DocType: Employee,Salary Mode,Modalità di stipendio
apps/erpnext/erpnext/hub_node/page/hub/hub.js +67,Register,Registrare
DocType: Patient,Divorced,Divorced
DocType: Buying Settings,Allow Item to be added multiple times in a transaction,Consenti di aggiungere lo stesso articolo più volte in una transazione
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +33,Cancel Material Visit {0} before cancelling this Warranty Claim,Annulla Materiale Visita {0} prima di annullare questa rivendicazione di Garanzia
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +19,Consumer Products,Prodotti di consumo
DocType: Purchase Receipt,Subscription Detail,Dettaglio dell&#39;abbonamento
DocType: Supplier Scorecard,Notify Supplier,Notificare il fornitore
DocType: Item,Customer Items,Articoli clienti
DocType: Project,Costing and Billing,Costi e Fatturazione
apps/erpnext/erpnext/accounts/doctype/account/account.py +48,Account {0}: Parent account {1} can not be a ledger,Il Conto {0}: conto derivato {1} non può essere un libro mastro
DocType: Item,Publish Item to hub.erpnext.com,Pubblicare Item a hub.erpnext.com
apps/erpnext/erpnext/config/setup.py +88,Email Notifications,Notifiche e-mail
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +26,Evaluation,Valorizzazione
DocType: Item,Default Unit of Measure,Unità di Misura Predefinita
DocType: SMS Center,All Sales Partner Contact,Tutte i contatti Partner vendite
DocType: Employee,Leave Approvers,Responsabili ferie
DocType: Sales Partner,Dealer,Rivenditore
DocType: Consultation,Investigations,indagini
DocType: Restaurant Order Entry,Click Enter To Add,Fare clic su Invio per aggiungere
DocType: Employee,Rented,Affittato
DocType: Purchase Order,PO-,PO-
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +216,"Stopped Production Order cannot be cancelled, Unstop it first to cancel","Produzione Arrestato Ordine non può essere annullato, Unstop è prima di cancellare"
DocType: Vehicle Service,Mileage,Chilometraggio
apps/erpnext/erpnext/assets/doctype/asset/asset.js +240,Do you really want to scrap this asset?,Vuoi davvero di accantonare questo bene?
DocType: Drug Prescription,Update Schedule,Aggiorna la pianificazione
apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +44,Select Default Supplier,Selezionare il Fornitore predefinito
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +37,Currency is required for Price List {0},E' necessario specificare la  valuta per il listino prezzi {0}
DocType: Sales Taxes and Charges Template,* Will be calculated in the transaction.,* Sarà calcolato nella transazione
DocType: Purchase Order,Customer Contact,Customer Contact
DocType: Patient Appointment,Check availability,Verificare la disponibilità
DocType: Job Applicant,Job Applicant,Candidati
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +6,This is based on transactions against this Supplier. See timeline below for details,Questo si basa su operazioni relative a questo fornitore. Vedere cronologia sotto per i dettagli
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +120,Legal,legale
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +191,Actual type tax cannot be included in Item rate in row {0},Il tipo di imposta / tassa non può essere inclusa nella tariffa della riga {0}
DocType: Bank Guarantee,Customer,Cliente
DocType: Purchase Receipt Item,Required By,Richiesto da
DocType: Delivery Note,Return Against Delivery Note,Di ritorno contro Consegna Nota
DocType: Purchase Order,% Billed,% Fatturato
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +43,Exchange Rate must be same as {0} {1} ({2}),Tasso di cambio deve essere uguale a {0} {1} ({2})
DocType: Sales Invoice,Customer Name,Nome Cliente
DocType: Vehicle,Natural Gas,Gas naturale
apps/erpnext/erpnext/setup/setup_wizard/operations/company_setup.py +64,Bank account cannot be named as {0},Il Conto bancario non si può chiamare {0}
DocType: Account,Heads (or groups) against which Accounting Entries are made and balances are maintained.,Soci (o società) per le quali le scritture contabili sono fatte e i saldi vengono mantenuti.
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +196,Outstanding for {0} cannot be less than zero ({1}),In sospeso per {0} non può essere inferiore a zero ( {1} )
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +343,There are no submitted Salary Slips to process.,Non ci sono pagamenti salariati da elaborare.
DocType: Manufacturing Settings,Default 10 mins,Predefinito 10 minuti
DocType: Leave Type,Leave Type Name,Lascia Tipo Nome
apps/erpnext/erpnext/templates/pages/projects.js +62,Show open,Mostra aperta
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +8,It is necessary to take this action today itself for the above mentioned recurring,È necessario prendere questa azione oggi stessa per quanto sopra riportato
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +151,Series Updated Successfully,Serie Aggiornato con successo
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +18,Checkout,Check-out
DocType: Pricing Rule,Apply On,applicare On
DocType: Item Price,Multiple Item prices.,Prezzi Articolo Multipli
,Purchase Order Items To Be Received,Articolo dell'Ordine di Acquisto da ricevere
DocType: SMS Center,All Supplier Contact,Tutti i Contatti Fornitori
DocType: Support Settings,Support Settings,Impostazioni di supporto
apps/erpnext/erpnext/projects/doctype/project/project.py +72,Expected End Date can not be less than Expected Start Date,Data fine prevista non può essere inferiore a quella prevista data di inizio
apps/erpnext/erpnext/utilities/transaction_base.py +110,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Riga #{0}: il Rapporto deve essere lo stesso di {1}: {2} ({3} / {4})
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +282,New Leave Application,Nuovo Lascia Application
,Batch Item Expiry Status,Batch Item scadenza di stato
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +184,Bank Draft,Assegno Bancario
DocType: Membership,membership validaty section,sezione validaty di appartenenza
DocType: Mode of Payment Account,Mode of Payment Account,Modalità di pagamento Conto
DocType: Consultation,Consultation,Consultazione
DocType: Accounts Settings,Show Payment Schedule in Print,Mostra programma pagamenti in stampa
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +19,Sales and Returns,Vendite e restituzioni
apps/erpnext/erpnext/stock/doctype/item/item.js +56,Show Variants,Mostra Varianti
DocType: Academic Term,Academic Term,Termine Accademico
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +14,Material,Materiale
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +66,Making website,Fare un sito web
DocType: Opening Invoice Creation Tool Item,Quantity,Quantità
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +544,Accounts table cannot be blank.,La tabella dei conti non può essere vuota.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +154,Loans (Liabilities),Prestiti (passività )
DocType: Employee Education,Year of Passing,Anni dal superamento
DocType: Item,Country of Origin,Paese d&#39;origine
DocType: Soil Texture,Soil Texture Criteria,Criteri di consistenza del suolo
apps/erpnext/erpnext/templates/includes/product_page.js +24,In Stock,In Magazzino
apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +16,Primary Contact Details,Dettagli del contatto principale
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +46,Open Issues,Controversia Aperta
DocType: Production Plan Item,Production Plan Item,Produzione Piano Voce
apps/erpnext/erpnext/hr/doctype/employee/employee.py +149,User {0} is already assigned to Employee {1},Utente {0} è già assegnato a Employee {1}
DocType: Lab Test Groups,Add new line,Aggiungi nuova riga
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +31,Health Care,Assistenza Sanitaria
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +65,Delay in payment (Days),Ritardo nel pagamento (Giorni)
DocType: Payment Terms Template Detail,Payment Terms Template Detail,Termini di pagamento Dettagli del modello
DocType: Lab Prescription,Lab Prescription,Prescrizione di laboratorio
apps/erpnext/erpnext/hub_node/page/hub/hub.js +185,Sort by Price,Ordina per Prezzo
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +26,Service Expense,spese per servizi
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +893,Serial Number: {0} is already referenced in Sales Invoice: {1},Numero di serie: {0} è già indicato nella fattura di vendita: {1}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +874,Invoice,Fattura
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +109,Make Retention Stock Entry,Effettua la registrazione di stock di conservazione
DocType: Purchase Invoice Item,Item Weight Details,Dettagli peso articolo
DocType: Asset Maintenance Log,Periodicity,Periodicità
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +21,Fiscal Year {0} is required,Fiscal Year {0} è richiesto
DocType: Crop Cycle,The minimum distance between rows of plants for optimum growth,La distanza minima tra le file di piante per una crescita ottimale
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +21,Defense,Difesa
DocType: Salary Component,Abbr,Abbr
DocType: Appraisal Goal,Score (0-5),Punteggio (0-5)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +223,Row {0}: {1} {2} does not match with {3},Riga {0}: {1} {2} non corrisponde con {3}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +75,Row # {0}:,Row # {0}:
DocType: Timesheet,Total Costing Amount,Importo totale Costing
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51,Customer &gt; Customer Group &gt; Territory,Cliente&gt; Gruppo clienti&gt; Territorio
DocType: Delivery Note,Vehicle No,Veicolo No
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +160,Please select Price List,Seleziona Listino Prezzi
DocType: Accounts Settings,Currency Exchange Settings,Impostazioni di cambio valuta
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +78,Row #{0}: Payment document is required to complete the trasaction,Row # {0}: documento pagamento è richiesto per completare la trasaction
DocType: Production Order Operation,Work In Progress,Lavori in corso
apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +13,Please select date,Seleziona la data
DocType: Employee,Holiday List,Elenco vacanza
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +127,Accountant,Ragioniere
DocType: Hub Settings,Selling Price List,Listino prezzi di vendita
DocType: Patient,Tobacco Current Use,Uso corrente di tabacco
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +21,Selling Rate,Tasso di vendita
DocType: Cost Center,Stock User,Utente Giacenze
DocType: Soil Analysis,(Ca+Mg)/K,(Ca + Mg) / K
DocType: Company,Phone No,N. di telefono
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +237,New {0}: #{1},Nuova {0}: # {1}
DocType: Delivery Trip,Initial Email Notification Sent,Notifica email iniziale inviata
,Sales Partners Commission,Vendite Partners Commissione
DocType: Soil Texture,Sandy Clay Loam,Sandy Clay Loam
DocType: Purchase Invoice,Rounding Adjustment,Regolazione arrotondamento
apps/erpnext/erpnext/setup/doctype/company/company.py +45,Abbreviation cannot have more than 5 characters,Le abbreviazioni non possono avere più di 5 caratteri
DocType: Physician Schedule Time Slot,Physician Schedule Time Slot,Slot di orario di programmazione medico
DocType: Payment Request,Payment Request,Richiesta di Pagamento
DocType: Asset,Value After Depreciation,Valore Dopo ammortamenti
DocType: Student,O+,O +
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt_dashboard.py +18,Related,Correlata
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +43,Attendance date can not be less than employee's joining date,Data la frequenza non può essere inferiore a quella di unirsi del dipendente
DocType: Grading Scale,Grading Scale Name,Grading Scale Nome
DocType: Subscription,Repeat on Day,Ripetere il giorno
apps/erpnext/erpnext/accounts/doctype/account/account.js +41,This is a root account and cannot be edited.,Questo è un account di root e non può essere modificato .
DocType: Sales Invoice,Company Address,indirizzo aziendale
DocType: BOM,Operations,Operazioni
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +38,Cannot set authorization on basis of Discount for {0},Impossibile impostare autorizzazione sulla base di Sconto per {0}
DocType: Rename Tool,"Attach .csv file with two columns, one for the old name and one for the new name","Allega file .csv con due colonne, una per il vecchio nome e uno per il nuovo nome"
apps/erpnext/erpnext/accounts/utils.py +73,{0} {1} not in any active Fiscal Year.,{0} {1} non presente in alcun Anno Fiscale attivo.
DocType: Packed Item,Parent Detail docname,Parent Dettaglio docname
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +69,"Reference: {0}, Item Code: {1} and Customer: {2}","Riferimento: {0}, codice dell&#39;articolo: {1} e cliente: {2}"
apps/erpnext/erpnext/utilities/user_progress.py +143,Kg,Kg
apps/erpnext/erpnext/config/hr.py +45,Opening for a Job.,Apertura di un lavoro.
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +103,BOM is not specified for subcontracting item {0} at row {1},La distinta componenti non viene specificata per l&#39;articolo conto terzi {0} alla riga {1}
apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +149,{0} Result submittted,{0} Risultato inviato
DocType: Item Attribute,Increment,Incremento
apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js +61,Timespan,Arco di tempo
apps/erpnext/erpnext/public/js/stock_analytics.js +61,Select Warehouse...,Seleziona Magazzino ...
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +6,Advertising,pubblicità
apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +22,Same Company is entered more than once,La stessa azienda viene inserito più di una volta
DocType: Patient,Married,Sposato
apps/erpnext/erpnext/accounts/party.py +44,Not permitted for {0},Non consentito per {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +593,Get items from,Ottenere elementi dal
DocType: Price List,Price Not UOM Dependant,Prezzo non dipendente da UOM
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +461,Stock cannot be updated against Delivery Note {0},Stock non può essere aggiornata contro Consegna Nota {0}
apps/erpnext/erpnext/templates/pages/home.py +25,Product {0},Prodotto {0}
apps/erpnext/erpnext/templates/generators/item_group.html +43,No items listed,Nessun elemento elencato
DocType: Asset Repair,Error Description,Descrizione dell&#39;errore
DocType: Payment Reconciliation,Reconcile,conciliare
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +30,Grocery,Drogheria
DocType: Quality Inspection Reading,Reading 1,Lettura 1
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +40,Pension Funds,Fondi Pensione
apps/erpnext/erpnext/assets/doctype/asset/asset.py +88,Next Depreciation Date cannot be before Purchase Date,La data di ammortamento successivo non puó essere prima della Data di acquisto
DocType: Crop,Perennial,Perenne
DocType: Consultation,Consultation Date,Data di consultazione
apps/erpnext/erpnext/hub_node/page/hub/hub.js +131,Product listing and discovery for ERPNext users,Elenco e scoperta di prodotti per gli utenti di ERPNext
DocType: SMS Center,All Sales Person,Tutti i Venditori
DocType: Monthly Distribution,**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,"** Distribuzione mensile ** aiuta a distribuire il Budget / Target nei mesi, nel caso di di business stagionali."
apps/erpnext/erpnext/accounts/page/pos/pos.js +1742,Not items found,Non articoli trovati
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +183,Salary Structure Missing,Stipendio Struttura mancante
DocType: Lead,Person Name,Nome della Persona
DocType: Sales Invoice Item,Sales Invoice Item,Articolo della Fattura di Vendita
DocType: Account,Credit,Avere
DocType: POS Profile,Write Off Cost Center,Centro di costo Svalutazioni
apps/erpnext/erpnext/public/js/setup_wizard.js +117,"e.g. ""Primary School"" or ""University""","ad esempio, ""Scuola Elementare"" o ""Università"""
apps/erpnext/erpnext/config/stock.py +28,Stock Reports,Reports Magazzino
DocType: Warehouse,Warehouse Detail,Dettagli Magazzino
apps/erpnext/erpnext/selling/doctype/customer/customer.py +192,Credit limit has been crossed for customer {0} {1}/{2},Limite di credito è stato attraversato per il cliente {0} {1} / {2}
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +33,The Term End Date cannot be later than the Year End Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,Il Data Terminologia fine non può essere successiva alla data di fine anno dell&#39;anno accademico a cui il termine è legata (Anno Accademico {}). Si prega di correggere le date e riprovare.
apps/erpnext/erpnext/stock/doctype/item/item.py +258,"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","""E' un Asset"" non può essere deselezionato, in quanto esiste già un movimento collegato"
DocType: Delivery Trip,Departure Time,Orario di partenza
DocType: Vehicle Service,Brake Oil,olio freno
DocType: Tax Rule,Tax Type,Tipo fiscale
apps/erpnext/erpnext/controllers/taxes_and_totals.py +561,Taxable Amount,Importo tassabile
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +160,You are not authorized to add or update entries before {0},Non sei autorizzato ad aggiungere o aggiornare le voci prima di {0}
DocType: BOM,Item Image (if not slideshow),Immagine Articolo (se non slideshow)
DocType: Production Order Operation,(Hour Rate / 60) * Actual Operation Time,(Tasso Orario / 60) * tempo operazione effettivo
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1076,Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Riga # {0}: Il tipo di documento di riferimento deve essere uno dei requisiti di spesa o voce del giornale
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +964,Select BOM,Seleziona la Distinta Materiali
DocType: SMS Log,SMS Log,SMS Log
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Delivered Items,Costo di oggetti consegnati
apps/erpnext/erpnext/config/hr.py +127,Manage advance amount given to the Employee,Gestisci l&#39;importo anticipato dato al Dipendente
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +38,The holiday on {0} is not between From Date and To Date,La vacanza su {0} non è tra da Data e A Data
DocType: Student Log,Student Log,Student Log
DocType: Quality Inspection,Get Specification Details,Ottieni Specifiche Dettagli
apps/erpnext/erpnext/config/buying.py +165,Templates of supplier standings.,Modelli di classifica dei fornitori.
DocType: Lead,Interested,Interessati
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +219,Opening,Apertura
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +29,From {0} to {1},Da {0} a {1}
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +50,Failed to setup taxes,Impossibile impostare le tasse
DocType: Item,Copy From Item Group,Copia da Gruppo Articoli
DocType: Delivery Trip,Delivery Notification,Notifica di consegna
DocType: Journal Entry,Opening Entry,Apertura Entry
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +25,Account Pay Only,Solo conto pay
DocType: Employee Loan,Repay Over Number of Periods,Rimborsare corso Numero di periodi
DocType: Stock Entry,Additional Costs,Costi aggiuntivi
apps/erpnext/erpnext/accounts/doctype/account/account.py +140,Account with existing transaction can not be converted to group.,Account con transazioni registrate non può essere convertito a gruppo.
DocType: Lead,Product Enquiry,Richiesta di informazioni sui prodotti
DocType: Education Settings,Validate Batch for Students in Student Group,Convalida il gruppo per gli studenti del gruppo studente
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +35,No leave record found for employee {0} for {1},Nessun record congedo trovato per dipendente {0} per {1}
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +23,Please enter company first,Inserisci prima azienda
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +366,Please select Company first,Seleziona prima azienda
DocType: Employee Education,Under Graduate,Laureando
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.js +27,Target On,obiettivo On
DocType: BOM,Total Cost,Costo totale
DocType: Soil Analysis,Ca/K,Ca / K
DocType: Journal Entry Account,Employee Loan,prestito dipendenti
DocType: Fee Schedule,Send Payment Request Email,Invia la richiesta di pagamento
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +259,Item {0} does not exist in the system or has expired,L'articolo {0} non esiste nel sistema o è scaduto
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +44,Real Estate,Immobiliare
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +1,Statement of Account,Estratto conto
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +41,Pharmaceuticals,Farmaceutici
DocType: Purchase Invoice Item,Is Fixed Asset,E' un Bene Strumentale
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +251,"Available qty is {0}, you need {1}","Disponibile Quantità è {0}, è necessario {1}"
DocType: Expense Claim Detail,Claim Amount,Importo Reclamo
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +56,Duplicate customer group found in the cutomer group table,Gruppo di clienti duplicato trovato nella tabella gruppo cutomer
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +31,Supplier Type / Supplier,Fornitore Tipo / Fornitore
DocType: Naming Series,Prefix,Prefisso
apps/erpnext/erpnext/hr/email_alert/training_scheduled/training_scheduled.html +7,Event Location,Posizione dell&#39;evento
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +68,Consumable,Consumabile
DocType: Student,B-,B-
DocType: Production Planning Tool,Pull Material Request of type Manufacture based on the above criteria,Tirare Materiale Richiesta di tipo Produzione sulla base dei criteri di cui sopra
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +100,Successfully unregistered.,Registrazione cancellata con successo.
DocType: Assessment Result,Grade,Grado
DocType: Restaurant Table,No of Seats,No delle sedute
DocType: Subscription,"To add dynamic subject, use jinja tags like

<div><pre><code>New {{ doc.doctype }} #{{ doc.name }}</code></pre></div>","Per aggiungere argomento dinamico, utilizzare i tag jinja come <div><pre> <code>New {{ doc.doctype }} #{{ doc.name }}</code> </pre> </div>"
DocType: Sales Invoice Item,Delivered By Supplier,Consegnato dal Fornitore
DocType: Asset Maintenance Task,Asset Maintenance Task,Attività di manutenzione degli asset
DocType: SMS Center,All Contact,Tutti i contatti
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +952,Production Order already created for all items with BOM,Ordine di produzione già creato per tutti gli elementi con BOM
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +230,Annual Salary,Stipendio Annuo
DocType: Daily Work Summary,Daily Work Summary,Riepilogo lavori giornaliero
DocType: Period Closing Voucher,Closing Fiscal Year,Chiusura Anno Fiscale
apps/erpnext/erpnext/accounts/party.py +380,{0} {1} is frozen,{0} {1} è bloccato
apps/erpnext/erpnext/setup/doctype/company/company.py +129,Please select Existing Company for creating Chart of Accounts,Seleziona esistente Società per la creazione di piano dei conti
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +80,Stock Expenses,Spese di stoccaggio
apps/erpnext/erpnext/stock/doctype/batch/batch.js +103,Select Target Warehouse,Seleziona il Magazzino di Destinazione
apps/erpnext/erpnext/hr/doctype/employee/employee.js +80,Please enter Preferred Contact Email,Inserisci il contatto preferito Email
DocType: Journal Entry,Contra Entry,Contra Entry
DocType: Journal Entry Account,Credit in Company Currency,Credito in Società Valuta
DocType: Lab Test UOM,Lab Test UOM,Lab Test UOM
DocType: Delivery Note,Installation Status,Stato di installazione
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +135,"Do you want to update attendance?<br>Present: {0}\
					<br>Absent: {1}",Vuoi aggiornare presenze? <br> Presente: {0} \ <br> Assente: {1}
apps/erpnext/erpnext/controllers/buying_controller.py +326,Accepted + Rejected Qty must be equal to Received quantity for Item {0},Quantità accettata + rifiutata deve essere uguale alla quantità ricevuta per {0}
DocType: Request for Quotation,RFQ-,RFQ-
DocType: Item,Supply Raw Materials for Purchase,Fornire Materie Prime per l'Acquisto
DocType: Agriculture Analysis Criteria,Fertilizer,Fertilizzante
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +150,At least one mode of payment is required for POS invoice.,è richiesta almeno una modalità di pagamento per POS fattura.
DocType: Products Settings,Show Products as a List,Mostra prodotti sotto forma di elenco
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +507,Item {0} is not active or end of life has been reached,L'articolo {0} non è attivo o la fine della vita è stato raggiunta
DocType: Student Admission Program,Minimum Age,Età minima
apps/erpnext/erpnext/utilities/user_progress.py +187,Example: Basic Mathematics,Esempio: Matematica di base
apps/erpnext/erpnext/controllers/accounts_controller.py +769,"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","Per includere fiscale in riga {0} in rate articolo , tasse nelle righe {1} devono essere inclusi"
apps/erpnext/erpnext/config/hr.py +223,Settings for HR Module,Impostazioni per il modulo HR
DocType: SMS Center,SMS Center,Centro SMS
DocType: Sales Invoice,Change Amount,quantità di modifica
DocType: BOM Update Tool,New BOM,Nuova Distinta Base
DocType: Driver,Driving License Categories,Categorie di patenti di guida
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +118,Please enter Delivery Date,Inserisci la data di consegna
DocType: Depreciation Schedule,Make Depreciation Entry,Crea una scrittura per l'ammortamento
DocType: Appraisal Template Goal,KRA,KRA
DocType: Lead,Request Type,Tipo di richiesta
apps/erpnext/erpnext/hr/doctype/offer_letter/offer_letter.js +17,Make Employee,Crea Dipendente
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +14,Broadcasting,emittente
apps/erpnext/erpnext/config/accounts.py +313,Setup mode of POS (Online / Offline),Imposta modalità del POS (Online / Offline)
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +191,Execution,esecuzione
apps/erpnext/erpnext/config/manufacturing.py +62,Details of the operations carried out.,I dettagli delle operazioni effettuate.
DocType: Asset Maintenance Log,Maintenance Status,Stato di manutenzione
apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +10,Membership Details,Dettagli iscrizione
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +56,{0} {1}: Supplier is required against Payable account {2},{0} {1}: Il campo Fornitore è richiesto per il conto di debito  {2}
apps/erpnext/erpnext/config/selling.py +52,Items and Pricing,Oggetti e prezzi
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +2,Total hours: {0},Ore totali: {0}
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +43,From Date should be within the Fiscal Year. Assuming From Date = {0},Dalla data deve essere entro l'anno fiscale. Assumendo Dalla Data = {0}
DocType: Drug Prescription,Interval,Intervallo
DocType: Grant Application,Individual,Individuale
DocType: Academic Term,Academics User,Utenti accademici
DocType: Cheque Print Template,Amount In Figure,Importo Nella figura
DocType: Employee Loan Application,Loan Info,Info prestito
apps/erpnext/erpnext/config/maintenance.py +12,Plan for maintenance visits.,Piano per le visite di manutenzione.
DocType: Supplier Scorecard Period,Supplier Scorecard Period,Periodo del punteggio fornitore
DocType: POS Profile,Customer Groups,Gruppi clienti
apps/erpnext/erpnext/public/js/financial_statements.js +51,Financial Statements,Bilancio d&#39;esercizio
DocType: Guardian,Students,Alunni
apps/erpnext/erpnext/config/selling.py +91,Rules for applying pricing and discount.,Le modalità di applicazione di prezzi e sconti .
DocType: Physician Schedule,Time Slots,Fasce orarie
apps/erpnext/erpnext/stock/doctype/price_list/price_list.py +14,Price List must be applicable for Buying or Selling,Prezzo di listino deve essere applicabile per l'acquisto o la vendita di
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +79,Installation date cannot be before delivery date for Item {0},Data di installazione non può essere prima della data di consegna per la voce {0}
DocType: Pricing Rule,Discount on Price List Rate (%),Sconto su Prezzo di Listino (%)
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +112,Item Template,Modello di oggetto
apps/erpnext/erpnext/healthcare/setup.py +215,Biochemistry,Biochimica
DocType: Offer Letter,Select Terms and Conditions,Selezionare i Termini e Condizioni
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +70,Out Value,Valore out
DocType: Production Planning Tool,Sales Orders,Ordini di vendita
DocType: Purchase Taxes and Charges,Valuation,Valorizzazione
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +373,Set as Default,Imposta come predefinito
,Purchase Order Trends,Acquisto Tendenze Ordine
apps/erpnext/erpnext/utilities/user_progress.py +75,Go to Customers,Vai ai clienti
apps/erpnext/erpnext/templates/emails/request_for_quotation.html +7,The request for quotation can be accessed by clicking on the following link,Accedere alla richiesta di offerta cliccando sul seguente link
apps/erpnext/erpnext/config/hr.py +81,Allocate leaves for the year.,Assegnare le foglie per l' anno.
DocType: SG Creation Tool Course,SG Creation Tool Course,SG Corso strumento di creazione
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +253,Insufficient Stock,insufficiente della
DocType: Manufacturing Settings,Disable Capacity Planning and Time Tracking,Capacity Planning e Disabilita Time Tracking
DocType: Email Digest,New Sales Orders,Nuovi Ordini di vendita
DocType: Bank Guarantee,Bank Account,Conto Bancario
DocType: Leave Type,Allow Negative Balance,Consentire Bilancio Negativo
apps/erpnext/erpnext/projects/doctype/project_type/project_type.py +13,You cannot delete Project Type 'External',Non è possibile eliminare il tipo di progetto &#39;Esterno&#39;
DocType: Employee,Create User,Creare un utente
DocType: Selling Settings,Default Territory,Territorio Predefinito
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +53,Television,televisione
DocType: Production Order Operation,Updated via 'Time Log',Aggiornato con 'Time Log'
apps/erpnext/erpnext/controllers/taxes_and_totals.py +428,Advance amount cannot be greater than {0} {1},importo anticipato non può essere maggiore di {0} {1}
DocType: Naming Series,Series List for this Transaction,Lista Serie per questa transazione
DocType: Company,Enable Perpetual Inventory,Abilita inventario perpetuo
DocType: Company,Default Payroll Payable Account,Payroll di mora dovuti account
apps/erpnext/erpnext/education/doctype/student_group/student_group.js +51,Update Email Group,Aggiorna Gruppo Email
DocType: Sales Invoice,Is Opening Entry,Sta aprendo Entry
DocType: Lab Test Template,"If unchecked, the item wont be appear in Sales Invoice, but can be used in group test creation. ","Se non è selezionato, l&#39;elemento non verrà visualizzato in fattura di vendita, ma può essere utilizzato nella creazione di test di gruppo."
DocType: Customer Group,Mention if non-standard receivable account applicable,Menzione se conto credito non standard applicabile
DocType: Course Schedule,Instructor Name,Istruttore Nome
DocType: Supplier Scorecard,Criteria Setup,Criteri di installazione
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +199,For Warehouse is required before Submit,Prima della conferma inserire per Magazzino
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +8,Received On,Ricevuto On
DocType: Sales Partner,Reseller,Rivenditore
DocType: Codification Table,Medical Code,Codice medico
DocType: Production Planning Tool,"If checked, Will include non-stock items in the Material Requests.","Se selezionato, comprenderà gli elementi non-azione nelle richieste dei materiali."
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +20,Please enter Company,Inserisci Società
DocType: Delivery Note Item,Against Sales Invoice Item,a fronte dell'Articolo della Fattura di Vendita
DocType: Agriculture Analysis Criteria,Linked Doctype,Docty collegato
,Production Orders in Progress,Ordini di produzione in corso
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +39,Net Cash from Financing,Di cassa netto da finanziamento
apps/erpnext/erpnext/accounts/page/pos/pos.js +2332,"LocalStorage is full , did not save","LocalStorage è piena, non ha salvato"
DocType: Lead,Address & Contact,Indirizzo e Contatto
DocType: Leave Allocation,Add unused leaves from previous allocations,Aggiungere le foglie non utilizzate precedentemente assegnata
DocType: Sales Partner,Partner website,sito web partner
DocType: Restaurant Order Entry,Add Item,Aggiungi articolo
DocType: Lab Test,Custom Result,Risultato personalizzato
DocType: Delivery Stop,Contact Name,Nome Contatto
DocType: Course Assessment Criteria,Course Assessment Criteria,Criteri di valutazione del corso
DocType: POS Customer Group,POS Customer Group,POS Gruppi clienti
DocType: Land Unit,Land Unit describing various land assets,Unità di terra che descrive vari beni terreni
DocType: Cheque Print Template,Line spacing for amount in words,interlinea per importo in lettere
DocType: Vehicle,Additional Details,dettagli aggiuntivi
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +11,Assessment Plan: ,Piano di valutazione:
apps/erpnext/erpnext/templates/generators/bom.html +85,No description given,Nessuna descrizione fornita
apps/erpnext/erpnext/config/buying.py +13,Request for purchase.,Richiesta di acquisto.
DocType: Lab Test,Submitted Date,Data di invio
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +6,This is based on the Time Sheets created against this project,Questo si basa sulla tabella dei tempi create contro questo progetto
DocType: Payment Term,Credit Months,Mesi di credito
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +409,Net Pay cannot be less than 0,Retribuzione netta non può essere inferiore a 0
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5,"To stop sending repetitive error notifications from the system, we have checked Disabled field in the subscription","Per interrompere l&#39;invio di notifiche di errore ripetitive dal sistema, abbiamo verificato il campo Disabled nel sottoscrizione"
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +224,Only the selected Leave Approver can submit this Leave Application,Solo il responsabile ferie scelto può sottoporre questa richiesta di ferie
apps/erpnext/erpnext/hr/doctype/employee/employee.py +121,Relieving Date must be greater than Date of Joining,Data Alleviare deve essere maggiore di Data di giunzione
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +238,Leaves per Year,Ferie per Anno
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +128,Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,Riga {0}: Abilita 'è Advance' contro Account {1} se questa è una voce di anticipo.
apps/erpnext/erpnext/stock/utils.py +217,Warehouse {0} does not belong to company {1},Deposito {0} non appartiene alla società {1}
DocType: Email Digest,Profit & Loss,Profit &amp; Loss
apps/erpnext/erpnext/utilities/user_progress.py +144,Litre,Litro
DocType: Task,Total Costing Amount (via Time Sheet),Totale Costing Importo (tramite Time Sheet)
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +69,Please setup Students under Student Groups,Impostare gli studenti in gruppi di studenti
DocType: Item Website Specification,Item Website Specification,Specifica da Sito Web dell'articolo
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +477,Leave Blocked,Lascia Bloccato
apps/erpnext/erpnext/stock/doctype/item/item.py +709,Item {0} has reached its end of life on {1},L'articolo {0} ha raggiunto la fine della sua vita su {1}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +99,Bank Entries,Registrazioni bancarie
DocType: Crop,Annual,annuale
DocType: Stock Reconciliation Item,Stock Reconciliation Item,Voce Riconciliazione Giacenza
DocType: Stock Entry,Sales Invoice No,Fattura di Vendita n.
DocType: Material Request Item,Min Order Qty,Qtà Minima Ordine
DocType: Student Group Creation Tool Course,Student Group Creation Tool Course,Corso di Gruppo Student strumento di creazione
DocType: Lead,Do Not Contact,Non Contattaci
apps/erpnext/erpnext/utilities/user_progress.py +207,People who teach at your organisation,Le persone che insegnano presso la propria organizzazione
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +135,Software Developer,Software Developer
DocType: Item,Minimum Order Qty,Qtà ordine minimo
DocType: Pricing Rule,Supplier Type,Tipo Fornitore
DocType: Course Scheduling Tool,Course Start Date,Data inizio corso
,Student Batch-Wise Attendance,Student Batch-Wise presenze
DocType: POS Profile,Allow user to edit Rate,Consenti all&#39;utente di modificare Tasso
DocType: Item,Publish in Hub,Pubblicare in Hub
DocType: Student Admission,Student Admission,L&#39;ammissione degli studenti
,Terretory,Territorio
apps/erpnext/erpnext/stock/doctype/item/item.py +729,Item {0} is cancelled,L'articolo {0} è annullato
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +948,Material Request,Richiesta materiale
DocType: Bank Reconciliation,Update Clearance Date,Aggiornare Liquidazione Data
DocType: Item,Purchase Details,"Acquisto, i dati"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +382,Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Articolo {0} non trovato tra le 'Materie Prime Fornite' tabella in Ordine di Acquisto {1}
DocType: Salary Slip,Total Principal Amount,Importo principale totale
DocType: Student Guardian,Relation,Relazione
DocType: Student Guardian,Mother,Madre
DocType: Restaurant Reservation,Reservation End Time,Termine di prenotazione
DocType: Crop,Biennial,Biennale
apps/erpnext/erpnext/config/selling.py +18,Confirmed orders from Customers.,Ordini Confermati da Clienti.
DocType: Purchase Receipt Item,Rejected Quantity,Rifiutato Quantità
apps/erpnext/erpnext/education/doctype/fees/fees.py +80,Payment request {0} created,La richiesta di pagamento {0} è stata creata
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72,Open Orders,Ordini aperti
apps/erpnext/erpnext/healthcare/setup.py +255,Low Sensitivity,Sensibilità bassa
DocType: Notification Control,Notification Control,Controllo di notifica
apps/erpnext/erpnext/templates/emails/training_event.html +17,Please confirm once you have completed your training,Si prega di confermare una volta completata la tua formazione
DocType: Lead,Suggestions,Suggerimenti
DocType: Territory,Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Impostare la voce del budget di Gruppo-saggi su questo territorio. È inoltre possibile includere la stagionalità impostando la distribuzione.
DocType: Payment Term,Payment Term Name,Nome del termine di pagamento
DocType: Healthcare Settings,Create documents for sample collection,Crea documenti per la raccolta di campioni
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +274,Payment against {0} {1} cannot be greater than Outstanding Amount {2},Il pagamento contro {0} {1} non può essere maggiore dell'importo dovuto {2}
DocType: Supplier,Address HTML,Indirizzo HTML
DocType: Lead,Mobile No.,Num. Cellulare
DocType: Maintenance Schedule,Generate Schedule,Genera Programma
DocType: Purchase Invoice Item,Expense Head,Conto
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +163,Please select Charge Type first,Seleziona il tipo di carica prima
DocType: Crop,"You can define all the tasks which need to carried out for this crop here. The day field is used to mention the day on which the task needs to be carried out, 1 being the 1st day, etc.. ","Puoi definire tutte le attività che devono essere eseguite per questo raccolto qui. Il campo del giorno viene utilizzato per indicare il giorno in cui è necessario eseguire l&#39;attività, 1 è il 1 ° giorno, ecc."
DocType: Student Group Student,Student Group Student,Student Student Group
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Latest,ultimo
DocType: Asset Maintenance Task,2 Yearly,2 anni
DocType: Education Settings,Education Settings,Impostazioni di educazione
DocType: Vehicle Service,Inspection,ispezione
DocType: Supplier Scorecard Scoring Standing,Max Grade,Max Grado
DocType: Email Digest,New Quotations,Nuovi Preventivi
DocType: HR Settings,Emails salary slip to employee based on preferred email selected in Employee,Messaggi di posta elettronica stipendio slittamento al dipendente sulla base di posta preferito selezionato a dipendenti
DocType: Employee,The first Leave Approver in the list will be set as the default Leave Approver,Il primo responsabile ferie della lista sarà impostato come il responsabile ferie di default
DocType: Tax Rule,Shipping County,Distretto di  Spedizione
apps/erpnext/erpnext/config/desktop.py +167,Learn,Guide
DocType: Asset,Next Depreciation Date,Data ammortamento successivo
apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js +3,Activity Cost per Employee,Costo attività per dipendente
DocType: Accounts Settings,Settings for Accounts,Impostazioni per gli account
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +667,Supplier Invoice No exists in Purchase Invoice {0},La Fattura Fornitore non esiste nella Fattura di Acquisto {0}
apps/erpnext/erpnext/config/selling.py +118,Manage Sales Person Tree.,Gestire venditori ad albero
DocType: Job Applicant,Cover Letter,Lettera di presentazione
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +37,Outstanding Cheques and Deposits to clear,Gli assegni in circolazione e depositi per cancellare
DocType: Item,Synced With Hub,Sincronizzati con Hub
DocType: Driver,Fleet Manager,Responsabile flotta aziendale
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +542,Row #{0}: {1} can not be negative for item {2},Row # {0}: {1} non può essere negativo per la voce {2}
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +59,Wrong Password,Password Errata
DocType: Item,Variant Of,Variante di
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +387,Completed Qty can not be greater than 'Qty to Manufacture',Completato Quantità non può essere maggiore di 'Quantità di Fabbricazione'
DocType: Period Closing Voucher,Closing Account Head,Chiudere Conto Primario
DocType: Employee,External Work History,Storia del lavoro esterno
DocType: Physician,Time per Appointment,Tempo per appuntamento
apps/erpnext/erpnext/projects/doctype/task/task.py +110,Circular Reference Error,Circular Error Reference
DocType: Appointment Type,Is Inpatient,È ospedaliero
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +55,Guardian1 Name,Nome Guardian1
DocType: Delivery Note,In Words (Export) will be visible once you save the Delivery Note.,In Parole (Export) sarà visibile una volta che si salva il DDT.
DocType: Cheque Print Template,Distance from left edge,Distanza dal bordo sinistro
apps/erpnext/erpnext/utilities/bot.py +29,{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} unità di [{1}](#Form/Item/{1}) trovate in [{2}](#Form/Warehouse/{2})
DocType: Lead,Industry,Industria
DocType: Employee,Job Profile,Profilo di lavoro
DocType: BOM Item,Rate & Amount,Tariffa e importo
apps/erpnext/erpnext/setup/doctype/company/company_dashboard.py +6,This is based on transactions against this Company. See timeline below for details,Questo si basa sulle transazioni contro questa Azienda. Vedere la sequenza temporale qui sotto per i dettagli
DocType: Stock Settings,Notify by Email on creation of automatic Material Request,Notifica tramite e-mail sulla creazione di Richiesta automatica Materiale
apps/erpnext/erpnext/healthcare/setup.py +259,Resistant,Resistente
DocType: Journal Entry,Multi Currency,Multi valuta
DocType: Opening Invoice Creation Tool,Invoice Type,Tipo Fattura
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +933,Delivery Note,Documento Di Trasporto
DocType: Consultation,Encounter Impression,Incontro impressione
apps/erpnext/erpnext/config/learn.py +82,Setting up Taxes,Impostazione Tasse
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +134,Cost of Sold Asset,Costo del bene venduto
DocType: Volunteer,Morning,Mattina
apps/erpnext/erpnext/accounts/utils.py +347,Payment Entry has been modified after you pulled it. Please pull it again.,Pagamento ingresso è stato modificato dopo l'tirato. Si prega di tirare di nuovo.
apps/erpnext/erpnext/stock/doctype/item/item.py +464,{0} entered twice in Item Tax,{0} inserito due volte in tassazione articolo
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +113,Summary for this week and pending activities,Riepilogo per questa settimana e le attività in corso
DocType: Student Applicant,Admitted,Ammesso
DocType: Workstation,Rent Cost,Affitto Costo
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +81,Amount After Depreciation,Importo Dopo ammortamento
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +97,Upcoming Calendar Events,Prossimi eventi del calendario
apps/erpnext/erpnext/public/js/templates/item_quick_entry.html +1,Variant Attributes,Attributi Variante
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +85,Please select month and year,Si prega di selezionare mese e anno
DocType: Employee,Company Email,azienda Email
DocType: GL Entry,Debit Amount in Account Currency,Importo Debito Account Valuta
DocType: Supplier Scorecard,Scoring Standings,Classificazione del punteggio
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +21,Order Value,Valore dell&#39;ordine
apps/erpnext/erpnext/config/accounts.py +27,Bank/Cash transactions against party or for internal transfer,Transazioni Banca/Cassa solo a favore di partner o per giroconto
DocType: Shipping Rule,Valid for Countries,Valido per paesi
apps/erpnext/erpnext/stock/doctype/item/item.js +55,This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set,Questo articolo è un modello e non può essere utilizzato nelle transazioni. Attributi Voce verranno copiate nelle varianti meno che sia impostato 'No Copy'
DocType: Grant Application,Grant Application,Richiesta di sovvenzione
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +69,Total Order Considered,Totale ordine Considerato
apps/erpnext/erpnext/config/hr.py +243,"Employee designation (e.g. CEO, Director etc.).","Titolo dipendente (p. es. amministratore delegato, direttore, CEO, ecc.)"
DocType: Sales Invoice,Rate at which Customer Currency is converted to customer's base currency,Tasso con cui la valuta Cliente viene convertita in valuta di base del cliente
DocType: Course Scheduling Tool,Course Scheduling Tool,Corso strumento Pianificazione
apps/erpnext/erpnext/controllers/accounts_controller.py +602,Row #{0}: Purchase Invoice cannot be made against an existing asset {1},Row # {0}: Acquisto fattura non può essere fatta contro un bene esistente {1}
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +255,[Urgent] Error while creating recurring %s for %s,[Urgente] Errore durante la creazione di% s ricorrenti per% s
DocType: Land Unit,LInked Analysis,Analisi di LInked
DocType: Item Tax,Tax Rate,Aliquota Fiscale
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +59,{0} already allocated for Employee {1} for period {2} to {3},{0} già allocato il dipendente {1} per il periodo {2} a {3}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +915,Select Item,Seleziona elemento
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +140,Purchase Invoice {0} is already submitted,La Fattura di Acquisto {0} è già stata presentata
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +91,Row # {0}: Batch No must be same as {1} {2},Fila # {0}: Lotto n deve essere uguale a {1} {2}
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +52,Convert to non-Group,Convert to non-Group
DocType: C-Form Invoice Detail,Invoice Date,Data Fattura
DocType: GL Entry,Debit Amount,Importo Debito
apps/erpnext/erpnext/accounts/party.py +251,There can only be 1 Account per Company in {0} {1},Ci può essere solo 1 account per ogni impresa in {0} {1}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +426,Please see attachment,Si prega di vedere allegato
DocType: Purchase Order,% Received,% Ricevuto
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +3,Create Student Groups,Creazione di gruppi di studenti
DocType: Volunteer,Weekends,Fine settimana
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +24,Credit Note Amount,Importo della nota di credito
DocType: Setup Progress Action,Action Document,Documento d&#39;azione
DocType: Chapter Member,Website URL,URL del sito web
,Finished Goods,Beni finiti
DocType: Delivery Note,Instructions,Istruzione
DocType: Quality Inspection,Inspected By,Verifica a cura di
DocType: Asset Maintenance Log,Maintenance Type,Tipo di manutenzione
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +45,{0} - {1} is not enrolled in the Course {2},{0} - {1} non è iscritto al corso {2}
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +59,Serial No {0} does not belong to Delivery Note {1},Serial No {0} non appartiene alla Consegna Nota {1}
apps/erpnext/erpnext/templates/pages/demo.html +47,ERPNext Demo,ERPNext Demo
apps/erpnext/erpnext/public/js/utils/item_selector.js +20,Add Items,Aggiungi Articoli
DocType: Item Quality Inspection Parameter,Item Quality Inspection Parameter,Voce di controllo di qualità dei parametri
DocType: Leave Application,Leave Approver Name,Nome responsabile ferie
DocType: Depreciation Schedule,Schedule Date,Programma Data
apps/erpnext/erpnext/config/hr.py +116,"Earnings, Deductions and other Salary components","Guadagni, deduzioni e altri componenti di stipendio"
DocType: Packed Item,Packed Item,Articoli imballato
apps/erpnext/erpnext/config/buying.py +65,Default settings for buying transactions.,Impostazioni predefinite per operazioni di acquisto .
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +29,Activity Cost exists for Employee {0} against Activity Type - {1},Costo attività trovato per dipendente {0} con tipo attività - {1}
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +14,Mandatory field - Get Students From,Campo obbligatorio - Prendi gli studenti da
DocType: Program Enrollment,Enrolled courses,Corsi iscritti
DocType: Currency Exchange,Currency Exchange,Cambio Valuta
DocType: Opening Invoice Creation Tool Item,Item Name,Nome Articolo
DocType: Authorization Rule,Approving User  (above authorized value),Approvazione utente (sopra il valore autorizzato)
DocType: Email Digest,Credit Balance,Balance Credit
DocType: Employee,Widowed,Vedovo
DocType: Request for Quotation,Request for Quotation,Richiesta di offerta
DocType: Healthcare Settings,Require Lab Test Approval,Richiede l&#39;approvazione di un test di laboratorio
DocType: Salary Slip Timesheet,Working Hours,Orari di lavoro
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +10,Total Outstanding,Assolutamente stupendo
DocType: Naming Series,Change the starting / current sequence number of an existing series.,Cambia l'inizio/numero sequenza corrente per una serie esistente
DocType: Dosage Strength,Strength,Forza
apps/erpnext/erpnext/accounts/page/pos/pos.js +1523,Create a new Customer,Creare un nuovo cliente
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +59,"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Se più regole dei prezzi continuano a prevalere, gli utenti sono invitati a impostare manualmente la priorità per risolvere il conflitto."
apps/erpnext/erpnext/utilities/activation.py +90,Create Purchase Orders,Creare ordini d&#39;acquisto
,Purchase Register,Registro Acquisti
DocType: Scheduling Tool,Rechedule,Rechedule
DocType: Landed Cost Item,Applicable Charges,Spese applicabili
DocType: Workstation,Consumable Cost,Costo consumabili
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +220,{0} ({1}) must have role 'Leave Approver',{0} ({1}) deve avere il ruolo 'Approvatore Ferie'
DocType: Purchase Receipt,Vehicle Date,Data Veicolo
DocType: Student Log,Medical,Medico
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +177,Reason for losing,Motivo per Perdere
apps/erpnext/erpnext/accounts/doctype/account/account.js +52,Update Account Number,Aggiorna il numero di conto
apps/erpnext/erpnext/crm/doctype/lead/lead.py +42,Lead Owner cannot be same as the Lead,Il proprietario del Lead non può essere il Lead stesso
apps/erpnext/erpnext/accounts/utils.py +353,Allocated amount can not greater than unadjusted amount,importo concesso non può maggiore del valore non aggiustato
DocType: Announcement,Receiver,Ricevitore
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +83,Workstation is closed on the following dates as per Holiday List: {0},Stazione di lavoro chiusa nei seguenti giorni secondo la lista delle vacanze: {0}
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +32,Opportunities,Opportunità
DocType: Lab Test Template,Single,Singolo
DocType: Salary Slip,Total Loan Repayment,Totale Rimborso prestito
DocType: Account,Cost of Goods Sold,Costo del venduto
DocType: Subscription,Yearly,Annuale
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +228,Please enter Cost Center,Inserisci Centro di costo
DocType: Drug Prescription,Dosage,Dosaggio
DocType: Journal Entry Account,Sales Order,Ordine di vendita
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +70,Avg. Selling Rate,Avg. Tasso di vendita
DocType: Assessment Plan,Examiner Name,Nome Examiner
DocType: Lab Test Template,No Result,Nessun risultato
DocType: Purchase Invoice Item,Quantity and Rate,Quantità e Prezzo
DocType: Delivery Note,% Installed,% Installato
apps/erpnext/erpnext/utilities/user_progress.py +227,Classrooms/ Laboratories etc where lectures can be scheduled.,Aule / Laboratori etc dove le lezioni possono essere programmati.
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +46,Please enter company name first,Inserisci il nome della società prima
DocType: Purchase Invoice,Supplier Name,Nome Fornitore
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +25,Read the ERPNext Manual,Leggere il manuale ERPNext
DocType: Account,Is Group,E' un Gruppo
DocType: Email Digest,Pending Purchase Orders,In attesa di ordini di acquisto
DocType: Stock Settings,Automatically Set Serial Nos based on FIFO,Imposta automaticamente seriale Nos sulla base FIFO
DocType: Accounts Settings,Check Supplier Invoice Number Uniqueness,Controllare l'unicità del numero fattura fornitore
apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +34,Primary Address Details,Dettagli indirizzo primario
DocType: Vehicle Service,Oil Change,Cambio olio
DocType: Asset Maintenance Log,Asset Maintenance Log,Registro di manutenzione delle risorse
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +57,'To Case No.' cannot be less than 'From Case No.','A Caso N.' non può essere minore di 'Da Caso N.'
DocType: Chapter,Non Profit,Non Profit
DocType: Production Order,Not Started,Non Iniziato
DocType: Lead,Channel Partner,Canale Partner
DocType: Account,Old Parent,Vecchio genitore
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +18,Mandatory field - Academic Year,Campo obbligatorio - Anno Accademico
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +209,{0} {1} is not associated with {2} {3},{0} {1} non è associato a {2} {3}
DocType: Notification Control,Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.,Personalizza testo di introduzione che andrà nell'email. Ogni transazione ha un introduzione distinta.
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +182,Please set default payable account for the company {0},Imposta il conto pagabile in default per la società {0}
DocType: Setup Progress Action,Min Doc Count,Min di Doc Doc
apps/erpnext/erpnext/config/manufacturing.py +84,Global settings for all manufacturing processes.,Impostazioni globali per tutti i processi produttivi.
DocType: Accounts Settings,Accounts Frozen Upto,Conti congelati fino al
DocType: SMS Log,Sent On,Inviata il
apps/erpnext/erpnext/stock/doctype/item/item.py +671,Attribute {0} selected multiple times in Attributes Table,Attributo {0} selezionato più volte in Attributi Tabella
DocType: HR Settings,Employee record is created using selected field. ,Record dipendente viene creato utilizzando campo selezionato.
DocType: Sales Order,Not Applicable,Non Applicabile
apps/erpnext/erpnext/config/hr.py +70,Holiday master.,Vacanza principale.
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +77,Opening Invoice Item,Articolo di fattura di apertura
DocType: Request for Quotation Item,Required Date,Data richiesta
DocType: Delivery Note,Billing Address,Indirizzo di fatturazione
DocType: BOM,Costing,Valutazione Costi
DocType: Tax Rule,Billing County,Contea di fatturazione
DocType: Purchase Taxes and Charges,"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Se selezionato, l&#39;importo della tassa sarà considerata già inclusa nel Stampa Valuta / Stampa Importo"
DocType: Request for Quotation,Message for Supplier,Messaggio per il Fornitore
DocType: Driver,DRIVER-.#####,DRIVER -. #####
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +48,Total Qty,Totale Quantità
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62,Guardian2 Email ID,Email ID Guardian2
DocType: Item,Show in Website (Variant),Show di Sito web (Variant)
DocType: Employee,Health Concerns,Preoccupazioni per la salute
DocType: Payroll Entry,Select Payroll Period,Seleziona Periodo Busta Paga
DocType: Purchase Invoice,Unpaid,Non pagata
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +49,Reserved for sale,Riservato per la vendita
DocType: Packing Slip,From Package No.,Da Pacchetto N.
DocType: Item Attribute,To Range,Per Intervallo
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +29,Securities and Deposits,I titoli e depositi
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +46,"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method","Impossibile modificare il metodo di valorizzazione, in quanto vi sono transazioni contro alcuni elementi che non hanno il proprio metodo di valorizzazione"
apps/erpnext/erpnext/config/healthcare.py +133,Test Sample Master.,Test Master del campione.
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +82,Total leaves allocated is mandatory,Foglie totali assegnate è obbligatoria
DocType: Patient,AB Positive,AB Positivo
DocType: Job Opening,Description of a Job Opening,Descrizione dell'Offerta di Lavoro
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +110,Pending activities for today,Attività di attesa per oggi
apps/erpnext/erpnext/config/hr.py +24,Attendance record.,Archivio Presenze
DocType: Salary Structure,Salary Component for timesheet based payroll.,Componente Stipendio per il libro paga base scheda attività.
DocType: Sales Order Item,Used for Production Plan,Usato per Piano di Produzione
DocType: Employee Loan,Total Payment,Pagamento totale
DocType: Manufacturing Settings,Time Between Operations (in mins),Tempo tra le operazioni (in minuti)
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +129,{0} {1} is cancelled so the action cannot be completed,{0} {1} viene annullato in modo che l&#39;azione non possa essere completata
DocType: Customer,Buyer of Goods and Services.,Buyer di beni e servizi.
DocType: Journal Entry,Accounts Payable,Conti pagabili
DocType: Patient,Allergies,allergie
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +30,The selected BOMs are not for the same item,Le distinte materiali selezionati non sono per la stessa voce
DocType: Supplier Scorecard Standing,Notify Other,Notifica Altro
DocType: Vital Signs,Blood Pressure (systolic),Pressione sanguigna (sistolica)
DocType: Pricing Rule,Valid Upto,Valido Fino
DocType: Training Event,Workshop,Laboratorio
DocType: Supplier Scorecard Scoring Standing,Warn Purchase Orders,Avvisa gli ordini di acquisto
apps/erpnext/erpnext/utilities/user_progress.py +64,List a few of your customers. They could be organizations or individuals.,Elencare alcuni dei vostri clienti . Potrebbero essere organizzazioni o individui .
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54,Supplier &gt; Supplier Type,Fornitore&gt; Tipo di fornitore
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +21,Enough Parts to Build,Parti abbastanza per costruire
DocType: POS Profile User,POS Profile User,Profilo utente POS
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +128,Direct Income,reddito diretta
DocType: Patient Appointment,Date TIme,Appuntamento
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +36,"Can not filter based on Account, if grouped by Account","Non è possibile filtrare sulla base di conto , se raggruppati per conto"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +130,Administrative Officer,responsabile amministrativo
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +39,Setting up company and taxes,Impostare società e tasse
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +22,Please select Course,Seleziona Corso
DocType: Codification Table,Codification Table,Tabella di codificazione
DocType: Timesheet Detail,Hrs,ore
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +350,Please select Company,Selezionare prego
DocType: Stock Entry Detail,Difference Account,account differenza
DocType: Purchase Invoice,Supplier GSTIN,Fornitore GSTIN
apps/erpnext/erpnext/projects/doctype/task/task.py +47,Cannot close task as its dependant task {0} is not closed.,Impossibile chiudere l'attività; esistono attività dipendenti {0} non completate.
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +433,Please enter Warehouse for which Material Request will be raised,Inserisci il Magazzino per cui Materiale richiesta sarà sollevata
DocType: Production Order,Additional Operating Cost,Ulteriori costi di esercizio
DocType: Lab Test Template,Lab Routine,Laboratorio di routine
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +20,Cosmetics,cosmetici
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +18,Please select Completion Date for Completed Asset Maintenance Log,Selezionare la data di completamento per il registro di manutenzione delle attività completato
apps/erpnext/erpnext/stock/doctype/item/item.py +526,"To merge, following properties must be same for both items","Per unire , seguenti proprietà devono essere uguali per entrambe le voci"
DocType: Shipping Rule,Net Weight,Peso netto
DocType: Employee,Emergency Phone,Telefono di emergenza
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +29,Buy,Acquistare
,Serial No Warranty Expiry,Serial No Garanzia di scadenza
DocType: Sales Invoice,Offline POS Name,Nome POS offline
apps/erpnext/erpnext/utilities/user_progress.py +177,Student Application,Applicazione per studenti
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +20,Please define grade for Threshold 0%,Definisci il grado per Soglia 0%
DocType: Sales Order,To Deliver,Da Consegnare
DocType: Purchase Invoice Item,Item,Articolo
apps/erpnext/erpnext/healthcare/setup.py +256,High Sensitivity,Alta sensibilità
apps/erpnext/erpnext/config/non_profit.py +48,Volunteer Type information.,Informazioni sul tipo di volontariato.
apps/erpnext/erpnext/accounts/page/pos/pos.js +2512,Serial no item cannot be a fraction,Serial nessun elemento non può essere una frazione
DocType: Journal Entry,Difference (Dr - Cr),Differenza ( Dr - Cr )
DocType: Account,Profit and Loss,Profitti e Perdite
DocType: Patient,Risk Factors,Fattori di rischio
DocType: Patient,Occupational Hazards and Environmental Factors,Pericoli professionali e fattori ambientali
DocType: Vital Signs,Respiratory rate,Frequenza respiratoria
apps/erpnext/erpnext/config/stock.py +330,Managing Subcontracting,Gestione conto lavoro / terzista
DocType: Vital Signs,Body Temperature,Temperatura corporea
DocType: Project,Project will be accessible on the website to these users,Progetto sarà accessibile sul sito web per questi utenti
DocType: Detected Disease,Disease,Malattia
apps/erpnext/erpnext/config/projects.py +24,Define Project type.,Definisci il tipo di progetto.
DocType: Supplier Scorecard,Weighting Function,Funzione di ponderazione
DocType: Physician,OP Consulting Charge,Carica di consulenza OP
apps/erpnext/erpnext/utilities/user_progress.py +25,Setup your ,Imposta il tuo
DocType: Quotation,Rate at which Price list currency is converted to company's base currency,Tasso al quale Listino valuta viene convertita in valuta di base dell&#39;azienda
apps/erpnext/erpnext/setup/doctype/company/company.py +62,Account {0} does not belong to company: {1},Il Conto {0} non appartiene alla società: {1}
apps/erpnext/erpnext/setup/doctype/company/company.py +51,Abbreviation already used for another company,Abbreviazione già utilizzata per un'altra società
DocType: Selling Settings,Default Customer Group,Gruppo Clienti Predefinito
DocType: Asset Repair,ARLOG-,ARLOG-
DocType: Global Defaults,"If disable, 'Rounded Total' field will not be visible in any transaction","Se disabilitare, &#39;Rounded totale&#39; campo non sarà visibile in qualsiasi transazione"
DocType: BOM,Operating Cost,Costo di gestione
DocType: Crop,Produced Items,Articoli prodotti
DocType: Sales Order Item,Gross Profit,Utile lordo
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +49,Increment cannot be 0,Incremento non può essere 0
DocType: Production Planning Tool,Material Requirement,Richiesta Materiale
DocType: Company,Delete Company Transactions,Elimina transazioni Azienda
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +351,Reference No and Reference Date is mandatory for Bank transaction,Di riferimento e di riferimento Data è obbligatoria per la transazione Bank
DocType: Purchase Receipt,Add / Edit Taxes and Charges,Aggiungere / Modificare tasse e ricarichi
DocType: Payment Entry Reference,Supplier Invoice No,Fattura Fornitore N.
DocType: Territory,For reference,Per riferimento
DocType: Healthcare Settings,Appointment Confirmation,Conferma dell&#39;appuntamento
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +158,"Cannot delete Serial No {0}, as it is used in stock transactions","Impossibile eliminare N. di serie {0}, come si usa in transazioni di borsa"
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +253,Closing (Cr),Chiusura (Cr)
apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +1,Hello,Ciao
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +110,Move Item,Sposta elemento
DocType: Serial No,Warranty Period (Days),Periodo di garanzia (Giorni)
DocType: Installation Note Item,Installation Note Item,Installazione Nota articolo
DocType: Production Plan Item,Pending Qty,In attesa Quantità
DocType: Budget,Ignore,Ignora
apps/erpnext/erpnext/accounts/party.py +384,{0} {1} is not active,{0} {1} non è attivo
apps/erpnext/erpnext/config/accounts.py +272,Setup cheque dimensions for printing,Configurazione Dimensioni Assegno per la stampa
DocType: Salary Slip,Salary Slip Timesheet,Stipendio slittamento Timesheet
apps/erpnext/erpnext/controllers/buying_controller.py +157,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Magazzino Fornitore obbligatorio per ricevuta d'acquisto del conto lavoro
DocType: Pricing Rule,Valid From,valido dal
DocType: Sales Invoice,Total Commission,Commissione Totale
DocType: Pricing Rule,Sales Partner,Partner vendite
apps/erpnext/erpnext/config/buying.py +150,All Supplier scorecards.,Tutti i punteggi dei fornitori.
DocType: Buying Settings,Purchase Receipt Required,Ricevuta di Acquisto necessaria
apps/erpnext/erpnext/stock/doctype/item/item.py +144,Valuation Rate is mandatory if Opening Stock entered,La valorizzazione è obbligatoria se si tratta di una disponibilità iniziale di magazzino
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +142,No records found in the Invoice table,Nessun record trovato nella tabella Fattura
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +17,Please select Company and Party Type first,Per favore selezionare prima l'azienda e il tipo di Partner
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +31,"Already set default in pos profile {0} for user {1}, kindly disabled default","Già impostato come predefinito nel profilo pos {0} per l&#39;utente {1}, disabilitato per impostazione predefinita"
apps/erpnext/erpnext/config/accounts.py +293,Financial / accounting year.,Esercizio finanziario / contabile .
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js +9,Accumulated Values,Valori accumulati
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +162,"Sorry, Serial Nos cannot be merged","Siamo spiacenti , Serial Nos non può essere fusa"
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +68,Territory is Required in POS Profile,Il territorio è richiesto nel profilo POS
DocType: Supplier,Prevent RFQs,Impedire l&#39;RFQ
apps/erpnext/erpnext/utilities/activation.py +83,Make Sales Order,Crea Ordine di vendita
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +168,Salary Slip submitted for period from {0} to {1},Salary Slip presentato per il periodo da {0} a {1}
DocType: Project Task,Project Task,Attività Progetto
,Lead Id,Id del Lead
DocType: C-Form Invoice Detail,Grand Total,Somma totale
DocType: Assessment Plan,Course,Corso
DocType: Timesheet,Payslip,Busta paga
apps/erpnext/erpnext/public/js/pos/pos.html +4,Item Cart,Prodotto Carrello
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +38,Fiscal Year Start Date should not be greater than Fiscal Year End Date,Anno fiscale Data di inizio non deve essere maggiore di Data Fine dell'anno fiscale
DocType: Issue,Resolution,Risoluzione
DocType: C-Form,IV,IV
apps/erpnext/erpnext/templates/pages/order.html +76,Delivered: {0},Consegna: {0}
DocType: Expense Claim,Payable Account,Conto pagabile
DocType: Payment Entry,Type of Payment,Tipo di pagamento
DocType: Sales Order,Billing and Delivery Status,Stato della Fatturazione e Consegna
DocType: Job Applicant,Resume Attachment,Riprendi Allegato
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +58,Repeat Customers,Ripetere i clienti
DocType: Leave Control Panel,Allocate,Assegna
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +108,Create Variant,Crea variante
DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Strumento di creazione fattura di apertura
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +851,Sales Return,Ritorno di vendite
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,Nota: Totale foglie assegnati {0} non deve essere inferiore a foglie già approvati {1} per il periodo
,Total Stock Summary,Sommario totale delle azioni
DocType: Announcement,Posted By,Pubblicato da
DocType: Item,Delivered by Supplier (Drop Ship),Consegnato dal Fornitore (Drop Ship)
DocType: Healthcare Settings,Confirmation Message,Messaggio di conferma
apps/erpnext/erpnext/config/crm.py +12,Database of potential customers.,Database Potenziali Clienti.
DocType: Authorization Rule,Customer or Item,Cliente o Voce
apps/erpnext/erpnext/config/selling.py +28,Customer database.,Database Clienti.
DocType: Quotation,Quotation To,Preventivo a
DocType: Lead,Middle Income,Reddito Medio
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +225,Opening (Cr),Opening ( Cr )
apps/erpnext/erpnext/stock/doctype/item/item.py +835,Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.,Unità di misura predefinita per la voce {0} non può essere modificato direttamente perché si è già fatto qualche operazione (s) con un altro UOM. Sarà necessario creare una nuova voce per utilizzare un diverso UOM predefinito.
apps/erpnext/erpnext/accounts/utils.py +351,Allocated amount can not be negative,L'Importo assegnato non può essere negativo
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11,Please set the Company,Imposti la Società
DocType: Purchase Order Item,Billed Amt,Importo Fatturato
DocType: Training Result Employee,Training Result Employee,Employee Training Risultato
DocType: Warehouse,A logical Warehouse against which stock entries are made.,Magazzino logico utilizzato per l'entrata giacenza.
DocType: Repayment Schedule,Principal Amount,Quota capitale
DocType: Employee Loan Application,Total Payable Interest,Totale interessi passivi
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +60,Total Outstanding: {0},Totale in sospeso: {0}
DocType: Sales Invoice Timesheet,Sales Invoice Timesheet,Timesheet Fattura di Vendita
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +116,Reference No & Reference Date is required for {0},N. di riferimento & Reference Data è necessario per {0}
DocType: Payroll Entry,Select Payment Account to make Bank Entry,Selezionare Account pagamento per rendere Bank Entry
apps/erpnext/erpnext/utilities/activation.py +136,"Create Employee records to manage leaves, expense claims and payroll","Creare record dei dipendenti per la gestione foglie, rimborsi spese e del libro paga"
apps/erpnext/erpnext/config/healthcare.py +118,Prescription Period,Periodo di prescrizione
DocType: Restaurant Reservation,Restaurant Reservation,Prenotazione Ristorante
DocType: Land Unit,Land Unit Name,Nome unità di terra
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +190,Proposal Writing,Scrivere proposta
DocType: Payment Entry Deduction,Payment Entry Deduction,Pagamento Entry Deduzione
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +14,Wrapping up,Avvolgendo
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +35,Notify Customers via Email,Invia ai clienti tramite e-mail
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +35,Another Sales Person {0} exists with the same Employee id,Un&#39;altra Sales Person {0} esiste con lo stesso ID Employee
DocType: Employee Advance,Claimed Amount,Importo richiesto
DocType: Production Planning Tool,"If checked, raw materials for items that are sub-contracted will be included in the Material Requests","Se selezionata, materie prime per gli oggetti che sono sub-contratto saranno inclusi nella sezione Richieste Materiale"
apps/erpnext/erpnext/config/healthcare.py +61,Masters,Principali
DocType: Assessment Plan,Maximum Assessment Score,Massimo punteggio
apps/erpnext/erpnext/config/accounts.py +138,Update Bank Transaction Dates,Aggiorna le date delle transazioni bancarie
apps/erpnext/erpnext/config/projects.py +36,Time Tracking,Monitoraggio tempo
DocType: Purchase Invoice,DUPLICATE FOR TRANSPORTER,DUPLICATE PER IL TRASPORTATORE
apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py +49,Row {0}# Paid Amount cannot be greater than requested advance amount,La riga {0} N. importo pagato non può essere maggiore dell&#39;importo anticipato richiesto
DocType: Fiscal Year Company,Fiscal Year Company,Anno Fiscale Società
DocType: Packing Slip Item,DN Detail,Dettaglio DN
DocType: Training Event,Conference,Conferenza
DocType: Timesheet,Billed,Addebbitato
DocType: Batch,Batch Description,Descrizione Batch
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +12,Creating student groups,Creazione di gruppi di studenti
apps/erpnext/erpnext/accounts/utils.py +724,"Payment Gateway Account not created, please create one manually.","Payment Gateway account non ha creato, per favore creare uno manualmente."
DocType: Supplier Scorecard,Per Year,Per anno
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +51,Not eligible for the admission in this program as per DOB,Non è ammissibile per l&#39;ammissione in questo programma come per DOB
DocType: Sales Invoice,Sales Taxes and Charges,Tasse di vendita e oneri
DocType: Employee,Organization Profile,Profilo dell'organizzazione
DocType: Vital Signs,Height (In Meter),Altezza (in metro)
DocType: Student,Sibling Details,Dettagli sibling
DocType: Vehicle Service,Vehicle Service,Servizio di veicoli
apps/erpnext/erpnext/config/setup.py +101,Automatically triggers the feedback request based on conditions.,fa scattare automaticamente la richiesta di feedback in base alle condizioni.
DocType: Employee,Reason for Resignation,Motivo della Dimissioni
apps/erpnext/erpnext/config/hr.py +152,Template for performance appraisals.,Modello per la valutazione delle prestazioni .
DocType: Sales Invoice,Credit Note Issued,Nota di Credito Emessa
DocType: Project Task,Weight,Peso
DocType: Payment Reconciliation,Invoice/Journal Entry Details,Dettagli Fattura/Registro
apps/erpnext/erpnext/accounts/utils.py +83,{0} '{1}' not in Fiscal Year {2},{0} '{1}' non in anno fiscale {2}
DocType: Buying Settings,Settings for Buying Module,Impostazioni per il Modulo Acquisti
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +21,Asset {0} does not belong to company {1},Asset {0} non appartiene alla società {1}
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +70,Please enter Purchase Receipt first,Si prega di inserire prima la Ricevuta di Acquisto
DocType: Buying Settings,Supplier Naming By,Creare il Nome Fornitore da
DocType: Activity Type,Default Costing Rate,Tasso Costing Predefinito
DocType: Maintenance Schedule,Maintenance Schedule,Programma di manutenzione
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +36,"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Quindi le Regole dei prezzi vengono filtrate in base a cliente, Gruppo Cliente, Territorio, Fornitore, Tipo Fornitore, Campagna, Partner di vendita ecc"
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +24,Net Change in Inventory,Variazione netta Inventario
apps/erpnext/erpnext/config/hr.py +162,Employee Loan Management,Prestito gestione del personale
DocType: Employee,Passport Number,Numero di passaporto
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +60,Relation with Guardian2,Rapporto con Guardian2
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +124,Manager,Manager
DocType: Payment Entry,Payment From / To,Pagamento da / a
apps/erpnext/erpnext/selling/doctype/customer/customer.py +155,New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},Il Nuovo limite di credito è inferiore all'attuale importo dovuto dal cliente. Il limite di credito deve essere almeno {0}
apps/erpnext/erpnext/controllers/trends.py +39,'Based On' and 'Group By' can not be same,'Basato Su' e 'Raggruppato Per' non può essere lo stesso
DocType: Sales Person,Sales Person Targets,Sales Person Obiettivi
DocType: Installation Note,IN-,IN-
DocType: Production Order Operation,In minutes,In pochi minuti
DocType: Issue,Resolution Date,Risoluzione Data
DocType: Lab Test Template,Compound,Composto
DocType: Student Batch Name,Batch Name,Batch Nome
DocType: Fee Validity,Max number of visit,Numero massimo di visite
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +339,Timesheet created:,Scheda attività creata:
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +920,Please set default Cash or Bank account in Mode of Payment {0},Si prega di impostare di default Contanti o conto bancario in Modalità di pagamento {0}
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +24,Enroll,Iscriversi
DocType: GST Settings,GST Settings,Impostazioni GST
DocType: Selling Settings,Customer Naming By,Creare il Nome Cliente da
DocType: Student Leave Application,Will show the student as Present in Student Monthly Attendance Report,Mostrerà lo studente come presente nel Presenze Monthly Report
DocType: Depreciation Schedule,Depreciation Amount,quota di ammortamento
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +56,Convert to Group,Convert to Group
DocType: Delivery Trip,TOUR-.#####,TOUR -. #####
DocType: Activity Cost,Activity Type,Tipo attività
DocType: Request for Quotation,For individual supplier,Per singolo fornitore
DocType: BOM Operation,Base Hour Rate(Company Currency),Base Hour Rate (Società di valuta)
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47,Delivered Amount,Importo Consegnato
DocType: Company,Fixed Days,Giorni fissi
DocType: Quotation Item,Item Balance,Saldo
DocType: Sales Invoice,Packing List,Lista di imballaggio
apps/erpnext/erpnext/config/buying.py +28,Purchase Orders given to Suppliers.,Ordini di acquisto emessi ai Fornitori.
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +43,Publishing,editoria
DocType: Activity Cost,Projects User,Progetti utente
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Consumed,Consumato
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +157,{0}: {1} not found in Invoice Details table,{0}: {1} non trovato in tabella Dettagli Fattura
DocType: Asset,Asset Owner Company,Asset Owner Company
DocType: Company,Round Off Cost Center,Arrotondamento Centro di costo
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +242,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,La manutenzione {0} deve essere cancellata prima di annullare questo ordine di vendita
DocType: Asset Maintenance Log,AML-,AML-
DocType: Item,Material Transfer,Trasferimento materiale
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py +24,Could not find path for ,Impossibile trovare il percorso
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +218,Opening (Dr),Opening ( Dr)
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +39,Posting timestamp must be after {0},Distacco timestamp deve essere successiva {0}
apps/erpnext/erpnext/config/accounts.py +39,To make recurring documents,Per eseguire documenti ricorrenti
,GST Itemised Purchase Register,Registro Acquisti Itemized GST
DocType: Course Scheduling Tool,Reschedule,Riprogrammare
DocType: Employee Loan,Total Interest Payable,Totale interessi passivi
DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,Tasse Landed Cost e oneri
DocType: Production Order Operation,Actual Start Time,Ora di inizio effettiva
DocType: BOM Operation,Operation Time,Tempo di funzionamento
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +315,Finish,Finire
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +412,Base,Base
DocType: Timesheet,Total Billed Hours,Totale Ore Fatturate
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1438,Write Off Amount,Importo Svalutazione
DocType: Leave Block List Allow,Allow User,Consentire Utente
DocType: Journal Entry,Bill No,Fattura N.
DocType: Company,Gain/Loss Account on Asset Disposal,Conto profitti / perdite su Asset in smaltimento
DocType: Vehicle Log,Service Details,Dettagli del servizio
DocType: Subscription,Quarterly,Trimestralmente
DocType: Lab Test Template,Grouped,raggruppate
DocType: Selling Settings,Delivery Note Required,Documento di Trasporto Richiesto
DocType: Bank Guarantee,Bank Guarantee Number,Numero di garanzia bancaria
DocType: Assessment Criteria,Assessment Criteria,Criteri di valutazione
DocType: BOM Item,Basic Rate (Company Currency),Tasso Base (Valuta Azienda)
DocType: Student Attendance,Student Attendance,La partecipazione degli studenti
DocType: Sales Invoice Timesheet,Time Sheet,Scheda attività
DocType: Manufacturing Settings,Backflush Raw Materials Based On,Backflush Materie prime calcolate in base a
DocType: Lead,Lead is an Organization,Lead è un&#39;organizzazione
DocType: Guardian Interest,Interest,Interesse
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +10,Pre Sales,Pre vendita
DocType: Purchase Receipt,Other Details,Altri dettagli
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +18,Suplier,suplier
DocType: Lab Test,Test Template,Modello di prova
DocType: Restaurant Order Entry Item,Served,servito
apps/erpnext/erpnext/config/non_profit.py +13,Chapter information.,Informazioni sul capitolo
DocType: Account,Accounts,Contabilità
DocType: Vehicle,Odometer Value (Last),Valore del contachilometri (Last)
apps/erpnext/erpnext/config/buying.py +160,Templates of supplier scorecard criteria.,Modelli di criteri di scorecard fornitori.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +109,Marketing,Marketing
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +290,Payment Entry is already created,Pagamento L&#39;ingresso è già stato creato
DocType: Request for Quotation,Get Suppliers,Ottenere Fornitori
DocType: Purchase Receipt Item Supplied,Current Stock,Giacenza Corrente
apps/erpnext/erpnext/controllers/accounts_controller.py +589,Row #{0}: Asset {1} does not linked to Item {2},Row # {0}: Asset {1} non legata alla voce {2}
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +394,Preview Salary Slip,Anteprima foglio paga
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +54,Account {0} has been entered multiple times,Account {0} è stato inserito più volte
DocType: Account,Expenses Included In Valuation,Spese incluse nella valorizzazione
apps/erpnext/erpnext/non_profit/doctype/membership/membership.py +23,You can only renew if your membership expires within 30 days,Puoi rinnovare solo se la tua iscrizione scade entro 30 giorni
DocType: Land Unit,Longitude,Longitudine
,Absent Student Report,Report Assenze Studente
DocType: Crop,Crop Spacing UOM,Crop Spacing UOM
DocType: Email Digest,Next email will be sent on:,La prossima Email verrà inviata il:
DocType: Offer Letter Term,Offer Letter Term,Termine di Offerta
DocType: Supplier Scorecard,Per Week,A settimana
apps/erpnext/erpnext/stock/doctype/item/item.py +639,Item has variants.,Articolo ha varianti.
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +154,Total Student,Studente totale
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +65,Item {0} not found,Articolo {0} non trovato
DocType: Bin,Stock Value,Valore Giacenza
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +42,Fee records will be created in the background. In case of any error the error message will be updated in the Schedule.,I record delle tariffe verranno creati in background. In caso di errore il messaggio di errore verrà aggiornato nell&#39;Appendice.
apps/erpnext/erpnext/accounts/doctype/account/account.py +241,Company {0} does not exist,Società di {0} non esiste
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +40,{0} has fee validity till {1},{0} ha la validità della tassa fino a {1}
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +57,Tree Type,albero Type
DocType: BOM Explosion Item,Qty Consumed Per Unit,Quantità consumata per unità
DocType: Serial No,Warranty Expiry Date,Data di scadenza Garanzia
DocType: Material Request Item,Quantity and Warehouse,Quantità e Magazzino
DocType: Hub Settings,Unregister,Annullare la registrazione
DocType: Sales Invoice,Commission Rate (%),Tasso Commissione (%)
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +24,Please select Program,Seleziona Programma
DocType: Project,Estimated Cost,Costo stimato
DocType: Purchase Order,Link to material requests,Collegamento alle richieste di materiale
DocType: Hub Settings,Publish,Pubblicare
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +7,Aerospace,aerospaziale
DocType: Journal Entry,Credit Card Entry,Entry Carta di Credito
apps/erpnext/erpnext/config/accounts.py +57,Company and Accounts,Azienda e Contabilità
apps/erpnext/erpnext/config/healthcare.py +108,Appointment Type Master,Tipo di appuntamento Master
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +68,In Value,in Valore
DocType: Lead,Campaign Name,Nome Campagna
DocType: Selling Settings,Close Opportunity After Days,Chiudi Opportunità dopo giorni
,Reserved,riservato
DocType: Driver,License Details,Dettagli della licenza
DocType: Purchase Order,Supply Raw Materials,Fornire Materie Prime
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +10,Current Assets,Attività correnti
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +99,{0} is not a stock Item,{0} non è un articolo in scorta
apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +6,Please share your feedback to the training by clicking on 'Training Feedback' and then 'New',"Per favore, condividi i tuoi commenti con la formazione cliccando su &quot;Informazioni sulla formazione&quot; e poi su &quot;Nuovo&quot;"
DocType: Mode of Payment Account,Default Account,Account Predefinito
apps/erpnext/erpnext/stock/doctype/item/item.py +262,Please select Sample Retention Warehouse in Stock Settings first,Seleziona prima il magazzino di conservazione dei campioni in Impostazioni stock
DocType: Payment Entry,Received Amount (Company Currency),Importo ricevuto (Società di valuta)
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +192,Lead must be set if Opportunity is made from Lead,Il Lead deve essere impostato se l'opportunità è generata da un Lead
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +29,Please select weekly off day,Seleziona il giorno di riposo settimanale
DocType: Patient,O Negative,O negativo
DocType: Production Order Operation,Planned End Time,Planned End Time
,Sales Person Target Variance Item Group-Wise,Sales Person target Varianza articolo Group- Wise
apps/erpnext/erpnext/accounts/doctype/account/account.py +95,Account with existing transaction cannot be converted to ledger,Account con transazione registrate non può essere convertito in libro mastro
apps/erpnext/erpnext/config/non_profit.py +33,Memebership Type Details,Dettagli tipo di unità
DocType: Delivery Note,Customer's Purchase Order No,Ordine Acquisto Cliente N.
DocType: Budget,Budget Against,budget contro
DocType: Employee,Cell Number,Numero di Telefono
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +445,There's no employee for the given criteria. Check that Salary Slips have not already been created.,Non ci sono dipendenti per i criteri indicati. Verifica che gli Scivoli salariali non siano già stati creati.
apps/erpnext/erpnext/stock/reorder_item.py +190,Auto Material Requests Generated,Richieste Materiale Auto generata
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +7,Lost,perso
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +150,You can not enter current voucher in 'Against Journal Entry' column,Non è possibile inserire il buono nella colonna 'Against Journal Entry'
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +50,Reserved for manufacturing,Riservato per la produzione
DocType: Soil Texture,Sand,Sabbia
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +25,Energy,Energia
DocType: Opportunity,Opportunity From,Opportunità da
apps/erpnext/erpnext/config/hr.py +98,Monthly salary statement.,Busta Paga Mensile.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +881,Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,Riga {0}: {1} Numeri di serie necessari per l&#39;articolo {2}. Hai fornito {3}.
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +79,Please select a table,Seleziona una tabella
DocType: BOM,Website Specifications,Website Specifiche
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +78,{0} is an invalid email address in 'Recipients',{0} è un indirizzo email non valido in &#39;Destinatari&#39;
DocType: Special Test Items,Particulars,particolari
apps/erpnext/erpnext/config/healthcare.py +143,Antibiotic.,Antibiotico.
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +24,{0}: From {0} of type {1},{0}: Da {0} di tipo {1}
DocType: Warranty Claim,CI-,CI-
apps/erpnext/erpnext/controllers/buying_controller.py +292,Row {0}: Conversion Factor is mandatory,Riga {0}: fattore di conversione è obbligatoria
DocType: Student,A+,A+
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +326,"Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}","Più regole Prezzo esiste con stessi criteri, si prega di risolvere i conflitti tramite l&#39;assegnazione di priorità. Regole Prezzo: {0}"
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +504,Cannot deactivate or cancel BOM as it is linked with other BOMs,Impossibile disattivare o cancellare distinta in quanto è collegata con altri BOM
DocType: Asset,Maintenance,Manutenzione
DocType: Item Attribute Value,Item Attribute Value,Valore Attributo Articolo
DocType: Item,Maximum sample quantity that can be retained,Quantità massima di campione che può essere conservata
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +393,Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},La riga {0} # articolo {1} non può essere trasferita più di {2} contro l&#39;ordine d&#39;acquisto {3}
apps/erpnext/erpnext/config/selling.py +158,Sales campaigns.,Campagne di vendita .
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +117,Make Timesheet,Crea un Timesheet
DocType: Sales Taxes and Charges Template,"Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.

#### Note

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

#### Description of Columns

1. Calculation Type: 
    - This can be on **Net Total** (that is the sum of basic amount).
    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.
    - **Actual** (as mentioned).
2. Account Head: The Account ledger under which this tax will be booked
3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.
4. Description: Description of the tax (that will be printed in invoices / quotes).
5. Rate: Tax rate.
6. Amount: Tax amount.
7. Total: Cumulative total to this point.
8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).
9. Is this Tax included in Basic Rate?: If you check this, it means that this tax will not be shown below the item table, but will be included in the Basic Rate in your main item table. This is useful where you want give a flat price (inclusive of all taxes) price to customers.","Modello fiscale standard che può essere applicato a tutte le transazioni di vendita. Questo modello può contenere l'elenco delle teste fiscali e anche altri capi oneri / proventi come ""spedizione"", ""Assicurazioni"", ""Gestione"", ecc 

 #### Nota 

 Il tax rate si definire qui sarà l'aliquota standard per tutti gli articoli ** **. Se ci sono gli articoli ** ** che hanno tariffe diverse, devono essere aggiunti nella voce imposte ** ** tavolo in ** ** Item master.

 #### Descrizione di colonne 

 1. Tipo di calcolo: 
 - Questo può essere di ** Net Total ** (che è la somma di importo di base).
 - ** Il Fila Indietro Total / Importo ** (per le imposte o tasse cumulative). Selezionando questa opzione, l'imposta sarà applicata come percentuale della riga precedente (nella tabella fiscale) importo o totale.
 - ** ** Actual (come detto).
 2. Account testa: Il registro account con cui questa imposta sarà prenotato 
 3. Centro di costo: se l'imposta / tassa è di un reddito (come il trasporto) o spese deve essere prenotato contro un centro di costo.
 4. Descrizione: Descrizione della tassa (che sarà stampato in fatture / virgolette).
 5. Vota: Aliquota.
 6. Importo: Ammontare IVA.
 7. Totale: totale cumulativo a questo punto.
 8. Inserisci Row: se sulla base di ""Previous totale riga"" è possibile selezionare il numero di riga che sarà preso come base per il calcolo (di default è la riga precedente).
 9. È questo Tax incluso nel Basic Rate ?: Se si seleziona questa, vuol dire che questa tassa non verrà mostrato sotto la tabella voce, ma sarà inclusa nella tariffa di base nella tabella principale voce. Questo è utile quando si vuole dare un prezzo forfettario (tasse comprese) dei prezzi per i clienti."
DocType: Employee,Bank A/C No.,Conto Bancario N.
DocType: Bank Guarantee,Project,Progetto
DocType: Quality Inspection Reading,Reading 7,Lettura 7
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +9,Partially Ordered,parzialmente ordinato
DocType: Lab Test,Lab Test,Test di laboratorio
DocType: Expense Claim Detail,Expense Claim Type,Tipo Rimborso Spese
DocType: Shopping Cart Settings,Default settings for Shopping Cart,Impostazioni predefinite per Carrello
apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +26,Add Timeslots,Aggiungi Timelots
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +138,Asset scrapped via Journal Entry {0},Asset demolito tramite diario {0}
DocType: Employee Loan,Interest Income Account,Conto Interessi attivi
apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py +58,Review Invitation Sent,Rivedi l&#39;invito inviato
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +13,Biotechnology,Biotecnologia
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +109,Office Maintenance Expenses,Spese di manutenzione dell'ufficio
apps/erpnext/erpnext/utilities/user_progress.py +51,Go to ,Vai a
apps/erpnext/erpnext/config/learn.py +47,Setting up Email Account,Impostazione di account e-mail
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.js +114,Please enter Item first,Inserisci articolo prima
DocType: Asset Repair,Downtime,I tempi di inattività
DocType: Account,Liability,responsabilità
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +234,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Importo sanzionato non può essere maggiore di rivendicazione Importo in riga {0}.
DocType: Salary Detail,Do not include in total,Non includere in totale
DocType: Company,Default Cost of Goods Sold Account,Costo predefinito di Account merci vendute
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +964,Sample quantity {0} cannot be more than received quantity {1},La quantità di esempio {0} non può essere superiore alla quantità ricevuta {1}
apps/erpnext/erpnext/stock/get_item_details.py +362,Price List not selected,Listino Prezzi non selezionati
DocType: Employee,Family Background,Sfondo Famiglia
DocType: Request for Quotation Supplier,Send Email,Invia Email
apps/erpnext/erpnext/stock/doctype/item/item.py +218,Warning: Invalid Attachment {0},Attenzione: L&#39;allegato non valido {0}
DocType: Item,Max Sample Quantity,Quantità di campione massima
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +764,No Permission,Nessuna autorizzazione
apps/erpnext/erpnext/hub_node/page/hub/hub.js +438,Quote Requested,Quotazione richiesta
DocType: Vital Signs,Heart Rate / Pulse,Frequenza cardiaca / impulso
DocType: Company,Default Bank Account,Conto Banca Predefinito
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +50,"To filter based on Party, select Party Type first","Per filtrare sulla base del Partner, selezionare prima il tipo di Partner"
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +48,'Update Stock' can not be checked because items are not delivered via {0},'Aggiorna Scorte' non può essere selezionato perché gli articoli non vengono recapitati tramite {0}
DocType: Vehicle,Acquisition Date,Data Acquisizione
apps/erpnext/erpnext/utilities/user_progress.py +143,Nos,nos
DocType: Item,Items with higher weightage will be shown higher,Gli articoli con maggiore weightage nel periodo più alto
apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +14,Lab Tests and Vital Signs,Test di laboratorio e segni vitali
DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,Dettaglio Riconciliazione Banca
apps/erpnext/erpnext/controllers/accounts_controller.py +593,Row #{0}: Asset {1} must be submitted,Row # {0}: Asset {1} deve essere presentata
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +40,No employee found,Nessun dipendente trovato
DocType: Subscription,Stopped,Arrestato
DocType: Item,If subcontracted to a vendor,Se subappaltato a un fornitore
apps/erpnext/erpnext/education/doctype/student_group/student_group.js +111,Student Group is already updated.,Il gruppo studente è già aggiornato.
DocType: SMS Center,All Customer Contact,Tutti Contatti Clienti
DocType: Land Unit,Tree Details,Dettagli Albero
DocType: Training Event,Event Status,Stato evento
DocType: Volunteer,Availability Timeslot,Orario di disponibilità
,Support Analytics,Analytics Support
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +352,"If you have any questions, please get back to us.","Se avete domande, si prega di tornare a noi."
DocType: Item,Website Warehouse,Magazzino sito web
DocType: Payment Reconciliation,Minimum Invoice Amount,Importo Minimo Fattura
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +111,{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: Il Centro di Costo {2} non appartiene all'azienda {3}
apps/erpnext/erpnext/utilities/user_progress.py +89,Upload your letter head (Keep it web friendly as 900px by 100px),Carica la tua testata (Rendila web friendly come 900px per 100px)
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +88,{0} {1}: Account {2} cannot be a Group,{0} {1}: Il conto {2} non può essere un gruppo
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +63,Item Row {idx}: {doctype} {docname} does not exist in above '{doctype}' table,Articolo Row {} IDX: {DOCTYPE} {} docname non esiste nel precedente &#39;{} doctype&#39; tavolo
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +291,Timesheet {0} is already completed or cancelled,La scheda attività {0} è già stata completata o annullata
apps/erpnext/erpnext/templates/pages/projects.html +42,No tasks,Nessuna attività
DocType: Item Variant Settings,Copy Fields to Variant,Copia campi in variante
DocType: Asset,Opening Accumulated Depreciation,Apertura del deprezzamento accumulato
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js +49,Score must be less than or equal to 5,Il punteggio deve essere minore o uguale a 5
DocType: Program Enrollment Tool,Program Enrollment Tool,Strumento di iscrizione Programma
apps/erpnext/erpnext/config/accounts.py +335,C-Form records,Record C -Form
apps/erpnext/erpnext/config/selling.py +311,Customer and Supplier,Cliente e Fornitore
DocType: Email Digest,Email Digest Settings,Impostazioni Email di Sintesi
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +354,Thank you for your business!,Grazie per il tuo business!
apps/erpnext/erpnext/config/support.py +12,Support queries from customers.,Supportare le query da parte dei clienti.
DocType: Setup Progress Action,Action Doctype,Doctype d'Azione
,Production Order Stock Report,Ordine di produzione Stock Report
apps/erpnext/erpnext/config/healthcare.py +148,Sensitivity Naming.,Attribuzione di sensibilità.
DocType: HR Settings,Retirement Age,Età di pensionamento
DocType: Bin,Moving Average Rate,Tasso Media Mobile
DocType: Production Planning Tool,Select Items,Selezionare Elementi
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +370,{0} against Bill {1} dated {2},{0} per fattura {1} in data {2}
apps/erpnext/erpnext/utilities/user_progress.py +24,Setup Institution,Configura istituzione
DocType: Program Enrollment,Vehicle/Bus Number,Numero di veicolo / bus
apps/erpnext/erpnext/education/doctype/course/course.js +17,Course Schedule,Orario del corso
DocType: Request for Quotation Supplier,Quote Status,Quote Status
DocType: Maintenance Visit,Completion Status,Stato Completamento
DocType: HR Settings,Enter retirement age in years,Inserire l&#39;età pensionabile in anni
DocType: Crop,Target Warehouse,Magazzino di Destinazione
DocType: Payroll Employee Detail,Payroll Employee Detail,Dettaglio dipendente del libro paga
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +128,Please select a warehouse,Seleziona un magazzino
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +88,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Configurare le serie di numerazione per Presenze tramite Setup&gt; Numerazione serie
DocType: Cheque Print Template,Starting location from left edge,A partire da posizione bordo sinistro
DocType: Item,Allow over delivery or receipt upto this percent,Consenti superamento ricezione o invio fino a questa percentuale
DocType: Stock Entry,STE-,STEREO
DocType: Upload Attendance,Import Attendance,Importa presenze
apps/erpnext/erpnext/public/js/pos/pos.html +113,All Item Groups,Tutti i Gruppi
apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +39,Net Profit / Loss,Utile / Perdita
apps/erpnext/erpnext/config/setup.py +89,Automatically compose message on submission of transactions.,Comporre automaticamente il messaggio di presentazione delle transazioni .
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +201,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Impostare Serie di denominazione per {0} tramite Impostazione&gt; Impostazioni&gt; Serie di denominazione
DocType: Production Order,Item To Manufacture,Articolo da produrre
apps/erpnext/erpnext/buying/utils.py +80,{0} {1} status is {2},{0} {1} stato è {2}
DocType: Water Analysis,Collection Temperature ,Temperatura di raccolta
DocType: Employee,Provide Email Address registered in company,Fornire l&#39;indirizzo e-mail registrato in compagnia
DocType: Shopping Cart Settings,Enable Checkout,Abilita Checkout
apps/erpnext/erpnext/config/learn.py +202,Purchase Order to Payment,Ordine d&#39;acquisto a pagamento
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +48,Projected Qty,Qtà Proiettata
DocType: Sales Invoice,Payment Due Date,Scadenza
DocType: Drug Prescription,Interval UOM,Intervallo UOM
apps/erpnext/erpnext/stock/doctype/item/item.js +489,Item Variant {0} already exists with same attributes,Prodotto Modello {0} esiste già con gli stessi attributi
DocType: Item,Hub Publishing Details,Dettagli di pubblicazione Hub
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +115,'Opening','Apertura'
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +130,Open To Do,Aperto per fare
DocType: Notification Control,Delivery Note Message,Messaggio del Documento di Trasporto
DocType: Lab Test Template,Result Format,Formato risultato
DocType: Expense Claim,Expenses,Spese
DocType: Delivery Stop,Delivery Notes,Bolle di consegna
DocType: Item Variant Attribute,Item Variant Attribute,Prodotto Modello attributo
,Purchase Receipt Trends,Acquisto Tendenze Receipt
DocType: Payroll Entry,Bimonthly,ogni due mesi
DocType: Vehicle Service,Brake Pad,Pastiglie freno
DocType: Fertilizer,Fertilizer Contents,Contenuto di fertilizzante
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +119,Research & Development,Ricerca & Sviluppo
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +20,Amount to Bill,Importo da Bill
DocType: Company,Registration Details,Dettagli di Registrazione
DocType: Timesheet,Total Billed Amount,Totale Importo Fatturato
DocType: Item Reorder,Re-Order Qty,Quantità Ri-ordino
DocType: Leave Block List Date,Leave Block List Date,Lascia Block List Data
DocType: Pricing Rule,Price or Discount,Prezzo o Sconto
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +91,BOM #{0}: Raw material cannot be same as main Item,BOM # {0}: La materia prima non può essere uguale a quella principale
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +92,Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges,Totale oneri addebitati in Acquisto tabella di carico Gli articoli devono essere uguale Totale imposte e oneri
DocType: Sales Team,Incentives,Incentivi
apps/erpnext/erpnext/hub_node/page/hub/hub.js +64,Register for Hub,Registrati per Hub
DocType: SMS Log,Requested Numbers,Numeri richiesti
DocType: Volunteer,Evening,Sera
DocType: Production Planning Tool,Only Obtain Raw Materials,Ottenere solo materie prime
DocType: Customer,Bypass credit limit check at Sales Order,Ignorare il controllo del limite di credito in ordine cliente
apps/erpnext/erpnext/config/hr.py +147,Performance appraisal.,Valutazione delle prestazioni.
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +97,"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart","L&#39;attivazione di &#39;utilizzare per il Carrello&#39;, come Carrello è abilitato e ci dovrebbe essere almeno una regola imposta per Carrello"
apps/erpnext/erpnext/controllers/accounts_controller.py +391,"Payment Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.","La registrazione di pagamento {0} è legata all'ordine {1}, controllare se deve essere considerato come anticipo in questa fattura."
DocType: Sales Invoice Item,Stock Details,Dettagli Stock
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29,Project Value,Valore di progetto
apps/erpnext/erpnext/config/selling.py +321,Point-of-Sale,Punto vendita
DocType: Fee Schedule,Fee Creation Status,Stato della creazione della tariffa
DocType: Vehicle Log,Odometer Reading,Lettura del contachilometri
apps/erpnext/erpnext/accounts/doctype/account/account.py +118,"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Saldo a bilancio già nel credito, non è permesso impostare il 'Saldo Futuro' come 'debito'"
DocType: Account,Balance must be,Il saldo deve essere
DocType: Hub Settings,Publish Pricing,Pubblicare Prezzi
DocType: Notification Control,Expense Claim Rejected Message,Messaggio Rimborso Spese Rifiutato
,Available Qty,Disponibile Quantità
DocType: Purchase Taxes and Charges,On Previous Row Total,Sul totale della riga precedente
DocType: Purchase Invoice Item,Rejected Qty,Quantità Rifiutato
DocType: Setup Progress Action,Action Field,Campo di azione
DocType: Healthcare Settings,Manage Customer,Gestisci il Cliente
DocType: Delivery Trip,Delivery Stops,Fermate di consegna
DocType: Salary Slip,Working Days,Giorni lavorativi
DocType: Serial No,Incoming Rate,Tasso in ingresso
DocType: Packing Slip,Gross Weight,Peso lordo
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +47,Enable Hub,Abilita Hub
apps/erpnext/erpnext/public/js/setup_wizard.js +110,The name of your company for which you are setting up this system.,Il nome dell'azienda per la quale si sta configurando questo sistema.
DocType: HR Settings,Include holidays in Total no. of Working Days,Includi vacanze in totale n. dei giorni lavorativi
apps/erpnext/erpnext/setup/setup_wizard/operations/sample_data.py +108,Setup your Institute in ERPNext,Imposta il tuo istituto in ERPNext
DocType: Agriculture Analysis Criteria,Plant Analysis,Analisi delle piante
DocType: Job Applicant,Hold,Mantieni
DocType: Employee,Date of Joining,Data Adesione
DocType: Naming Series,Update Series,Update
DocType: Supplier Quotation,Is Subcontracted,È in Conto Lavorazione
DocType: Restaurant Table,Minimum Seating,Minima sede
DocType: Item Attribute,Item Attribute Values,Valori Attributi Articolo
DocType: Examination Result,Examination Result,L&#39;esame dei risultati
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +843,Purchase Receipt,Ricevuta di Acquisto
,Received Items To Be Billed,Oggetti ricevuti da fatturare
apps/erpnext/erpnext/config/accounts.py +303,Currency exchange rate master.,Maestro del tasso di cambio di valuta .
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +198,Reference Doctype must be one of {0},Riferimento Doctype deve essere uno dei {0}
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +322,Unable to find Time Slot in the next {0} days for Operation {1},Impossibile trovare tempo di slot nei prossimi {0} giorni per l&#39;operazione {1}
DocType: Production Order,Plan material for sub-assemblies,Materiale Piano per sub-assemblaggi
apps/erpnext/erpnext/config/selling.py +97,Sales Partners and Territory,I partner di vendita e Territorio
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +585,BOM {0} must be active,BOM {0} deve essere attivo
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +221,Closing (Opening + Total),Chiusura (apertura + totale)
DocType: Journal Entry,Depreciation Entry,Ammortamenti Entry
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +36,Please select the document type first,Si prega di selezionare il tipo di documento prima
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +65,Cancel Material Visits {0} before cancelling this Maintenance Visit,Annulla Visite Materiale {0} prima di annullare questa visita di manutenzione
DocType: Crop Cycle,ISO 8016 standard,ISO 8016 standard
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +213,Serial No {0} does not belong to Item {1},Serial No {0} non appartiene alla voce {1}
DocType: Purchase Receipt Item Supplied,Required Qty,Quantità richiesta
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +127,Warehouses with existing transaction can not be converted to ledger.,Magazzini con transazione esistenti non possono essere convertiti in contabilità.
DocType: Bank Reconciliation,Total Amount,Totale Importo
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +32,Internet Publishing,Internet Publishing
DocType: Prescription Duration,Number,Numero
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +25,Creating {0} Invoice,Creazione di {0} fattura
DocType: Medical Code,Medical Code Standard,Codice medico standard
DocType: Soil Texture,Clay Composition (%),Composizione di argilla (%)
DocType: Production Planning Tool,Production Orders,Ordini di produzione
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +81,Please save before assigning task.,Si prega di salvare prima di assegnare attività.
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +72,Balance Value,Valore Saldo
DocType: Lab Test,Lab Technician,Tecnico di laboratorio
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +38,Sales Price List,Lista Prezzo di vendita
DocType: Healthcare Settings,"If checked, a customer will be created, mapped to Patient.
Patient Invoices will be created against this Customer. You can also select existing Customer while creating Patient.","Se selezionato, verrà creato un cliente, associato a Paziente. Le fatture pazienti verranno create contro questo Cliente. È inoltre possibile selezionare il cliente esistente durante la creazione di paziente."
DocType: Bank Reconciliation,Account Currency,Valuta del saldo
DocType: Lab Test,Sample ID,ID del campione
apps/erpnext/erpnext/accounts/general_ledger.py +165,Please mention Round Off Account in Company,Si prega di citare Arrotondamento account in azienda
DocType: Purchase Receipt,Range,Intervallo
DocType: Supplier,Default Payable Accounts,Contabilità Fornitori Predefinita
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +49,Employee {0} is not active or does not exist,Employee {0} non è attiva o non esiste
DocType: Fee Structure,Components,componenti
apps/erpnext/erpnext/assets/doctype/asset/asset.py +272,Please enter Asset Category in Item {0},Si prega di inserire Asset categoria al punto {0}
apps/erpnext/erpnext/stock/doctype/item/item.py +634,Item Variants {0} updated,Voce Varianti {0} aggiornato
DocType: Quality Inspection Reading,Reading 6,Lettura 6
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +9,"to be generated. If delayed, you will have to manually change the ""Repeat on Day of Month"" field
of this","da generare. Se è ritardato, dovrai cambiare manualmente il campo &quot;Ripeti in Giorno del mese&quot;"
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +945,Cannot {0} {1} {2} without any negative outstanding invoice,Impossibile {0} {1} {2} senza alcuna fattura in sospeso negativo
DocType: Purchase Invoice Advance,Purchase Invoice Advance,Anticipo Fattura di Acquisto
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +197,Row {0}: Credit entry can not be linked with a {1},Riga {0}: ingresso di credito non può essere collegato con un {1}
apps/erpnext/erpnext/config/accounts.py +246,Define budget for a financial year.,Definire bilancio per l&#39;anno finanziario.
DocType: Mode of Payment Account,Default Bank / Cash account will be automatically updated in POS Invoice when this mode is selected.,"""Conto Banca / Cassa predefinito"" sarà verrà automaticamente aggiornato nella fattura del punto vendita quando sarà selezionata questa modalità."
DocType: Lead,LEAD-,LEAD-
DocType: Employee,Permanent Address Is,Indirizzo permanente è
DocType: Production Order Operation,Operation completed for how many finished goods?,Operazione completata per quanti prodotti finiti?
DocType: Payment Terms Template,Payment Terms Template,Modello di termini di pagamento
apps/erpnext/erpnext/public/js/setup_wizard.js +51,The Brand,Il marchio / brand
DocType: Employee,Exit Interview Details,Uscire Dettagli Intervista
DocType: Item,Is Purchase Item,È Acquisto Voce
DocType: Journal Entry Account,Purchase Invoice,Fattura di Acquisto
DocType: Stock Ledger Entry,Voucher Detail No,Voucher Detail No
apps/erpnext/erpnext/accounts/page/pos/pos.js +780,New Sales Invoice,Nuova fattura di vendita
DocType: Stock Entry,Total Outgoing Value,Totale Valore uscita
DocType: Physician,Appointments,appuntamenti
apps/erpnext/erpnext/public/js/account_tree_grid.js +224,Opening Date and Closing Date should be within same Fiscal Year,Data e Data di chiusura di apertura dovrebbe essere entro lo stesso anno fiscale
DocType: Lead,Request for Information,Richiesta di Informazioni
,LeaderBoard,Classifica
DocType: Sales Invoice Item,Rate With Margin (Company Currency),Rate With Margin (Company Currency)
apps/erpnext/erpnext/accounts/page/pos/pos.js +793,Sync Offline Invoices,Sincronizzazione Fatture Off-line
DocType: Payment Request,Paid,Pagato
DocType: Program Fee,Program Fee,Costo del programma
DocType: BOM Update Tool,"Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM.
It also updates latest price in all the BOMs.","Sostituire una particolare BOM in tutte le altre BOM in cui è utilizzata. Sostituirà il vecchio collegamento BOM, aggiorna i costi e rigenererà la tabella &quot;BOM Explosion Item&quot; come per la nuova BOM. Inoltre aggiorna l&#39;ultimo prezzo in tutte le BOM."
DocType: Salary Slip,Total in words,Totale in parole
DocType: Material Request Item,Lead Time Date,Data di Consegna
DocType: Guardian,Guardian Name,Nome della guardia
DocType: Cheque Print Template,Has Print Format,Ha Formato di stampa
DocType: Employee Loan,Sanctioned,sanzionato
apps/erpnext/erpnext/accounts/page/pos/pos.js +75, is mandatory. Maybe Currency Exchange record is not created for ,Obbligatorio. Forse non è stato definito il vambio di valuta
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +117,Row #{0}: Please specify Serial No for Item {1},Row # {0}: Si prega di specificare Numero d'ordine per la voce {1}
DocType: Crop Cycle,Crop Cycle,Crop Cycle
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +632,"For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","Per &#39;prodotto Bundle&#39;, Warehouse, numero di serie e Batch No sarà considerata dal &#39;Packing List&#39; tavolo. Se Magazzino e Batch No sono gli stessi per tutti gli elementi di imballaggio per un elemento qualsiasi &#39;Product Bundle&#39;, questi valori possono essere inseriti nella tabella principale elemento, i valori verranno copiati a &#39;Packing List&#39; tavolo."
DocType: Student Admission,Publish on website,Pubblicare sul sito web
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +645,Supplier Invoice Date cannot be greater than Posting Date,La data Fattura Fornitore non può essere superiore della Data Registrazione
DocType: Purchase Invoice Item,Purchase Order Item,Articolo dell'Ordine di Acquisto
DocType: Agriculture Task,Agriculture Task,Attività agricola
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +132,Indirect Income,Proventi indiretti
DocType: Student Attendance Tool,Student Attendance Tool,Strumento Presenze
DocType: Restaurant Menu,Price List (Auto created),Listino prezzi (creato automaticamente)
DocType: Cheque Print Template,Date Settings,Impostazioni della data
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +48,Variance,Varianza
,Company Name,Nome Azienda
DocType: SMS Center,Total Message(s),Totale Messaggi
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +913,Select Item for Transfer,Selezionare la voce per il trasferimento
DocType: Purchase Invoice,Additional Discount Percentage,Percentuale di sconto Aggiuntivo
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +24,View a list of all the help videos,Visualizzare un elenco di tutti i video di aiuto
DocType: Agriculture Analysis Criteria,Soil Texture,Texture del suolo
DocType: Bank Reconciliation,Select account head of the bank where cheque was deposited.,Selezionare conto capo della banca in cui assegno è stato depositato.
DocType: Selling Settings,Allow user to edit Price List Rate in transactions,Consenti all'utente di modificare il prezzo di Listino nelle transazioni
DocType: Pricing Rule,Max Qty,Qtà max
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","Riga {0}: Fattura {1} non è valido, potrebbe essere cancellato / non esiste. \ Si prega di inserire una fattura valida"
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +130,Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Riga {0}: Pagamento contro vendite / ordine di acquisto deve essere sempre contrassegnato come anticipo
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +16,Chemical,chimico
DocType: Salary Component Account,Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,Predefinito conto bancario / Cash sarà aggiornato automaticamente in Stipendio diario quando viene selezionata questa modalità.
DocType: BOM,Raw Material Cost(Company Currency),Raw Material Cost (Società di valuta)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +758,All items have already been transferred for this Production Order.,Tutti gli articoli sono già stati trasferiti per questo ordine di produzione.
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +87,Row # {0}: Rate cannot be greater than the rate used in {1} {2},Riga # {0}: la velocità non può essere superiore alla velocità utilizzata in {1} {2}
apps/erpnext/erpnext/utilities/user_progress.py +144,Meter,metro
DocType: Workstation,Electricity Cost,Costo Elettricità
DocType: HR Settings,Don't send Employee Birthday Reminders,Non inviare Dipendente Birthday Reminders
DocType: Expense Claim,Total Advance Amount,Importo anticipato totale
DocType: Delivery Stop,Estimated Arrival,Arrivo Stimato
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +34,Save Settings,Salva le impostazioni
DocType: Delivery Stop,Notified by Email,Notificato via email
apps/erpnext/erpnext/hub_node/page/hub/hub.js +683,Requested Products,Prodotti richiesti
DocType: Item,Inspection Criteria,Criteri di ispezione
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +14,Transfered,Trasferiti
DocType: BOM Website Item,BOM Website Item,Distinta Base dell'Articolo sul Sito Web
apps/erpnext/erpnext/public/js/setup_wizard.js +52,Upload your letter head and logo. (you can edit them later).,Carica la tua testa lettera e logo. (È possibile modificare in un secondo momento).
DocType: Timesheet Detail,Bill,Conto
apps/erpnext/erpnext/assets/doctype/asset/asset.py +85,Next Depreciation Date is entered as past date,Successivo ammortamento Data viene inserita come data passata
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +208,White,Bianco
DocType: SMS Center,All Lead (Open),Tutti i Lead (Aperti)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +248,Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Riga {0}: Qtà non disponibile per {4} in magazzino {1} al momento della pubblicazione della voce ({2} {3})
DocType: Purchase Invoice,Get Advances Paid,Ottenere anticipo pagamento
DocType: Item,Automatically Create New Batch,Crea automaticamente un nuovo batch
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +808,Make ,Fare
DocType: Student Admission,Admission Start Date,L&#39;ammissione Data di inizio
DocType: Journal Entry,Total Amount in Words,Importo Totale in lettere
apps/erpnext/erpnext/hr/doctype/employee/employee_tree.js +29,New Employee,Nuovo impiegato
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.,Si è verificato un errore . Una ragione probabile potrebbe essere che non si è salvato il modulo. Si prega di contattare support@erpnext.com se il problema persiste .
apps/erpnext/erpnext/templates/pages/cart.html +5,My Cart,Il mio carrello
apps/erpnext/erpnext/controllers/selling_controller.py +126,Order Type must be one of {0},Tipo ordine deve essere uno dei {0}
DocType: Lead,Next Contact Date,Data del contatto successivo
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36,Opening Qty,Quantità di apertura
DocType: Healthcare Settings,Appointment Reminder,Appuntamento promemoria
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +472,Please enter Account for Change Amount,Si prega di inserire account per quantità di modifica
DocType: Student Batch Name,Student Batch Name,Studente Batch Nome
DocType: Consultation,Doctor,Medico
DocType: Holiday List,Holiday List Name,Nome elenco vacanza
DocType: Repayment Schedule,Balance Loan Amount,Importo del prestito di bilancio
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +14,Schedule Course,Programma del corso
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +234,Stock Options,Stock Options
DocType: Journal Entry Account,Expense Claim,Rimborso Spese
apps/erpnext/erpnext/assets/doctype/asset/asset.js +254,Do you really want to restore this scrapped asset?,Vuoi davvero ripristinare questo bene rottamato?
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +380,Qty for {0},Quantità per {0}
DocType: Leave Application,Leave Application,Applicazione Permessi
DocType: Patient,Patient Relation,Relazione paziente
apps/erpnext/erpnext/config/hr.py +80,Leave Allocation Tool,Strumento Allocazione Permessi
DocType: Item,Hub Category to Publish,Categoria Hub per pubblicare
DocType: Leave Block List,Leave Block List Dates,Lascia Blocco Elenco date
DocType: Sales Invoice,Billing Address GSTIN,Indirizzo di fatturazione GSTIN
DocType: Workstation,Net Hour Rate,Tasso Netto Orario
DocType: Landed Cost Purchase Receipt,Landed Cost Purchase Receipt,Landed Cost ricevuta di acquisto
DocType: Company,Default Terms,Termini di pagamento predefinito
DocType: Supplier Scorecard Period,Criteria,criteri
DocType: Packing Slip Item,Packing Slip Item,Distinta di imballaggio articolo
DocType: Purchase Invoice,Cash/Bank Account,Conto Cassa/Banca
apps/erpnext/erpnext/public/js/queries.js +96,Please specify a {0},Si prega di specificare un {0}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +71,Removed items with no change in quantity or value.,Eliminati elementi senza variazione di quantità o valore.
DocType: Delivery Note,Delivery To,Consegna a
apps/erpnext/erpnext/stock/doctype/item/item.js +384,Variant creation has been queued.,La creazione di varianti è stata accodata.
apps/erpnext/erpnext/stock/doctype/item/item.py +668,Attribute table is mandatory,Tavolo attributo è obbligatorio
DocType: Production Planning Tool,Get Sales Orders,Ottieni Ordini di Vendita
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +67,{0} can not be negative,{0} non può essere negativo
DocType: Training Event,Self-Study,Autodidatta
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +537,Discount,Sconto
DocType: Membership,Membership,membri
DocType: Asset,Total Number of Depreciations,Numero totale degli ammortamenti
DocType: Sales Invoice Item,Rate With Margin,Prezzo con margine
DocType: Workstation,Wages,Salari
DocType: Asset Maintenance,Maintenance Manager Name,Nome del responsabile della manutenzione
DocType: Agriculture Task,Urgent,Urgente
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +174,Please specify a valid Row ID for row {0} in table {1},Si prega di specificare un ID Row valido per riga {0} nella tabella {1}
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +84,Unable to find variable: ,Impossibile trovare la variabile:
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +723,Please select a field to edit from numpad,Seleziona un campo da modificare da numpad
apps/erpnext/erpnext/stock/doctype/item/item.py +253,Cannot be a fixed asset item as Stock Ledger is created.,Non può essere un elemento fisso quando viene creato il libro mastro.
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +23,Go to the Desktop and start using ERPNext,Vai al desktop e inizia a usare ERPNext
DocType: Item,Manufacturer,Produttore
DocType: Landed Cost Item,Purchase Receipt Item,Ricevuta di Acquisto Articolo
DocType: Purchase Receipt,PREC-RET-,PREC-RET-
DocType: POS Profile,Sales Invoice Payment,Pagamento Fattura di vendita
DocType: Production Plan Item,Reserved Warehouse in Sales Order / Finished Goods Warehouse,Warehouse Riservato a ordini di vendita / Magazzino prodotti finiti
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +72,Selling Amount,Importo di vendita
DocType: Repayment Schedule,Interest Amount,Ammontare Interessi
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +120,You are the Expense Approver for this record. Please Update the 'Status' and Save,Tu sei il Responsabile approvazione spese per questo record. Aggiorna lo Stato e salva
DocType: Serial No,Creation Document No,Creazione di documenti No
DocType: Issue,Issue,Contestazione
apps/erpnext/erpnext/healthcare/doctype/consultation/consultation_dashboard.py +11,Records,Records
DocType: Asset,Scrapped,Demolita
DocType: Purchase Invoice,Returns,Restituisce
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +42,WIP Warehouse,WIP Warehouse
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +195,Serial No {0} is under maintenance contract upto {1},Serial No {0} è sotto contratto di manutenzione fino a {1}
apps/erpnext/erpnext/config/hr.py +35,Recruitment,Reclutamento
DocType: Lead,Organization Name,Nome organizzazione
DocType: Tax Rule,Shipping State,Stato Spedizione
,Projected Quantity as Source,Proiezione Quantità come sorgente
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +61,Item must be added using 'Get Items from Purchase Receipts' button,L'oggetto deve essere aggiunto utilizzando 'ottenere elementi dal Receipts Purchase pulsante
DocType: Delivery Trip,Delivery Trip,Viaggio di consegna
DocType: Student,A-,A-
DocType: Production Planning Tool,Include non-stock items,Includi elementi non-azione
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117,Sales Expenses,Spese di vendita
DocType: Consultation,Diagnosis,Diagnosi
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +18,Standard Buying,Listino d'Acquisto
DocType: GL Entry,Against,Previsione
DocType: Item,Default Selling Cost Center,Centro di costo di vendita di default
DocType: Sales Partner,Implementation Partner,Partner di implementazione
apps/erpnext/erpnext/accounts/page/pos/pos.js +1613,ZIP Code,CAP
apps/erpnext/erpnext/controllers/selling_controller.py +245,Sales Order {0} is {1},Sales Order {0} è {1}
DocType: Opportunity,Contact Info,Info Contatto
apps/erpnext/erpnext/config/stock.py +315,Making Stock Entries,Creazione scorte
DocType: Packing Slip,Net Weight UOM,Peso Netto (UdM)
DocType: Item,Default Supplier,Fornitore Predefinito
DocType: Manufacturing Settings,Over Production Allowance Percentage,Nel corso di produzione Allowance Percentuale
DocType: Employee Loan,Repayment Schedule,Piano di rimborso
DocType: Shipping Rule Condition,Shipping Rule Condition,Condizioni Tipo di Spedizione
DocType: Holiday List,Get Weekly Off Dates,Ottieni cadenze settimanali
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +33,End Date can not be less than Start Date,Data di Fine non può essere inferiore a Data di inizio
DocType: Sales Person,Select company name first.,Selezionare il nome della società prima.
apps/erpnext/erpnext/hub_node/page/hub/hub.js +181,Low to High,Dal basso all&#39;alto
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +202,Email sent to {0},E-mail inviata a {0}
apps/erpnext/erpnext/config/buying.py +23,Quotations received from Suppliers.,Preventivi ricevuti dai Fornitori.
apps/erpnext/erpnext/config/manufacturing.py +74,Replace BOM and update latest price in all BOMs,Sostituire il BOM e aggiornare il prezzo più recente in tutte le BOM
apps/erpnext/erpnext/controllers/selling_controller.py +24,To {0} | {1} {2},Per {0} | {1} {2}
DocType: Delivery Trip,Driver Name,Nome del driver
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40,Average Age,Età media
DocType: Education Settings,Attendance Freeze Date,Data di congelamento della frequenza
apps/erpnext/erpnext/utilities/user_progress.py +107,List a few of your suppliers. They could be organizations or individuals.,Elencare alcuni dei vostri fornitori . Potrebbero essere società o persone fisiche
apps/erpnext/erpnext/templates/pages/home.html +31,View All Products,Visualizza tutti i prodotti
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20,Minimum Lead Age (Days),Età di piombo minima (giorni)
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +57,All BOMs,tutte le Distinte Materiali
DocType: Patient,Default Currency,Valuta Predefinita
DocType: Expense Claim,From Employee,Da Dipendente
DocType: Driver,Cellphone Number,numero di cellulare
apps/erpnext/erpnext/controllers/accounts_controller.py +451,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,Attenzione : Il sistema non controlla fatturazione eccessiva poiché importo per la voce {0} in {1} è zero
DocType: Journal Entry,Make Difference Entry,Aggiungi Differenza
DocType: Upload Attendance,Attendance From Date,Partecipazione Da Data
DocType: Appraisal Template Goal,Key Performance Area,Area Chiave Prestazioni
DocType: Program Enrollment,Transportation,Trasporto
apps/erpnext/erpnext/controllers/item_variant.py +92,Invalid Attribute,attributo non valido
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +229,{0} {1} must be submitted,{0} {1} deve essere confermato
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +151,Quantity must be less than or equal to {0},La quantità deve essere minore o uguale a {0}
DocType: SMS Center,Total Characters,Totale Personaggi
DocType: Employee Advance,Claimed,Ha sostenuto
DocType: Crop,Row Spacing,Row Spacing
apps/erpnext/erpnext/controllers/buying_controller.py +161,Please select BOM in BOM field for Item {0},Seleziona BOM BOM in campo per la voce {0}
DocType: C-Form Invoice Detail,C-Form Invoice Detail,C-Form Detagli Fattura
DocType: Payment Reconciliation Invoice,Payment Reconciliation Invoice,Pagamento Riconciliazione fattura
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +42,Contribution %,Contributo%
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +215,"As per the Buying Settings if Purchase Order Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Order first for item {0}","Come per le impostazioni di acquisto se l&#39;ordine di acquisto richiede == &#39;YES&#39;, quindi per la creazione di fattura di acquisto, l&#39;utente deve creare l&#39;ordine di acquisto per l&#39;elemento {0}"
DocType: Company,Company registration numbers for your reference. Tax numbers etc.,"Numeri di registrazione dell'azienda per il vostro riferimento. numero Tassa, ecc"
DocType: Sales Partner,Distributor,Distributore
DocType: Shopping Cart Shipping Rule,Shopping Cart Shipping Rule,Tipo di Spedizione del Carrello
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +252,Production Order {0} must be cancelled before cancelling this Sales Order,Ordine di produzione {0} deve essere cancellato prima di annullare questo ordine di vendita
apps/erpnext/erpnext/public/js/controllers/transaction.js +71,Please set 'Apply Additional Discount On',Impostare 'Applicare lo Sconto Aggiuntivo su'
,Ordered Items To Be Billed,Articoli ordinati da fatturare
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +46,From Range has to be less than To Range,Da Campo deve essere inferiore al campo
DocType: Global Defaults,Global Defaults,Predefiniti Globali
apps/erpnext/erpnext/projects/doctype/project/project.py +226,Project Collaboration Invitation,Progetto di collaborazione Invito
DocType: Salary Slip,Deductions,Deduzioni
DocType: Leave Allocation,LAL/,LAL /
DocType: Setup Progress Action,Action Name,Nome azione
apps/erpnext/erpnext/public/js/financial_statements.js +75,Start Year,Inizio Anno
apps/erpnext/erpnext/regional/india/utils.py +24,First 2 digits of GSTIN should match with State number {0},Le prime 2 cifre di GSTIN dovrebbero corrispondere al numero di stato {0}
DocType: Purchase Invoice,Start date of current invoice's period,Data finale del periodo di fatturazione corrente Avviare
DocType: Salary Slip,Leave Without Pay,Lascia senza stipendio
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +366,Capacity Planning Error,Capacity Planning Errore
,Trial Balance for Party,Bilancio di verifica per Partner
DocType: Lead,Consultant,Consulente
DocType: Salary Slip,Earnings,Rendimenti
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +416,Finished Item {0} must be entered for Manufacture type entry,Voce Finito {0} deve essere inserito per il tipo di fabbricazione ingresso
apps/erpnext/erpnext/config/learn.py +87,Opening Accounting Balance,Apertura bilancio contabile
,GST Sales Register,Registro delle vendite GST
DocType: Sales Invoice Advance,Sales Invoice Advance,Fattura di vendita (anticipata)
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +550,Nothing to request,Niente da chiedere
apps/erpnext/erpnext/public/js/setup_wizard.js +18,Select your Domains,Seleziona i tuoi domini
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +34,Another Budget record '{0}' already exists against {1} '{2}' for fiscal year {3},Un altro record di bilancio &#39;{0}&#39; esiste già contro {1} &#39;{2}&#39; per l&#39;anno fiscale {3}
DocType: Item Variant Settings,Fields will be copied over only at time of creation.,I campi verranno copiati solo al momento della creazione.
apps/erpnext/erpnext/projects/doctype/task/task.py +41,'Actual Start Date' can not be greater than 'Actual End Date','Data Inizio effettivo' non può essere maggiore di 'Data di fine effettiva'
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +117,Management,Amministrazione
DocType: Cheque Print Template,Payer Settings,Impostazioni Pagatore
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""","Questo sarà aggiunto al codice articolo della variante. Ad esempio, se la sigla è ""SM"", e il codice articolo è ""T-SHIRT"", il codice articolo della variante sarà ""T-SHIRT-SM"""
DocType: Salary Slip,Net Pay (in words) will be visible once you save the Salary Slip.,Paga Netta (in lettere) sarà visibile una volta che si salva la busta paga.
DocType: Purchase Invoice,Is Return,È Return
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +81,Caution,Attenzione
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +813,Return / Debit Note,Reso / Nota di Debito
DocType: Price List Country,Price List Country,Listino Prezzi Nazione
DocType: Item,UOMs,Unità di Misure
apps/erpnext/erpnext/stock/utils.py +210,{0} valid serial nos for Item {1},{0} numeri di serie validi per l'articolo {1}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +57,Item Code cannot be changed for Serial No.,Codice Articolo non può essere modificato per N. di Serie
DocType: Purchase Invoice Item,UOM Conversion Factor,Fattore di conversione Unità di Misura
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +40,Please enter Item Code to get Batch Number,Inserisci Codice Articolo per ottenere il numero di lotto
DocType: Stock Settings,Default Item Group,Gruppo Articoli Predefinito
DocType: Employee Loan,Partially Disbursed,parzialmente erogato
apps/erpnext/erpnext/config/non_profit.py +73,Grant information.,Concedere informazioni
apps/erpnext/erpnext/config/buying.py +38,Supplier database.,Database dei fornitori.
DocType: Account,Balance Sheet,Bilancio Patrimoniale
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +748,Cost Center For Item with Item Code ',Centro di costo per articoli con Codice Prodotto '
DocType: Fee Validity,Valid Till,Valido fino a
apps/erpnext/erpnext/accounts/page/pos/pos.js +2473,"Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.","Modalità di pagamento non è configurato. Si prega di verificare, se account è stato impostato sulla modalità di pagamento o su POS profilo."
apps/erpnext/erpnext/buying/utils.py +74,Same item cannot be entered multiple times.,Lo stesso articolo non può essere inserito più volte.
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +30,"Further accounts can be made under Groups, but entries can be made against non-Groups","Ulteriori conti possono essere fatti in Gruppi, ma le voci possono essere fatte contro i non-Gruppi"
DocType: Lead,Lead,Lead
DocType: Email Digest,Payables,Debiti
DocType: Course,Course Intro,corso di Introduzione
apps/erpnext/erpnext/stock/doctype/batch/batch.js +97,Stock Entry {0} created,Entrata Scorte di Magazzino {0} creata
apps/erpnext/erpnext/controllers/buying_controller.py +298,Row #{0}: Rejected Qty can not be entered in Purchase Return,Row # {0}: Rifiutato Quantità non è possibile entrare in acquisto di ritorno
,Purchase Order Items To Be Billed,Articoli dell'Ordine di Acquisto da fatturare
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +45,Updating estimated arrival times.,Aggiornamento dei tempi di arrivo stimati.
DocType: Purchase Invoice Item,Net Rate,Tasso Netto
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +147,Please select a customer,Seleziona un cliente
DocType: Purchase Invoice Item,Purchase Invoice Item,Articolo della Fattura di Acquisto
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +58,Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,Inserimenti Inventario e Libro Mastro sono aggiornati per le Ricevute di Acquisto selezionate
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +8,Item 1,Articolo 1
DocType: Holiday,Holiday,Vacanza
DocType: Support Settings,Close Issue After Days,Chiudi problema dopo giorni
DocType: Leave Control Panel,Leave blank if considered for all branches,Lasciare vuoto se considerato per tutti i rami
DocType: Bank Guarantee,Validity in Days,Validità in giorni
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +21,C-form is not applicable for Invoice: {0},C-forma non è applicabile per la fattura: {0}
DocType: Payment Reconciliation,Unreconciled Payment Details,Dettagli di pagamento non riconciliati
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20,Order Count,Conteggio ordini
DocType: Global Defaults,Current Fiscal Year,Anno Fiscale Corrente
DocType: Purchase Order,Group same items,stessi articoli di gruppo
DocType: Purchase Invoice,Disable Rounded Total,Disabilita Arrotondamento su Totale
DocType: Employee Loan Application,Repayment Info,Info rimborso
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +446,'Entries' cannot be empty,'le voci' non possono essere vuote
DocType: Maintenance Team Member,Maintenance Role,Ruolo di manutenzione
apps/erpnext/erpnext/utilities/transaction_base.py +81,Duplicate row {0} with same {1},Fila Duplicate {0} con lo stesso {1}
,Trial Balance,Bilancio di verifica
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +438,Fiscal Year {0} not found,Anno fiscale {0} non trovato
apps/erpnext/erpnext/config/hr.py +305,Setting up Employees,Impostazione dipendenti
DocType: Sales Order,SO-,COSÌ-
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +153,Please select prefix first,Si prega di selezionare il prefisso prima
DocType: Student,O-,O-
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +189,Research,ricerca
DocType: Maintenance Visit Purpose,Work Done,Attività svolta
apps/erpnext/erpnext/controllers/item_variant.py +33,Please specify at least one attribute in the Attributes table,Specifica almeno un attributo nella tabella Attributi
DocType: Announcement,All Students,Tutti gli studenti
apps/erpnext/erpnext/assets/doctype/asset/asset.py +45,Item {0} must be a non-stock item,Voce {0} deve essere un elemento non-azione
apps/erpnext/erpnext/stock/doctype/batch/batch.js +18,View Ledger,vista Ledger
DocType: Grading Scale,Intervals,intervalli
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Earliest,La prima
apps/erpnext/erpnext/stock/doctype/item/item.py +500,"An Item Group exists with same name, please change the item name or rename the item group","Esiste un gruppo di articoli con lo stesso nome, si prega di cambiare il nome dell'articolo o di rinominare il gruppo di articoli"
DocType: Crop Cycle,Less than a year,Meno di un anno
apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +52,Student Mobile No.,No. studente in mobilità
apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +105,Rest Of The World,Resto del Mondo
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +81,The Item {0} cannot have Batch,L'articolo {0} non può avere Lotto
DocType: Crop,Yield UOM,Resa UOM
,Budget Variance Report,Report Variazione Budget
DocType: Salary Slip,Gross Pay,Paga lorda
DocType: Item,Is Item from Hub,È elemento da Hub
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +118,Row {0}: Activity Type is mandatory.,Riga {0}: Tipo Attività è obbligatoria.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +166,Dividends Paid,Dividendo liquidato
apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +36,Accounting Ledger,Libro Mastro Contabile
DocType: Stock Reconciliation,Difference Amount,Differenza Importo
DocType: Purchase Invoice,Reverse Charge,Carica inversa
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +172,Retained Earnings,Utili Trattenuti
DocType: Vehicle Log,Service Detail,Particolare di servizio
DocType: BOM,Item Description,Descrizione Articolo
DocType: Student Sibling,Student Sibling,Student Sibling
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +18,Payment Mode,Modalità di pagamento
DocType: Purchase Invoice,Supplied Items,Elementi in dotazione
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +85,Please set an active menu for Restaurant {0},Imposta un menu attivo per il ristorante {0}
DocType: Student,STUD.,PERNO.
DocType: Production Order,Qty To Manufacture,Qtà da Produrre
DocType: Email Digest,New Income,Nuovo reddito
DocType: Buying Settings,Maintain same rate throughout purchase cycle,Mantenere la stessa tariffa per l'intero ciclo di acquisto
DocType: Opportunity Item,Opportunity Item,Opportunità articolo
,Student and Guardian Contact Details,Student and Guardian Contatti
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +51,Row {0}: For supplier {0} Email Address is required to send email,Riga {0}: Per il fornitore {0} l'Indirizzo e-mail è richiesto per inviare l'e-mail
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +72,Temporary Opening,Apertura temporanea
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +10,View Hub,Visualizza Hub
,Employee Leave Balance,Saldo del Congedo Dipendete
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +147,Balance for Account {0} must always be {1},Il Saldo del Conto {0} deve essere sempre {1}
DocType: Patient Appointment,More Info,Ulteriori Informazioni
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +178,Valuation Rate required for Item in row {0},Tasso di valorizzazione richiesto per la voce sulla riga {0}
DocType: Supplier Scorecard,Scorecard Actions,Azioni Scorecard
apps/erpnext/erpnext/utilities/user_progress.py +166,Example: Masters in Computer Science,Esempio: Master in Computer Science
DocType: Purchase Invoice,Rejected Warehouse,Magazzino Rifiutato
DocType: GL Entry,Against Voucher,Per Tagliando
DocType: Item,Default Buying Cost Center,Comprare Centro di costo predefinito
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +6,"To get the best out of ERPNext, we recommend that you take some time and watch these help videos.","Per ottenere il meglio da ERPNext, si consiglia di richiedere un certo tempo e guardare questi video di aiuto."
apps/erpnext/erpnext/accounts/page/pos/pos.js +76, to ,a
DocType: Supplier Quotation Item,Lead Time in days,Tempo di Consegna in giorni
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +58,Accounts Payable Summary,Conti pagabili Sommario
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +321,Payment of salary from {0} to {1},Il pagamento dello stipendio da {0} a {1}
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +213,Not authorized to edit frozen Account {0},Non autorizzato a modificare account congelati {0}
DocType: Journal Entry,Get Outstanding Invoices,Ottieni fatture non saldate
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +84,Sales Order {0} is not valid,Sales Order {0} non è valido
DocType: Supplier Scorecard,Warn for new Request for Quotations,Avvisa per la nuova richiesta per le citazioni
apps/erpnext/erpnext/utilities/activation.py +91,Purchase orders help you plan and follow up on your purchases,Gli ordini di acquisto ti aiutano a pianificare e monitorare i tuoi acquisti
apps/erpnext/erpnext/setup/doctype/company/company.py +215,"Sorry, companies cannot be merged","Siamo spiacenti , le aziende non possono essere unite"
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +151,Lab Test Prescriptions,Prescrizioni di laboratorio
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +162,"The total Issue / Transfer quantity {0} in Material Request {1}  \
							cannot be greater than requested quantity {2} for Item {3}",La quantità emissione / trasferimento totale {0} in Materiale Richiesta {1} \ non può essere maggiore di quantità richiesta {2} per la voce {3}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +197,Small,Piccolo
DocType: Opening Invoice Creation Tool Item,Opening Invoice Creation Tool Item,Apertura dello strumento per la creazione di fatture
DocType: Education Settings,Employee Number,Numero Dipendente
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +67,Case No(s) already in use. Try from Case No {0},Caso n ( s) già in uso . Prova da Caso n {0}
DocType: Project,% Completed,% Completato
,Invoiced Amount (Exculsive Tax),Importo fatturato ( Exculsive Tax)
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +14,Item 2,Articolo 2
DocType: Supplier,SUPP-,SUPP-
DocType: Training Event,Training Event,evento di formazione
DocType: Item,Auto re-order,Auto riordino
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +59,Total Achieved,Totale Raggiunto
DocType: Employee,Place of Issue,Luogo di emissione
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +101,Contract,contratto
DocType: Plant Analysis,Laboratory Testing Datetime,Test di laboratorio datetime
DocType: Email Digest,Add Quote,Aggiungi Citazione
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +932,UOM coversion factor required for UOM: {0} in Item: {1},Fattore di conversione Unità di Misura è obbligatorio per Unità di Misura: {0} alla voce: {1}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +92,Indirect Expenses,spese indirette
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +88,Row {0}: Qty is mandatory,Riga {0}: Quantità è obbligatorio
DocType: Agriculture Analysis Criteria,Agriculture,agricoltura
apps/erpnext/erpnext/accounts/page/pos/pos.js +785,Sync Master Data,Sync Master Data
DocType: Asset Repair,Repair Cost,costo di riparazione
apps/erpnext/erpnext/utilities/user_progress.py +135,Your Products or Services,I vostri prodotti o servizi
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +15,Failed to login,Impossibile accedere
DocType: Special Test Items,Special Test Items,Articoli speciali di prova
DocType: Mode of Payment,Mode of Payment,Modalità di Pagamento
apps/erpnext/erpnext/stock/doctype/item/item.py +192,Website Image should be a public file or website URL,Website Immagine dovrebbe essere un file o URL del sito web pubblico
DocType: Student Applicant,AP,AP
DocType: Purchase Invoice Item,BOM,BOM
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +37,This is a root item group and cannot be edited.,Questo è un gruppo elemento principale e non può essere modificato .
DocType: Journal Entry Account,Purchase Order,Ordine di acquisto
DocType: Vehicle,Fuel UOM,Fuel UOM
DocType: Warehouse,Warehouse Contact Info,Contatti Magazzino
DocType: Payment Entry,Write Off Difference Amount,Importo a differenza Svalutazione
DocType: Volunteer,Volunteer Name,Nome del volontario
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +434,"{0}: Employee email not found, hence email not sent","{0}: Indirizzo e-mail del dipendente non trovato, e-mail non inviata"
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +85,Shipping rule not applicable for country {0},Regola di spedizione non applicabile per il paese {0}
DocType: Item,Foreign Trade Details,Commercio Estero Dettagli
,Assessment Plan Status,Stato del piano di valutazione
DocType: Email Digest,Annual Income,Reddito annuo
DocType: Serial No,Serial No Details,Serial No Dettagli
DocType: Purchase Invoice Item,Item Tax Rate,Articolo Tax Rate
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +75,Please select Physician and Date,Seleziona Medico e Data
DocType: Student Group Student,Group Roll Number,Numero di rotolo di gruppo
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +143,"For {0}, only credit accounts can be linked against another debit entry","Per {0}, solo i conti di credito possono essere collegati contro un'altra voce di addebito"
apps/erpnext/erpnext/projects/doctype/project/project.py +80,Total of all task weights should be 1. Please adjust weights of all Project tasks accordingly,Totale di tutti i pesi delle attività dovrebbe essere 1. Modificare i pesi di tutte le attività del progetto di conseguenza
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +582,Delivery Note {0} is not submitted,Il Documento di Trasporto {0} non è confermato
apps/erpnext/erpnext/stock/get_item_details.py +146,Item {0} must be a Sub-contracted Item,L'Articolo {0} deve essere di un sub-contratto
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +43,Capital Equipments,Attrezzature Capital
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +33,"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Regola Prezzi viene prima selezionato in base al 'applicare sul campo', che può essere prodotto, Articolo di gruppo o di marca."
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +245,Please set the Item Code first,Impostare prima il codice dell&#39;articolo
DocType: Item,ITEM-,ARTICOLO-
apps/erpnext/erpnext/controllers/selling_controller.py +119,Total allocated percentage for sales team should be 100,Totale percentuale assegnato per il team di vendita dovrebbe essere di 100
DocType: Sales Invoice Item,Edit Description,Modifica Descrizione
DocType: Antibiotic,Antibiotic,Antibiotico
,Team Updates,squadra Aggiornamenti
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +910,For Supplier,per Fornitore
DocType: Account,Setting Account Type helps in selecting this Account in transactions.,Impostazione Tipo di account aiuta nella scelta questo account nelle transazioni.
DocType: Purchase Invoice,Grand Total (Company Currency),Somma totale (valuta Azienda)
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Create Print Format,Creare Formato di stampa
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +5,Fee Created,Fee creata
apps/erpnext/erpnext/utilities/bot.py +39,Did not find any item called {0},Non hai trovato alcun oggetto chiamato {0}
DocType: Supplier Scorecard Criteria,Criteria Formula,Criteri Formula
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Total Outgoing,Uscita totale
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +39,"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""","Può esserci una sola Condizione per Tipo di Spedizione con valore 0 o con valore vuoto per ""A Valore"""
DocType: Authorization Rule,Transaction,Transazioni
DocType: Patient Appointment,Duration,Durata
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +27,Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Nota : Questo centro di costo è un gruppo . Non può fare scritture contabili contro i gruppi .
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +54,Child warehouse exists for this warehouse. You can not delete this warehouse.,Esiste magazzino Bambino per questo magazzino. Non è possibile eliminare questo magazzino.
DocType: Item,Website Item Groups,Sito gruppi di articoli
DocType: Purchase Invoice,Total (Company Currency),Totale (Valuta Società)
apps/erpnext/erpnext/stock/utils.py +205,Serial number {0} entered more than once,Numero di serie {0} è entrato più di una volta
DocType: Journal Entry,Journal Entry,Registrazione Contabile
DocType: Expense Claim Advance,Unclaimed amount,Importo non reclamato
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +148,{0} items in progress,{0} articoli in lavorazione
DocType: Workstation,Workstation Name,Nome Stazione di lavoro
DocType: Grading Scale Interval,Grade Code,Codice grado
DocType: POS Item Group,POS Item Group,POS Gruppo Articolo
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +17,Email Digest:,Email di Sintesi:
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +591,BOM {0} does not belong to Item {1},Distinta Base {0} non appartiene alla voce {1}
DocType: Sales Partner,Target Distribution,Distribuzione di destinazione
DocType: Salary Slip,Bank Account No.,Conto Bancario N.
DocType: Naming Series,This is the number of the last created transaction with this prefix,Questo è il numero dell&#39;ultimo transazione creata con questo prefisso
DocType: Supplier Scorecard,"Scorecard variables can be used, as well as:
{total_score} (the total score from that period),
{period_number} (the number of periods to present day)
","Possono essere utilizzate variabili Scorecard, nonché: {total_score} (il punteggio totale di quel periodo), {period_number} (il numero di periodi fino al presente)"
DocType: Quality Inspection Reading,Reading 8,Lettura 8
DocType: Sales Partner,Agent,Agente
DocType: Purchase Invoice,Taxes and Charges Calculation,Tasse e le spese di calcolo
DocType: Accounts Settings,Book Asset Depreciation Entry Automatically,Apprendere automaticamente l&#39;ammortamento dell&#39;attivo
DocType: BOM Operation,Workstation,Stazione di lavoro
DocType: Request for Quotation Supplier,Request for Quotation Supplier,Fornitore della richiesta di offerta
DocType: Healthcare Settings,Registration Message,Messaggio di registrazione
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +154,Hardware,Hardware
DocType: Prescription Dosage,Prescription Dosage,Dosaggio prescrizione
DocType: Attendance,HR Manager,HR Manager
apps/erpnext/erpnext/accounts/party.py +178,Please select a Company,Seleziona una società
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +92,Privilege Leave,Lascia Privilege
DocType: Purchase Invoice,Supplier Invoice Date,Data Fattura Fornitore
apps/erpnext/erpnext/templates/includes/product_page.js +18,per,per
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +90,You need to enable Shopping Cart,È necessario abilitare Carrello
DocType: Payment Entry,Writeoff,Cancellare
DocType: Appraisal Template Goal,Appraisal Template Goal,Valutazione Modello Obiettivo
DocType: Salary Component,Earning,Rendimento
DocType: Supplier Scorecard,Scoring Criteria,Criteri di punteggio
DocType: Purchase Invoice,Party Account Currency,Valuta Conto del Partner
,BOM Browser,Sfoglia BOM
apps/erpnext/erpnext/templates/emails/training_event.html +13,Please update your status for this training event,Aggiorna il tuo stato per questo evento di addestramento
DocType: Purchase Taxes and Charges,Add or Deduct,Aggiungi o Sottrai
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +148,Overlapping conditions found between:,Condizioni sovrapposti trovati tra :
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +187,Against Journal Entry {0} is already adjusted against some other voucher,Contro diario {0} è già regolata contro un altro buono
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +68,Total Order Value,Totale valore di ordine
apps/erpnext/erpnext/demo/setup/setup_data.py +328,Food,cibo
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +51,Ageing Range 3,Gamma invecchiamento 3
DocType: Maintenance Schedule Item,No of Visits,Num. di Visite
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +165,Maintenance Schedule {0} exists against {1},Il programma di manutenzione {0} esiste contro {1}
apps/erpnext/erpnext/hub_node/page/hub/hub.js +118,Do you want to publish your Items to Hub ?,Vuoi pubblicare i tuoi articoli in Hub?
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +36,Enrolling student,studente iscrivendosi
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +33,Currency of the Closing Account must be {0},Valuta del Conto di chiusura deve essere {0}
apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py +21,Sum of points for all goals should be 100. It is {0},Somma dei punti per tutti gli obiettivi dovrebbero essere 100. E &#39;{0}
DocType: Project,Start and End Dates,Date di inizio e fine
,Delivered Items To Be Billed,Gli Articoli consegnati da Fatturare
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +16,Open BOM {0},Apri la Distinta Base {0}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +60,Warehouse cannot be changed for Serial No.,Magazzino non può essere modificato per Serial No.
DocType: Authorization Rule,Average Discount,Sconto Medio
DocType: Purchase Invoice Item,UOM,Unità di misura
DocType: Rename Tool,Utilities,Utilità
DocType: POS Profile,Accounting,Contabilità
DocType: Employee,EMP/,EMP /
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +133,Please select batches for batched item ,Si prega di selezionare i batch per l&#39;articolo in scatola
DocType: Asset,Depreciation Schedules,piani di ammortamento
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +89,Application period cannot be outside leave allocation period,Periodo di applicazione non può essere periodo di assegnazione congedo di fuori
DocType: Activity Cost,Projects,Progetti
DocType: Payment Request,Transaction Currency,transazioni valutarie
apps/erpnext/erpnext/controllers/buying_controller.py +27,From {0} | {1} {2},Da {0} | {1} {2}
DocType: Production Order Operation,Operation Description,Operazione Descrizione
DocType: Item,Will also apply to variants,Si applicheranno anche alle varianti
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +34,Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,Impossibile modificare Fiscal Year data di inizio e di fine anno fiscale una volta l'anno fiscale è stato salvato.
DocType: Quotation,Shopping Cart,Carrello spesa
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Avg Daily Outgoing,Media giornaliera in uscita
DocType: POS Profile,Campaign,Campagna
DocType: Supplier,Name and Type,Nome e Tipo
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +66,Approval Status must be 'Approved' or 'Rejected',Stato approvazione deve essere ' Approvato ' o ' Rifiutato '
DocType: Physician,Contacts and Address,Contatti e indirizzo
DocType: Purchase Invoice,Contact Person,Persona di Riferimento
apps/erpnext/erpnext/projects/doctype/task/task.py +38,'Expected Start Date' can not be greater than 'Expected End Date','Data prevista di inizio' non può essere maggiore di 'Data di fine prevista'
DocType: Course Scheduling Tool,Course End Date,Corso Data fine
DocType: Holiday List,Holidays,Vacanze
DocType: Sales Order Item,Planned Quantity,Quantità Prevista
DocType: Purchase Invoice Item,Item Tax Amount,Articolo fiscale Ammontare
DocType: Water Analysis,Water Analysis Criteria,Criteri di analisi dell&#39;acqua
DocType: Item,Maintain Stock,Movimenta l'articolo in magazzino
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +217,Stock Entries already created for Production Order ,Le voci di archivio già creati per ordine di produzione
DocType: Employee,Prefered Email,preferito Email
DocType: Student Admission,Eligibility and Details,Eligibilità e dettagli
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +33,Net Change in Fixed Asset,Variazione netta delle immobilizzazioni
DocType: Leave Control Panel,Leave blank if considered for all designations,Lasciare vuoto se considerato per tutte le designazioni
apps/erpnext/erpnext/controllers/accounts_controller.py +775,Charge of type 'Actual' in row {0} cannot be included in Item Rate,Carica di tipo ' Actual ' in riga {0} non può essere incluso nella voce Tasso
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +381,Max: {0},Max: {0}
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,From Datetime,Da Datetime
DocType: Email Digest,For Company,Per Azienda
apps/erpnext/erpnext/config/support.py +17,Communication log.,Log comunicazione
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +193,"Request for Quotation is disabled to access from portal, for more check portal settings.","Richiesta di offerta disabilitata per l'accesso dal portale, verificare le configurazioni del portale"
DocType: Supplier Scorecard Scoring Variable,Supplier Scorecard Scoring Variable,Variabile di punteggio dei punteggi dei fornitori
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +73,Buying Amount,Importo Acquisto
DocType: Sales Invoice,Shipping Address Name,Destinazione
DocType: Material Request,Terms and Conditions Content,Termini e condizioni contenuti
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +18,There were errors creating Course Schedule,Si sono verificati degli errori durante la creazione del programma del corso
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +580,cannot be greater than 100,non può essere superiore a 100
apps/erpnext/erpnext/stock/doctype/item/item.py +720,Item {0} is not a stock Item,L'articolo {0} non è in Giagenza
DocType: Maintenance Visit,Unscheduled,Non in programma
DocType: Employee,Owned,Di proprietà
DocType: Salary Detail,Depends on Leave Without Pay,Dipende in aspettativa senza assegni
DocType: Pricing Rule,"Higher the number, higher the priority","Più alto è il numero, maggiore è la priorità"
,Purchase Invoice Trends,Andamento Fatture di Acquisto
DocType: Employee,Better Prospects,Prospettive Migliori
apps/erpnext/erpnext/stock/doctype/batch/batch.py +119,"Row #{0}: The batch {1} has only {2} qty. Please select another batch which has {3} qty available or split the row into multiple rows, to deliver/issue from multiple batches","Riga # {0}: Il batch {1} ha solo {2} qty. Si prega di selezionare un altro batch che dispone di {3} qty disponibile o si divide la riga in più righe, per consegnare / emettere da più batch"
DocType: Vehicle,License Plate,Targa
DocType: Appraisal,Goals,Obiettivi
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +343,Select POS Profile,Selezionare Profilo POS
DocType: Warranty Claim,Warranty / AMC Status,Garanzia / AMC Stato
,Accounts Browser,Esplora Conti
DocType: Payment Entry Reference,Payment Entry Reference,Pagamento voce di riferimento
DocType: GL Entry,GL Entry,GL Entry
DocType: HR Settings,Employee Settings,Impostazioni dipendente
,Batch-Wise Balance History,Cronologia Bilanciamento Lotti-Wise
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +73,Print settings updated in respective print format,Le impostazioni di stampa aggiornati nel rispettivo formato di stampa
DocType: Package Code,Package Code,Codice Confezione
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +105,Apprentice,apprendista
DocType: Purchase Invoice,Company GSTIN,Azienda GSTIN
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +103,Negative Quantity is not allowed,Quantità negative non è consentito
DocType: Purchase Invoice Item,"Tax detail table fetched from item master as a string and stored in this field.
Used for Taxes and Charges","Dettaglio Tax tavolo prelevato dalla voce principale come una stringa e memorizzati in questo campo.
 Utilizzato per imposte e oneri"
DocType: Supplier Scorecard Period,SSC-,SSC
apps/erpnext/erpnext/hr/doctype/employee/employee.py +159,Employee cannot report to himself.,Il dipendente non può riportare a se stesso.
DocType: Account,"If the account is frozen, entries are allowed to restricted users.","Se l'account viene bloccato , le voci sono autorizzati a utenti con restrizioni ."
DocType: Email Digest,Bank Balance,Saldo bancario
apps/erpnext/erpnext/accounts/party.py +243,Accounting Entry for {0}: {1} can only be made in currency: {2},Ingresso contabile per {0}: {1} può essere fatto solo in valuta: {2}
DocType: Job Opening,"Job profile, qualifications required etc.","Profilo Posizione , qualifiche richieste ecc"
DocType: Journal Entry Account,Account Balance,Saldo a bilancio
apps/erpnext/erpnext/config/accounts.py +183,Tax Rule for transactions.,Regola fiscale per le operazioni.
DocType: Rename Tool,Type of document to rename.,Tipo di documento da rinominare.
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +53,{0} {1}: Customer is required against Receivable account {2},{0} {1}:Per la Contabilità Clienti è necessario specificare un Cliente  {2}
DocType: Purchase Invoice,Total Taxes and Charges (Company Currency),Totale tasse e spese (Azienda valuta)
DocType: Weather,Weather Parameter,Parametro meteorologico
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +60,Show unclosed fiscal year's P&L balances,Mostra di P &amp; L saldi non chiusa anno fiscale di
DocType: Lab Test Template,Collection Details,Dettagli raccolta
DocType: POS Profile,Allow Print Before Pay,Consenti stampa prima del pagamento
DocType: Land Unit,Linked Soil Texture,Texture del suolo collegata
DocType: Shipping Rule,Shipping Account,Conto di Spedizione
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +92,{0} {1}: Account {2} is inactive,{0} {1}: Il conto {2} è inattivo
apps/erpnext/erpnext/utilities/activation.py +82,Make Sales Orders to help you plan your work and deliver on-time,Creare gli Ordini di Vendita ti aiuta a pianificare la lavorazione e a consegnare entro i tempi stabiliti
DocType: Quality Inspection,Readings,Letture
DocType: Stock Entry,Total Additional Costs,Totale Costi aggiuntivi
DocType: Course Schedule,SH,SH
DocType: BOM,Scrap Material Cost(Company Currency),Scrap Materiale Costo (Società di valuta)
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +66,Sub Assemblies,sub Assemblies
DocType: Asset,Asset Name,Asset Nome
DocType: Project,Task Weight,Peso Attività
DocType: Shipping Rule Condition,To Value,Per Valore
DocType: Asset Movement,Stock Manager,Responsabile di magazzino
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +149,Source warehouse is mandatory for row {0},Il Magazzino di provenienza è obbligatorio per il rigo {0}
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +38,The Payment Term at row {0} is possibly a duplicate.,Il termine di pagamento nella riga {0} è probabilmente un duplicato.
apps/erpnext/erpnext/public/js/setup_wizard.js +30,Agriculture (beta),Agricoltura (beta)
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +856,Packing Slip,Documento di trasporto
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +110,Office Rent,Affitto Ufficio
apps/erpnext/erpnext/config/setup.py +111,Setup SMS gateway settings,Configura impostazioni gateway SMS
DocType: Disease,Common Name,Nome comune
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +61,Import Failed!,Importazione non riuscita!
apps/erpnext/erpnext/public/js/templates/address_list.html +20,No address added yet.,Nessun indirizzo ancora aggiunto.
DocType: Workstation Working Hour,Workstation Working Hour,Ore di lavoro Workstation
DocType: Vital Signs,Blood Pressure,Pressione sanguigna
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +125,Analyst,analista
DocType: Item,Inventory,Inventario
DocType: Item,Sales Details,Dettagli di vendita
DocType: Quality Inspection,QI-,Qi-
DocType: Opportunity,With Items,Con gli articoli
DocType: Asset Maintenance,Maintenance Team,Squadra di manutenzione
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,In Qty,Qtà
DocType: Education Settings,Validate Enrolled Course for Students in Student Group,Validate il Corso iscritto agli studenti del gruppo studente
DocType: Notification Control,Expense Claim Rejected,Rimborso Spese Rifiutato
DocType: Item,Item Attribute,Attributo Articolo
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +147,Government,Governo
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +40,Expense Claim {0} already exists for the Vehicle Log,Rimborso spese {0} esiste già per il registro di veicoli
apps/erpnext/erpnext/public/js/setup_wizard.js +64,Institute Name,Nome Istituto
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +117,Please enter repayment Amount,Si prega di inserire l&#39;importo di rimborso
apps/erpnext/erpnext/config/stock.py +305,Item Variants,Varianti Voce
apps/erpnext/erpnext/public/js/setup_wizard.js +29,Services,Servizi
DocType: HR Settings,Email Salary Slip to Employee,E-mail busta paga per i dipendenti
DocType: Cost Center,Parent Cost Center,Parent Centro di costo
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1039,Select Possible Supplier,Selezionare il Fornitore Possibile
DocType: Sales Invoice,Source,Fonte
apps/erpnext/erpnext/templates/pages/projects.html +31,Show closed,Mostra chiusa
DocType: Leave Type,Is Leave Without Pay,È lasciare senza stipendio
apps/erpnext/erpnext/stock/doctype/item/item.py +250,Asset Category is mandatory for Fixed Asset item,Asset categoria è obbligatoria per voce delle immobilizzazioni
DocType: Fee Validity,Fee Validity,Validità della tariffa
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +145,No records found in the Payment table,Nessun record trovato nella tabella di Pagamento
apps/erpnext/erpnext/education/utils.py +19,This {0} conflicts with {1} for {2} {3},Questo {0} conflitti con {1} per {2} {3}
DocType: Student Attendance Tool,Students HTML,Gli studenti HTML
DocType: POS Profile,Apply Discount,applicare Sconto
DocType: GST HSN Code,GST HSN Code,Codice GST HSN
DocType: Employee External Work History,Total Experience,Esperienza totale
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +70,Open Projects,progetti aperti
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +286,Packing Slip(s) cancelled,Bolla di accompagnamento ( s ) annullato
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +31,Cash Flow from Investing,Cash Flow da investimenti
DocType: Program Course,Program Course,programma del Corso
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +99,Freight and Forwarding Charges,Freight Forwarding e spese
DocType: Homepage,Company Tagline for website homepage,Società Sottotitolo per home page del sito
DocType: Item Group,Item Group Name,Nome Gruppo Articoli
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +27,Taken,Preso
DocType: Student,Date of Leaving,Data di partenza
DocType: Pricing Rule,For Price List,Per Listino Prezzi
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +27,Executive Search,executive Search
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +55,Setting defaults,Impostazione delle impostazioni predefinite
apps/erpnext/erpnext/utilities/activation.py +63,Create Leads,Creare un Lead
DocType: Maintenance Schedule,Schedules,Orari
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +451,POS Profile is required to use Point-of-Sale,Il profilo POS è richiesto per utilizzare Point-of-Sale
DocType: Purchase Invoice Item,Net Amount,Importo Netto
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +138,{0} {1} has not been submitted so the action cannot be completed,{0} {1} non è stato inviato affinché l&#39;azione non possa essere completata
DocType: Purchase Order Item Supplied,BOM Detail No,Dettaglio BOM N.
DocType: Landed Cost Voucher,Additional Charges,Spese aggiuntive
DocType: Purchase Invoice,Additional Discount Amount (Company Currency),Importo Sconto Aggiuntivo (valuta Azienda)
DocType: Supplier Scorecard,Supplier Scorecard,Scorecard dei fornitori
DocType: Plant Analysis,Result Datetime,Risultato Data / ora
apps/erpnext/erpnext/accounts/doctype/account/account.js +21,Please create new account from Chart of Accounts.,Si prega di creare un nuovo account dal Piano dei conti .
,Support Hour Distribution,Distribuzione dell&#39;orario di assistenza
DocType: Maintenance Visit,Maintenance Visit,Visita di manutenzione
DocType: Student,Leaving Certificate Number,Lasciando Numero del certificato
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +63,"Appointment cancelled, Please review and cancel the invoice {0}","Appuntamento annullato, esamina e annulla la fattura {0}"
DocType: Sales Invoice Item,Available Batch Qty at Warehouse,Disponibile Quantità Batch in magazzino
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Update Print Format,Aggiornamento Formato di Stampa
DocType: Landed Cost Voucher,Landed Cost Help,Landed Cost Aiuto
DocType: Purchase Invoice,Select Shipping Address,Selezionare l'indirizzo di spedizione
apps/erpnext/erpnext/config/non_profit.py +28,Memebership Details,Dettagli di estensione
DocType: Leave Block List,Block Holidays on important days.,Vacanze di blocco nei giorni importanti.
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +71,Accounts Receivable Summary,Contabilità Sommario Crediti
DocType: Employee Loan,Monthly Repayment Amount,Ammontare Rimborso Mensile
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +9,Opening Invoices,Apertura fatture
apps/erpnext/erpnext/hr/doctype/employee/employee.py +195,Please set User ID field in an Employee record to set Employee Role,Impostare campo ID utente in un record Employee impostare Ruolo Employee
DocType: UOM,UOM Name,Nome Unità di Misura
DocType: GST HSN Code,HSN Code,Codice HSN
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +43,Contribution Amount,Contributo Importo
DocType: Purchase Invoice,Shipping Address,Indirizzo di spedizione
DocType: Stock Reconciliation,This tool helps you to update or fix the quantity and valuation of stock in the system. It is typically used to synchronise the system values and what actually exists in your warehouses.,Questo strumento consente di aggiornare o correggere la quantità e la valutazione delle azioni nel sistema. Viene tipicamente utilizzato per sincronizzare i valori di sistema e ciò che esiste realmente in vostri magazzini.
DocType: Delivery Note,In Words will be visible once you save the Delivery Note.,In parole saranno visibili una volta che si salva il DDT.
DocType: Expense Claim,EXP,EXP
DocType: Water Analysis,Container,Contenitore
apps/erpnext/erpnext/education/utils.py +50,Student {0} - {1} appears Multiple times in row {2} & {3},Studente {0} - {1} compare più volte nella riga {2} e {3}
DocType: Healthcare Settings,Manage Sample Collection,Gestione del campione di raccolta
DocType: Program Enrollment Tool,Program Enrollments,iscrizioni Programma
DocType: Patient,Tobacco Past Use,Uso passato del tabacco
DocType: Sales Invoice Item,Brand Name,Nome Marchio
DocType: Purchase Receipt,Transporter Details,Transporter Dettagli
apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +65,User {0} is already assigned to Physician {1},L&#39;utente {0} è già assegnato a Physician {1}
apps/erpnext/erpnext/accounts/page/pos/pos.js +2657,Default warehouse is required for selected item,Deposito di default è richiesto per gli elementi selezionati
apps/erpnext/erpnext/utilities/user_progress.py +143,Box,Scatola
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1036,Possible Supplier,Fornitore Possibile
DocType: Budget,Monthly Distribution,Distribuzione Mensile
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +68,Receiver List is empty. Please create Receiver List,Lista Receiver è vuoto . Si prega di creare List Ricevitore
apps/erpnext/erpnext/public/js/setup_wizard.js +31,Healthcare (beta),Sanità (beta)
DocType: Production Plan Sales Order,Production Plan Sales Order,Produzione Piano di ordini di vendita
DocType: Sales Partner,Sales Partner Target,Vendite Partner di destinazione
DocType: Loan Type,Maximum Loan Amount,Importo massimo del prestito
DocType: Pricing Rule,Pricing Rule,Regola Prezzi
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +58,Duplicate roll number for student {0},Duplica il numero di rotolo per lo studente {0}
DocType: Budget,Action if Annual Budget Exceeded,Azione da effettuarsi se si eccede il Budget Annuale
apps/erpnext/erpnext/config/learn.py +197,Material Request to Purchase Order,Richiesta materiale per ordine d&#39;acquisto
DocType: Shopping Cart Settings,Payment Success URL,Pagamento Successo URL
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +80,Row # {0}: Returned Item {1} does not exists in {2} {3},Row # {0}: restituito Voce {1} non esiste in {2} {3}
DocType: Purchase Receipt,PREC-,PREC-
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +16,Bank Accounts,Conti bancari
,Bank Reconciliation Statement,Prospetto di Riconciliazione Banca
DocType: Consultation,Medical Coding,Codifica medica
DocType: Healthcare Settings,Reminder Message,Messaggio di promemoria
,Lead Name,Nome Lead
,POS,POS
DocType: C-Form,III,III
apps/erpnext/erpnext/config/stock.py +310,Opening Stock Balance,Apertura Saldo delle Scorte
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +58,{0} must appear only once,{0} deve apparire una sola volta
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +59,Leaves Allocated Successfully for {0},Lascia allocazione con successo per {0}
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +42,No Items to pack,Non ci sono elementi per il confezionamento
DocType: Shipping Rule Condition,From Value,Da Valore
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +581,Manufacturing Quantity is mandatory,La quantità da produrre è obbligatoria
DocType: Employee Loan,Repayment Method,Metodo di rimborso
DocType: Products Settings,"If checked, the Home page will be the default Item Group for the website","Se selezionato, la pagina iniziale sarà il gruppo di default dell&#39;oggetto per il sito web"
DocType: Quality Inspection Reading,Reading 4,Lettura 4
apps/erpnext/erpnext/config/hr.py +132,Claims for company expense.,Reclami per spese dell'azienda.
apps/erpnext/erpnext/utilities/activation.py +118,"Students are at the heart of the system, add all your students","Gli studenti sono al cuore del sistema, aggiungere tutti gli studenti"
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +81,Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Row # {0}: Data di Liquidazione {1} non può essere prima Assegno Data {2}
DocType: Asset Maintenance Task,Certificate Required,Certificato richiesto
DocType: Company,Default Holiday List,Lista vacanze predefinita
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +190,Row {0}: From Time and To Time of {1} is overlapping with {2},Riga {0}: From Time To Time e di {1} si sovrappone {2}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +145,Stock Liabilities,Passività in Giacenza
DocType: Purchase Invoice,Supplier Warehouse,Magazzino Fornitore
DocType: Opportunity,Contact Mobile No,Cellulare Contatto
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +382,Select Company,Seleziona Azienda
,Material Requests for which Supplier Quotations are not created,Richieste di materiale per le quali non sono state create Quotazioni dal Fornitore
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +34,User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.,L&#39;utente {0} non ha alcun profilo POS predefinito. Controlla predefinito alla riga {1} per questo utente.
DocType: Student Group,Set 0 for no limit,Impostare 0 per nessun limite
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.,Le giornate per cui si stanno segnando le ferie sono già di vacanze. Non è necessario chiedere un permesso.
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +64,Row {idx}: {field} is required to create the Opening {invoice_type} Invoices,Riga {idx}: {field} è richiesto per creare le fatture di apertura {fattoice_type}
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +20,Resend Payment Email,Invia di nuovo pagamento Email
apps/erpnext/erpnext/templates/pages/projects.html +27,New task,Nuova attività
DocType: Consultation,Appointment,Appuntamento
apps/erpnext/erpnext/utilities/activation.py +74,Make Quotation,Crea Preventivo
apps/erpnext/erpnext/config/selling.py +216,Other Reports,Altri Reports
apps/erpnext/erpnext/public/js/setup_wizard.js +39,Please select at least one domain.,Si prega di selezionare almeno un dominio.
DocType: Dependent Task,Dependent Task,Attività dipendente
apps/erpnext/erpnext/stock/doctype/item/item.py +430,Conversion factor for default Unit of Measure must be 1 in row {0},Fattore di conversione per unità di misura predefinita deve essere 1 in riga {0}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +208,Leave of type {0} cannot be longer than {1},Lascia di tipo {0} non può essere superiore a {1}
DocType: Manufacturing Settings,Try planning operations for X days in advance.,Provare le operazioni per X giorni in programma in anticipo.
DocType: HR Settings,Stop Birthday Reminders,Arresto Compleanno Promemoria
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +235,Please set Default Payroll Payable Account in Company {0},Si prega di impostare di default Payroll conto da pagare in azienda {0}
DocType: SMS Center,Receiver List,Lista Ricevitore
apps/erpnext/erpnext/accounts/page/pos/pos.js +1083,Search Item,Cerca Articolo
DocType: Payment Schedule,Payment Amount,Pagamento Importo
DocType: Patient Appointment,Referring Physician,Medico di riferimento
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +46,Consumed Amount,Quantità consumata
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +98,Net Change in Cash,Variazione netta delle disponibilità
DocType: Assessment Plan,Grading Scale,Scala di classificazione
apps/erpnext/erpnext/stock/doctype/item/item.py +425,Unit of Measure {0} has been entered more than once in Conversion Factor Table,Unità di misura {0} è stata inserita più volte nella tabella di conversione
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +616,Already completed,Già completato
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +33,Stock In Hand,Stock in mano
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +64,Import Successful!,Importazione Corretta!
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +29,Payment Request already exists {0},Richiesta di Pagamento già esistente {0}
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Issued Items,Costo di elementi Emesso
DocType: Physician,Hospital,Ospedale
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +384,Quantity must not be more than {0},Quantità non deve essere superiore a {0}
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +117,Previous Financial Year is not closed,Il Precedente Esercizio Finanziario non è chiuso
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +46,Age (Days),Età (Giorni)
DocType: Quotation Item,Quotation Item,Articolo del Preventivo
DocType: Customer,Customer POS Id,ID del cliente POS
DocType: Account,Account Name,Nome account
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +40,From Date cannot be greater than To Date,Dalla data non può essere maggiore di A Data
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +198,Serial No {0} quantity {1} cannot be a fraction,Serial No {0} {1} quantità non può essere una frazione
apps/erpnext/erpnext/config/buying.py +43,Supplier Type master.,Fornitore Tipo master.
DocType: Purchase Order Item,Supplier Part Number,Numero di articolo del fornitore
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +108,Conversion rate cannot be 0 or 1,Il tasso di conversione non può essere 0 o 1
DocType: Subscription,Reference Document,Documento di riferimento
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +209,{0} {1} is cancelled or stopped,{0} {1} viene cancellato o fermato
DocType: Accounts Settings,Credit Controller,Controllare Credito
DocType: Grant Application,Applicant Type,Tipo di candidato
DocType: Delivery Note,Vehicle Dispatch Date,Data Spedizione Veicolo
DocType: Healthcare Settings,Default Medical Code Standard,Standard di codice medico di default
DocType: Purchase Invoice Item,HSN/SAC,HSN / SAC
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +237,Purchase Receipt {0} is not submitted,La Ricevuta di Acquisto {0} non è stata presentata
DocType: Company,Default Payable Account,Conto da pagare Predefinito
apps/erpnext/erpnext/config/website.py +17,"Settings for online shopping cart such as shipping rules, price list etc.","Impostazioni carrello della spesa, come Tipi di Spedizione, Listino Prezzi ecc"
apps/erpnext/erpnext/controllers/website_list_for_contact.py +113,{0}% Billed,{0}% Fatturato
apps/erpnext/erpnext/hub_node/page/hub/hub.js +179,Sort by Price ...,Ordina per Prezzo ...
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +18,Reserved Qty,Riservato Quantità
DocType: Party Account,Party Account,Account del Partner
apps/erpnext/erpnext/config/setup.py +122,Human Resources,Risorse Umane
DocType: Lead,Upper Income,Reddito superiore
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +17,Reject,Rifiutare
DocType: Journal Entry Account,Debit in Company Currency,Debito in Società Valuta
DocType: BOM Item,BOM Item,BOM Articolo
DocType: Appraisal,For Employee,Per Dipendente
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.js +49,Make Disbursement Entry,Crea una scrittura per l'esborso
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +136,Row {0}: Advance against Supplier must be debit,Riga {0}: L'anticipo verso Fornitore deve essere un debito
DocType: Company,Default Values,Valori Predefiniti
DocType: Membership,INR,INR
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +60,{frequency} Digest,{Frequency} Digest
DocType: Expense Claim,Total Amount Reimbursed,Dell&#39;importo totale rimborsato
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py +5,This is based on logs against this Vehicle. See timeline below for details,Questo si basa su tronchi contro questo veicolo. Vedere cronologia sotto per i dettagli
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +90,Against Supplier Invoice {0} dated {1},Al ricevimento della Fattura Fornitore {0} datata {1}
DocType: Customer,Default Price List,Listino Prezzi Predefinito
apps/erpnext/erpnext/assets/doctype/asset/asset.py +265,Asset Movement record {0} created,record di Asset Movimento {0} creato
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,Non è possibile cancellare l&#39;anno fiscale {0}. Anno fiscale {0} è impostato in modo predefinito in Impostazioni globali
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py +20,A customer with the same name already exists,Esiste già un cliente con lo stesso nome
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +183,This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?,Questo invierà Salary Slips e creerà la registrazione ufficiale. Vuoi procedere?
DocType: Purchase Invoice,Total Net Weight,Peso netto totale
DocType: Journal Entry,Entry Type,Tipo voce
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py +44,No assessment plan linked with this assessment group,Nessun piano di valutazione collegato a questo gruppo di valutazione
,Customer Credit Balance,Balance Credit clienti
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +23,Net Change in Accounts Payable,Variazione Netta in Contabilità Fornitori
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +42,Customer required for 'Customerwise Discount',Cliente richiesto per ' Customerwise Discount '
apps/erpnext/erpnext/config/accounts.py +140,Update bank payment dates with journals.,Aggiorna le date di pagamento bancario con il Giornale.
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +21,Pricing,Prezzi
DocType: Quotation,Term Details,Dettagli Termini
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +30,Cannot enroll more than {0} students for this student group.,Non possono iscriversi più di {0} studenti per questo gruppo di studenti.
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17,Lead Count,Conto di piombo
apps/erpnext/erpnext/assets/doctype/asset_category/asset_category.py +15,{0} must be greater than 0,{0} deve essere maggiore di 0
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +17,Stock Available,Disponibile a magazzino
DocType: Manufacturing Settings,Capacity Planning For (Days),Capacity Planning per (giorni)
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +10,Procurement,Approvvigionamento
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +64,None of the items have any change in quantity or value.,Nessuno articolo ha modifiche in termini di quantità o di valore.
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +16,Mandatory field - Program,Campo obbligatorio - Programma
DocType: Special Test Template,Result Component,Componente risultato
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js +46,Warranty Claim,Richiesta di Garanzia
,Lead Details,Dettagli Lead
DocType: Volunteer,Availability and Skills,Disponibilità e competenze
DocType: Salary Slip,Loan repayment,Rimborso del prestito
DocType: Purchase Invoice,End date of current invoice's period,Data di fine del periodo di fatturazione corrente
DocType: Pricing Rule,Applicable For,applicabile per
DocType: Lab Test,Technician Name,Nome tecnico
DocType: Accounts Settings,Unlink Payment on Cancellation of Invoice,Scollegare il pagamento per la cancellazione della fattura
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +16,Current Odometer reading entered should be greater than initial Vehicle Odometer {0},lettura corrente dell&#39;odometro inserito deve essere maggiore di contachilometri iniziale veicolo {0}
DocType: Restaurant Reservation,No Show,Nessuno spettacolo
DocType: Shipping Rule Country,Shipping Rule Country,Tipo di Spedizione per Nazione
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +10,Leave and Attendance,Permessi e Presenze
DocType: Maintenance Visit,Partially Completed,Parzialmente completato
apps/erpnext/erpnext/healthcare/setup.py +257,Moderate Sensitivity,Sensibilità moderata
DocType: Leave Type,Include holidays within leaves as leaves,Includere le vacanze entro i fogli come foglie
DocType: Sales Invoice,Packed Items,Articoli imballati
apps/erpnext/erpnext/config/support.py +27,Warranty Claim against Serial No.,Richiesta Garanzia per N. Serie
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +71,'Total',&#39;Totale&#39;
DocType: Shopping Cart Settings,Enable Shopping Cart,Abilita Carrello
DocType: Employee,Permanent Address,Indirizzo permanente
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +258,"Advance paid against {0} {1} cannot be greater \
						than Grand Total {2}",Anticipo versato contro {0} {1} non può essere maggiore \ di Gran Totale {2}
DocType: Patient,Medication,medicazione
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +147,Please select item code,Si prega di selezionare il codice articolo
DocType: Student Sibling,Studying in Same Institute,Studiare in stesso Istituto
DocType: Territory,Territory Manager,Territory Manager
DocType: Packed Item,To Warehouse (Optional),Al Magazzino (opzionale)
DocType: Payment Entry,Paid Amount (Company Currency),Importo pagato (valuta della società)
DocType: Purchase Invoice,Additional Discount,Sconto aggiuntivo
DocType: Selling Settings,Selling Settings,Impostazioni Vendite
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +83,Confirm Action,Conferma azione
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +39,Online Auctions,Aste online
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +98,Please specify either Quantity or Valuation Rate or both,Si prega di specificare Quantitativo o Tasso di valutazione o di entrambi
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_dashboard.py +18,Fulfillment,Compimento
apps/erpnext/erpnext/templates/generators/item.html +67,View in Cart,Vedi Carrello
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +103,Marketing Expenses,Spese di Marketing
,Item Shortage Report,Report Carenza Articolo
apps/erpnext/erpnext/stock/doctype/item/item.js +275,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Il peso è menzionato, \n prega di citare ""Peso UOM"" troppo"
DocType: Stock Entry Detail,Material Request used to make this Stock Entry,Richiesta di materiale usata per l'entrata giacenza
apps/erpnext/erpnext/assets/doctype/asset/asset.py +68,Next Depreciation Date is mandatory for new asset,Successivo ammortamento Data è obbligatoria per i nuovi beni
DocType: Student Group Creation Tool,Separate course based Group for every Batch,Separare il gruppo di corso per ogni batch
apps/erpnext/erpnext/config/support.py +32,Single unit of an Item.,Unità singola di un articolo.
DocType: Fee Category,Fee Category,Fee Categoria
DocType: Agriculture Task,Next Business Day,Il prossimo giorno lavorativo
DocType: Customer,Primary Contact Detail,Dettaglio contatto principale
DocType: Drug Prescription,Dosage by time interval,Dosaggio per intervallo di tempo
,Student Fee Collection,Student Fee Collection
apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +23,Appointment Duration (mins),Durata dell'appuntamento (minuti)
DocType: Accounts Settings,Make Accounting Entry For Every Stock Movement,Crea una voce contabile per ogni movimento di scorta
DocType: Leave Allocation,Total Leaves Allocated,Totale Foglie allocati
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +163,Warehouse required at Row No {0},Magazzino richiesto al Fila No {0}
apps/erpnext/erpnext/public/js/setup_wizard.js +142,Please enter valid Financial Year Start and End Dates,Si prega di inserire valido Esercizio inizio e di fine
DocType: Employee,Date Of Retirement,Data di pensionamento
DocType: Upload Attendance,Get Template,Ottieni Modulo
DocType: Material Request,Transferred,trasferito
DocType: Vehicle,Doors,Porte
apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +117,ERPNext Setup Complete!,Installazione ERPNext completa!
DocType: Healthcare Settings,Collect Fee for Patient Registration,Raccogliere la tariffa per la registrazione del paziente
apps/erpnext/erpnext/stock/doctype/item/item.py +650,Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item,Impossibile modificare gli attributi dopo la transazione di magazzino. Crea un nuovo oggetto e trasferisci le scorte al nuovo oggetto
DocType: Course Assessment Criteria,Weightage,Pesa
DocType: Purchase Invoice,Tax Breakup,Pausa fiscale
DocType: Packing Slip,PS-,PS-
DocType: Member,Non Profit Member,Membro non profit
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +67,{0} {1}: Cost Center is required for 'Profit and Loss' account {2}. Please set up a default Cost Center for the Company.,{0} {1}: E' richiesto il Centro di Costo per il Conto Economico {2}. Configura un Centro di Costo di default per l'azienda
DocType: Payment Schedule,Payment Term,Termine di pagamento
apps/erpnext/erpnext/selling/doctype/customer/customer.py +146,A Customer Group exists with same name please change the Customer name or rename the Customer Group,"Esiste un Gruppo Clienti con lo stesso nome, per favore cambiare il nome del Cliente o rinominare il Gruppo Clienti"
DocType: Land Unit,Area,La zona
apps/erpnext/erpnext/public/js/templates/contact_list.html +37,New Contact,Nuovo contatto
DocType: Territory,Parent Territory,Territorio genitore
DocType: Sales Invoice,Place of Supply,Luogo di fornitura
DocType: Quality Inspection Reading,Reading 2,Lettura 2
DocType: Stock Entry,Material Receipt,Materiale ricevuto
DocType: Homepage,Products,prodotti
DocType: Announcement,Instructor,Istruttore
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +61,Select Item (optional),Seleziona voce (opzionale)
DocType: Fee Schedule Student Group,Fee Schedule Student Group,Schema di apprendimento gruppo studenti
DocType: Student,AB+,AB+
DocType: Item,"If this item has variants, then it cannot be selected in sales orders etc.","Se questa voce ha varianti, allora non può essere selezionata in ordini di vendita, ecc"
DocType: Lead,Next Contact By,Contatto Successivo Con
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +314,Quantity required for Item {0} in row {1},Quantità necessaria per la voce {0} in riga {1}
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +46,Warehouse {0} can not be deleted as quantity exists for Item {1},Deposito {0} non può essere cancellato in quanto esiste la quantità per l' articolo {1}
DocType: Quotation,Order Type,Tipo di ordine
,Item-wise Sales Register,Vendite articolo-saggio Registrati
DocType: Asset,Gross Purchase Amount,Importo Acquisto Gross
apps/erpnext/erpnext/utilities/user_progress.py +36,Opening Balances,Saldi di bilancio
DocType: Asset,Depreciation Method,Metodo di ammortamento
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +64,Offline,Disconnesso
DocType: Purchase Taxes and Charges,Is this Tax included in Basic Rate?,È questa tassa inclusi nel prezzo base?
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Target,Obiettivo totale
DocType: Soil Texture,Sand Composition (%),Composizione di sabbia (%)
DocType: Job Applicant,Applicant for a Job,Richiedente per un lavoro
DocType: Production Plan Material Request,Production Plan Material Request,Piano di produzione Materiale Richiesta
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +231,No Production Orders created,Ordini di Produzione non creati
DocType: Stock Reconciliation,Reconciliation JSON,Riconciliazione JSON
apps/erpnext/erpnext/accounts/report/financial_statements.html +3,Too many columns. Export the report and print it using a spreadsheet application.,Troppe colonne. Esportare il report e stamparlo utilizzando un foglio di calcolo.
DocType: Purchase Invoice Item,Batch No,Lotto N.
DocType: Selling Settings,Allow multiple Sales Orders against a Customer's Purchase Order,Consentire più ordini di vendita da un singolo ordine di un cliente
DocType: Student Group Instructor,Student Group Instructor,Istruttore del gruppo di studenti
DocType: Grant Application,Assessment  Mark (Out of 10),Segno di valutazione (su 10)
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +61,Guardian2 Mobile No,Guardian2 mobile No
apps/erpnext/erpnext/setup/doctype/company/company.py +194,Main,principale
apps/erpnext/erpnext/stock/doctype/item/item.js +72,Variant,Variante
DocType: Naming Series,Set prefix for numbering series on your transactions,Impostare prefisso per numerazione serie sulle transazioni
DocType: Employee Attendance Tool,Employees HTML,Dipendenti HTML
apps/erpnext/erpnext/stock/doctype/item/item.py +444,Default BOM ({0}) must be active for this item or its template,BOM default ({0}) deve essere attivo per questo articolo o il suo modello
DocType: Employee,Leave Encashed?,Lascia non incassati?
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +32,Opportunity From field is mandatory,Opportunity Dal campo è obbligatorio
DocType: Email Digest,Annual Expenses,Spese annuali
DocType: Item,Variants,Varianti
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1137,Make Purchase Order,Crea ordine d'acquisto
DocType: SMS Center,Send To,Invia a
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +152,There is not enough leave balance for Leave Type {0},Non c'è equilibrio congedo sufficiente per Leave tipo {0}
DocType: Payment Reconciliation Payment,Allocated amount,Importo Assegnato
DocType: Sales Team,Contribution to Net Total,Contributo sul totale netto
DocType: Sales Invoice Item,Customer's Item Code,Codice elemento Cliente
DocType: Stock Reconciliation,Stock Reconciliation,Riconciliazione Giacenza
DocType: Territory,Territory Name,Territorio Nome
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +197,Work-in-Progress Warehouse is required before Submit,Specificare il magazzino Work- in- Progress prima della Conferma
apps/erpnext/erpnext/config/hr.py +40,Applicant for a Job.,Richiedente per Lavoro.
DocType: Purchase Order Item,Warehouse and Reference,Magazzino e Riferimenti
DocType: Supplier,Statutory info and other general information about your Supplier,Informazioni legali e altre Informazioni generali sul tuo Fornitore
DocType: Item,Serial Nos and Batches,Numero e lotti seriali
apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42,Student Group Strength,Forza del gruppo studente
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +250,Against Journal Entry {0} does not have any unmatched {1} entry,Contro diario {0} non ha alcun ineguagliata {1} entry
apps/erpnext/erpnext/config/hr.py +142,Appraisals,Perizie
apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py +8,Training Events,Eventi formativi
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +205,Duplicate Serial No entered for Item {0},Inserito Numero di Serie duplicato per l'articolo {0}
DocType: Shipping Rule Condition,A condition for a Shipping Rule,Una condizione per un Tipo di Spedizione
apps/erpnext/erpnext/hr/doctype/employee/employee.py +167,Please enter ,Prego entra
apps/erpnext/erpnext/controllers/accounts_controller.py +467,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Buying Settings","Non può overbill per la voce {0} in riga {1} più di {2}. Per consentire over-billing, impostare in Impostazioni acquisto"
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +43,Maintenance Log,Registro di manutenzione
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +234,Please set filter based on Item or Warehouse,Si prega di impostare il filtro in base al punto o in un magazzino
DocType: Packing Slip,The net weight of this package. (calculated automatically as sum of net weight of items),Il peso netto di questo package (calcolato automaticamente come somma dei pesi netti).
DocType: Sales Order,To Deliver and Bill,Da Consegnare e Fatturare
DocType: Student Group,Instructors,Istruttori
DocType: GL Entry,Credit Amount in Account Currency,Importo del credito Account Valuta
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +588,BOM {0} must be submitted,BOM {0} deve essere confermata
DocType: Authorization Control,Authorization Control,Controllo Autorizzazioni
apps/erpnext/erpnext/controllers/buying_controller.py +309,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Fila # {0}: Rifiutato Warehouse è obbligatoria per la voce respinto {1}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +808,Payment,Pagamento
apps/erpnext/erpnext/controllers/stock_controller.py +92,"Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.","Il magazzino {0} non è collegato a nessun account, si prega di citare l&#39;account nel record magazzino o impostare l&#39;account di inventario predefinito nella società {1}."
apps/erpnext/erpnext/utilities/activation.py +81,Manage your orders,Gestisci i tuoi ordini
DocType: Production Order Operation,Actual Time and Cost,Tempo reale e costi
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},Richiesta materiale di massimo {0} può essere fatto per la voce {1} contro ordine di vendita {2}
DocType: Crop,Crop Spacing,Spaziatura
DocType: Course,Course Abbreviation,Abbreviazione corso
DocType: Student Leave Application,Student Leave Application,Student Leave Application
DocType: Item,Will also apply for variants,Si applica anche per le varianti
apps/erpnext/erpnext/assets/doctype/asset/asset.py +160,"Asset cannot be cancelled, as it is already {0}","Asset non può essere annullato, in quanto è già {0}"
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +29,Employee {0} on Half day on {1},Employee {0} sulla mezza giornata su {1}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +42,Total working hours should not be greater than max working hours {0},l&#39;orario di lavoro totale non deve essere maggiore di ore di lavoro max {0}
apps/erpnext/erpnext/templates/pages/task_info.html +90,On,On
apps/erpnext/erpnext/config/selling.py +62,Bundle items at time of sale.,Articoli Combinati e tempi di vendita.
DocType: Quotation Item,Actual Qty,Q.tà reale
DocType: Sales Invoice Item,References,Riferimenti
DocType: Quality Inspection Reading,Reading 10,Lettura 10
DocType: Hub Category,Hub Node,Nodo hub
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +78,You have entered duplicate items. Please rectify and try again.,Hai inserito degli elementi duplicati . Si prega di correggere e riprovare .
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +129,Associate,Associate
DocType: Asset Movement,Asset Movement,Movimento Asset
apps/erpnext/erpnext/accounts/page/pos/pos.js +2180,New Cart,Nuovo carrello
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +44,Item {0} is not a serialized Item,L'articolo {0} non è un elemento serializzato
DocType: SMS Center,Create Receiver List,Crea Elenco Ricezione
DocType: Vehicle,Wheels,Ruote
DocType: Packing Slip,To Package No.,A Pacchetto no
DocType: Patient Relation,Family,Famiglia
DocType: Production Planning Tool,Material Requests,Richieste di materiale
DocType: Warranty Claim,Issue Date,Data di Emissione
DocType: Activity Cost,Activity Cost,Costo attività
DocType: Sales Invoice Timesheet,Timesheet Detail,Dettagli scheda attività
DocType: Purchase Receipt Item Supplied,Consumed Qty,Q.tà Consumata
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +52,Telecommunications,Telecomunicazioni
apps/erpnext/erpnext/accounts/party.py +266,Billing currency must be equal to either default company's currency or party account currency,La valuta di fatturazione deve essere uguale alla valuta della società predefinita o alla valuta dell&#39;account del partito
DocType: Packing Slip,Indicates that the package is a part of this delivery (Only Draft),Indica che il pacchetto è una parte di questa consegna (solo Bozza)
DocType: Soil Texture,Loam,terra grassa
apps/erpnext/erpnext/controllers/accounts_controller.py +680,Row {0}: Due Date cannot be before posting date,Riga {0}: la data di scadenza non può essere precedente alla data di pubblicazione
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +36,Make Payment Entry,Effettua Ricevuta di Pagamento
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +129,Quantity for Item {0} must be less than {1},Quantità per la voce {0} deve essere inferiore a {1}
,Sales Invoice Trends,Andamento Fatture di vendita
DocType: Leave Application,Apply / Approve Leaves,Applicare / Approva Leaves
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3,For,Per
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +167,Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',Può riferirsi fila solo se il tipo di carica è 'On Fila Indietro Importo ' o ' Indietro totale riga '
DocType: Sales Order Item,Delivery Warehouse,Deposito di consegna
apps/erpnext/erpnext/config/accounts.py +241,Tree of financial Cost Centers.,Albero dei centri di costo finanziario.
DocType: Serial No,Delivery Document No,Documento Consegna N.
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +191,Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Si prega di impostare &#39;Conto / perdita di guadagno su Asset Disposal&#39; in compagnia {0}
DocType: Landed Cost Voucher,Get Items From Purchase Receipts,Ottenere elementi dal Acquisto Receipts
DocType: Serial No,Creation Date,Data di Creazione
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +33,Item {0} appears multiple times in Price List {1},L'articolo {0} compare più volte nel Listino {1}
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +40,"Selling must be checked, if Applicable For is selected as {0}","Vendita deve essere controllato, se applicabile per è selezionato come {0}"
DocType: Production Plan Material Request,Material Request Date,Data Richiesta Materiale
DocType: Purchase Order Item,Supplier Quotation Item,Articolo Fornitore del Preventivo
DocType: Manufacturing Settings,Disables creation of time logs against Production Orders. Operations shall not be tracked against Production Order,Disabilita la creazione di registri di tempo contro gli ordini di produzione. Le operazioni non devono essere monitorati contro ordine di produzione
DocType: Student,Student Mobile Number,Student Mobile Number
DocType: Item,Has Variants,Ha varianti
apps/erpnext/erpnext/templates/emails/training_event.html +11,Update Response,Aggiorna risposta
apps/erpnext/erpnext/public/js/utils.js +226,You have already selected items from {0} {1},Hai già selezionato elementi da {0} {1}
DocType: Monthly Distribution,Name of the Monthly Distribution,Nome della distribuzione mensile
apps/erpnext/erpnext/stock/doctype/batch/batch.py +26,Batch ID is mandatory,L&#39;ID batch è obbligatorio
DocType: Sales Person,Parent Sales Person,Parent Sales Person
apps/erpnext/erpnext/hub_node/page/hub/hub.js +180,High to Low,Da alto a basso
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +24,Select the program first,Selezionare prima il programma
DocType: Patient Appointment,Patient Age,Età del paziente
apps/erpnext/erpnext/config/learn.py +263,Managing Projects,Gestione progetti
DocType: Supplier,Supplier of Goods or Services.,Fornitore di beni o servizi.
DocType: Budget,Fiscal Year,Anno Fiscale
DocType: Asset Maintenance Log,Planned,previsto
DocType: Healthcare Settings,Default receivable accounts to be used if not set in Patient to book Consultation charges.,"Se non è impostato nel paziente per prenotare le spese di consultazione, è necessario utilizzare i conti di crediti di default."
DocType: Vehicle Log,Fuel Price,Prezzo Carburante
DocType: Budget,Budget,Budget
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +51,Set Open,Imposta aperta
apps/erpnext/erpnext/stock/doctype/item/item.py +247,Fixed Asset Item must be a non-stock item.,Un Bene Strumentale  deve essere un Bene Non di Magazzino
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +50,"Budget cannot be assigned against {0}, as it's not an Income or Expense account","Bilancio non può essere assegnato contro {0}, in quanto non è un conto entrate o uscite"
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +51,Achieved,Raggiunto
DocType: Student Admission,Application Form Route,Modulo di domanda di percorso
apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +66,Territory / Customer,Territorio / Cliente
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +44,Leave Type {0} cannot be allocated since it is leave without pay,Lascia tipo {0} non può essere assegnato in quanto si lascia senza paga
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +166,Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},Riga {0}: l'importo assegnato {1} deve essere inferiore o uguale alla fatturazione dell'importo dovuto {2}
DocType: Sales Invoice,In Words will be visible once you save the Sales Invoice.,In parole saranno visibili una volta che si salva la fattura di vendita.
DocType: Lead,Follow Up,Seguito
DocType: Item,Is Sales Item,È Voce vendite
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +21,Item Group Tree,Struttura Gruppo Articoli
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +69,Item {0} is not setup for Serial Nos. Check Item master,L'articolo {0} non ha Numeri di Serie. Verifica l'Articolo Principale
DocType: Maintenance Visit,Maintenance Time,Tempo di Manutenzione
,Amount to Deliver,Importo da consegnare
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +324,Same item has been entered multiple times. {0},Lo stesso oggetto è stato inserito più volte. {0}
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +30,The Term Start Date cannot be earlier than the Year Start Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,Il Data Terminologia di inizio non può essere anteriore alla data di inizio anno dell&#39;anno accademico a cui il termine è legata (Anno Accademico {}). Si prega di correggere le date e riprovare.
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +192,There were errors.,Ci sono stati degli errori.
DocType: Guardian,Guardian Interests,Custodi Interessi
DocType: Naming Series,Current Value,Valore Corrente
apps/erpnext/erpnext/controllers/accounts_controller.py +263,Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,esistono più esercizi per la data {0}. Si prega di impostare società l&#39;anno fiscale
DocType: Education Settings,Instructor Records to be created by,Istruttore Record da creare da
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +229,{0} created,{0} creato
DocType: Delivery Note Item,Against Sales Order,Contro Sales Order
,Serial No Status,Serial No Stato
DocType: Payment Entry Reference,Outstanding,In sospeso
DocType: Supplier,Warn POs,Avvisare i PO
,Daily Timesheet Summary,Riepilogo timesheet giornaliero
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +137,"Row {0}: To set {1} periodicity, difference between from and to date \
						must be greater than or equal to {2}","Riga {0}: Per impostare {1} periodicità, differenza tra da e per la data \
 deve essere maggiore o uguale a {2}"
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +6,This is based on stock movement. See {0} for details,Questo si basa sui movimenti di magazzino. Vedere {0} per i dettagli
DocType: Pricing Rule,Selling,Vendite
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +379,Amount {0} {1} deducted against {2},Importo {0} {1} dedotto contro {2}
DocType: Employee,Salary Information,Informazioni stipendio
DocType: Sales Person,Name and Employee ID,Nome e ID Dipendente
apps/erpnext/erpnext/accounts/party.py +311,Due Date cannot be before Posting Date,La Data di Scadenza non può essere antecedente alla Data di Registrazione
DocType: Website Item Group,Website Item Group,Sito Gruppo Articolo
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +150,Duties and Taxes,Dazi e tasse
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +354,Please enter Reference date,Inserisci Data di riferimento
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} voci di pagamento non possono essere filtrate per {1}
DocType: Item Website Specification,Table for Item that will be shown in Web Site,Tavolo per l'elemento che verrà mostrato sul sito web
DocType: Purchase Order Item Supplied,Supplied Qty,Dotazione Qtà
DocType: Purchase Order Item,Material Request Item,Voce di richiesta materiale
apps/erpnext/erpnext/config/selling.py +75,Tree of Item Groups.,Albero di gruppi di articoli .
DocType: Payroll Entry,Get Employee Details,Ottieni i dettagli dei dipendenti
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +177,Cannot refer row number greater than or equal to current row number for this Charge type,Non può consultare numero di riga maggiore o uguale al numero di riga corrente per questo tipo di carica
DocType: Asset,Sold,Venduto
,Item-wise Purchase History,Articolo-saggio Cronologia acquisti
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +230,Please click on 'Generate Schedule' to fetch Serial No added for Item {0},Si prega di cliccare su ' Generate Schedule ' a prendere Serial No aggiunto per la voce {0}
DocType: Account,Frozen,Congelato
,Open Production Orders,Aprire ordini di produzione
DocType: Sales Invoice Payment,Base Amount (Company Currency),Importo base (in valuta principale)
DocType: Payment Reconciliation Payment,Reference Row,Riferimento Row
DocType: Installation Note,Installation Time,Tempo di installazione
DocType: Sales Invoice,Accounting Details,Dettagli contabile
apps/erpnext/erpnext/setup/doctype/company/company.js +84,Delete all the Transactions for this Company,Eliminare tutte le Operazioni per questa Azienda
DocType: Patient,O Positive,O positivo
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +195,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Production Order # {3}. Please update operation status via Time Logs,Row # {0}: Operazione {1} non è completato per {2} qty di prodotti finiti in ordine di produzione # {3}. Si prega di aggiornare lo stato di funzionamento tramite registri Tempo
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +68,Investments,Investimenti
DocType: Issue,Resolution Details,Dettagli risoluzione
apps/erpnext/erpnext/hr/doctype/leave_type/leave_type.js +3,Allocations,Accantonamenti
DocType: Item Quality Inspection Parameter,Acceptance Criteria,Criterio  di accettazione
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +159,Please enter Material Requests in the above table,Si prega di inserire richieste materiale nella tabella di cui sopra
DocType: Item Attribute,Attribute Name,Nome Attributo
DocType: BOM,Show In Website,Mostra Nel Sito Web
DocType: Shopping Cart Settings,Show Quantity in Website,Mostra Quantità in Sito
DocType: Employee Loan Application,Total Payable Amount,Totale passività
DocType: Task,Expected Time (in hours),Tempo previsto (in ore)
DocType: Item Reorder,Check in (group),Il check-in (gruppo)
DocType: Soil Texture,Silt,Limo
,Qty to Order,Qtà da Ordinare
DocType: Period Closing Voucher,"The account head under Liability or Equity, in which Profit/Loss will be booked","L&#39;account testa sotto responsabilità o di capitale, in cui sarà prenotato Utile / Perdita"
apps/erpnext/erpnext/config/projects.py +31,Gantt chart of all tasks.,Diagramma di Gantt per tutte le attività.
DocType: Opportunity,Mins to First Response,Minuti per First Response
DocType: Pricing Rule,Margin Type,Tipo di Margine
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +15,{0} hours,{0} ore
DocType: Course,Default Grading Scale,Grading scala predefinita
DocType: Appraisal,For Employee Name,Per Nome Dipendente
DocType: Holiday List,Clear Table,Pulisci Tabella
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +106,Available slots,Slot disponibili
DocType: C-Form Invoice Detail,Invoice No,Fattura N
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +350,Make Payment,Effettua un  Pagamento
DocType: Room,Room Name,Nome della stanza
DocType: Prescription Duration,Prescription Duration,Durata della prescrizione
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}","Lasciare non può essere applicata / annullato prima {0}, come equilibrio congedo è già stato inoltrato carry-in futuro record di assegnazione congedo {1}"
DocType: Activity Cost,Costing Rate,Costing Tasso
apps/erpnext/erpnext/config/selling.py +229,Customer Addresses And Contacts,Indirizzi e Contatti Cliente
,Campaign Efficiency,Efficienza della campagna
DocType: Discussion,Discussion,Discussione
DocType: Payment Entry,Transaction ID,ID transazione
DocType: Volunteer,Anytime,in qualsiasi momento
DocType: Patient,Surgical History,Storia chirurgica
DocType: Employee,Resignation Letter Date,Lettera di dimissioni Data
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +39,Pricing Rules are further filtered based on quantity.,Regole dei prezzi sono ulteriormente filtrati in base alla quantità.
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +335,Please set the Date Of Joining for employee {0},Impostare la data di unione per dipendente {0}
DocType: Task,Total Billing Amount (via Time Sheet),Importo totale di fatturazione (tramite Time Sheet)
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +61,Repeat Customer Revenue,Ripetere Revenue clienti
DocType: Soil Texture,Silty Clay Loam,Argilloso Silty Clay
DocType: Chapter,Chapter,Capitolo
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +200,{0} ({1}) must have role 'Expense Approver',{0} ({1}) deve avere il ruolo 'Approvatore Spese'
apps/erpnext/erpnext/utilities/user_progress.py +143,Pair,Coppia
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +959,Select BOM and Qty for Production,Selezionare Distinta Materiali e Quantità per la  Produzione
DocType: Asset,Depreciation Schedule,piano di ammortamento
apps/erpnext/erpnext/config/selling.py +124,Sales Partner Addresses And Contacts,Indirizzi e Contatti del Partner Vendite
DocType: Bank Reconciliation Detail,Against Account,Previsione Conto
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +71,Half Day Date should be between From Date and To Date,La data di mezza giornata deve essere compresa da Data a Data
DocType: Maintenance Schedule Detail,Actual Date,Data effettiva
DocType: Item,Has Batch No,Ha lotto n.
apps/erpnext/erpnext/public/js/utils.js +100,Annual Billing: {0},Fatturazione annuale: {0}
apps/erpnext/erpnext/config/accounts.py +200,Goods and Services Tax (GST India),Tasse sui beni e servizi (GST India)
DocType: Delivery Note,Excise Page Number,Accise Numero Pagina
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +225,"Company, From Date and To Date is mandatory","Società, da Data e fino ad oggi è obbligatoria"
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +33,Get from Consultation,Ottenga dalla consultazione
DocType: Asset,Purchase Date,Data di acquisto
DocType: Volunteer,Volunteer Type,Tipo di volontariato
DocType: Student,Personal Details,Dettagli personali
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +193,Please set 'Asset Depreciation Cost Center' in Company {0},Si prega di impostare &#39;Asset Centro ammortamento dei costi&#39; in compagnia {0}
,Maintenance Schedules,Programmi di manutenzione
DocType: Task,Actual End Date (via Time Sheet),Data di fine effettiva (da Time Sheet)
DocType: Soil Texture,Soil Type,Tipo di terreno
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +374,Amount {0} {1} against {2} {3},Importo {0} {1} contro {2} {3}
,Quotation Trends,Tendenze di preventivo
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +159,Item Group not mentioned in item master for item {0},Gruppo Articoli non menzionato nell'Articolo principale per l'Articolo {0}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +362,Debit To account must be a Receivable account,Debito Per account deve essere un account di Credito
DocType: Shipping Rule,Shipping Amount,Importo spedizione
DocType: Supplier Scorecard Period,Period Score,Punteggio periodo
apps/erpnext/erpnext/utilities/user_progress.py +63,Add Customers,Aggiungi clienti
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Pending Amount,In attesa di Importo
DocType: Lab Test Template,Special,Speciale
DocType: Purchase Order Item Supplied,Conversion Factor,Fattore di Conversione
DocType: Purchase Order,Delivered,Consegnato
,Vehicle Expenses,Spese del veicolo
DocType: Serial No,Invoice Details,Dettagli della fattura
DocType: Grant Application,Show on Website,Mostra sul sito web
apps/erpnext/erpnext/assets/doctype/asset/asset.py +155,Expected value after useful life must be greater than or equal to {0},Valore atteso dopo la vita utile deve essere maggiore o uguale a {0}
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +29,Start on,Inizia
DocType: Hub Category,Hub Category,Categoria Hub
DocType: Purchase Invoice,SEZ,SEZ
DocType: Purchase Receipt,Vehicle Number,Numero di veicoli
DocType: Employee Loan,Loan Amount,Ammontare del prestito
apps/erpnext/erpnext/utilities/user_progress.py +88,Add Letterhead,Aggiungi carta intestata
DocType: Program Enrollment,Self-Driving Vehicle,Autovettura
DocType: Supplier Scorecard Standing,Supplier Scorecard Standing,Scorecard fornitore permanente
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +420,Row {0}: Bill of Materials not found for the Item {1},Riga {0}: Distinta materiali non trovato per la voce {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,Totale foglie assegnati {0} non può essere inferiore a foglie già approvati {1} per il periodo
DocType: Journal Entry,Accounts Receivable,Conti esigibili
,Supplier-Wise Sales Analytics,Estensione statistiche di Vendita Fornitore
DocType: Salary Structure,Select employees for current Salary Structure,Selezionare i dipendenti per i struttura di stipendio
DocType: Sales Invoice,Company Address Name,Nome dell&#39;azienda nome
DocType: Production Order,Use Multi-Level BOM,Utilizzare BOM Multi-Level
DocType: Bank Reconciliation,Include Reconciled Entries,Includi Voci riconciliati
DocType: Course,"Parent Course (Leave blank, if this isn't part of Parent Course)","Corso di genitori (lasciare vuoto, se questo non fa parte del corso dei genitori)"
DocType: Leave Control Panel,Leave blank if considered for all employee types,Lasciare vuoto se considerato per tutti i tipi dipendenti
DocType: Landed Cost Voucher,Distribute Charges Based On,Distribuire oneri corrispondenti
apps/erpnext/erpnext/hooks.py +144,Timesheets,Schede attività
DocType: HR Settings,HR Settings,Impostazioni HR
DocType: Salary Slip,net pay info,Informazioni retribuzione netta
DocType: Lab Test Template,This value is updated in the Default Sales Price List.,Questo valore viene aggiornato nell&#39;elenco dei prezzi di vendita predefinito.
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +122,Expense Claim is pending approval. Only the Expense Approver can update status.,Rimborso spese in attesa di approvazione. Solo il Responsabile Spese può modificarne lo stato.
DocType: Email Digest,New Expenses,nuove spese
DocType: Purchase Invoice,Additional Discount Amount,Importo Sconto Aggiuntivo
DocType: Consultation,Patient Details,Dettagli del paziente
DocType: Patient,B Positive,B Positivo
apps/erpnext/erpnext/controllers/accounts_controller.py +575,"Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.","Row # {0}: Quantità deve essere 1, poiche' si tratta di un Bene Strumentale. Si prega di utilizzare riga separata per quantita' multiple."
DocType: Leave Block List Allow,Leave Block List Allow,Lascia permesso blocco lista
apps/erpnext/erpnext/setup/doctype/company/company.py +288,Abbr can not be blank or space,L'abbr. non può essere vuota o spazio
DocType: Patient Medical Record,Patient Medical Record,Registro medico paziente
apps/erpnext/erpnext/accounts/doctype/account/account.js +68,Group to Non-Group,Gruppo di Non-Group
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +50,Sports,sportivo
DocType: Loan Type,Loan Name,Nome prestito
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Actual,Totale Actual
DocType: Lab Test UOM,Test UOM,Test UOM
DocType: Student Siblings,Student Siblings,Student Siblings
apps/erpnext/erpnext/utilities/user_progress.py +143,Unit,Unità
apps/erpnext/erpnext/stock/get_item_details.py +136,Please specify Company,Si prega di specificare Azienda
,Customer Acquisition and Loyalty,Acquisizione e fidelizzazione dei clienti
DocType: Asset Maintenance Task,Maintenance Task,Compito di manutenzione
DocType: Purchase Invoice,Warehouse where you are maintaining stock of rejected items,Magazzino dove si conservano Giacenze di Articoli Rifiutati
DocType: Production Order,Skip Material Transfer,Salta il trasferimento dei materiali
apps/erpnext/erpnext/setup/utils.py +109,Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually,Impossibile trovare il tasso di cambio per {0} a {1} per la data chiave {2}. Si prega di creare un record Exchange Exchange manualmente
DocType: POS Profile,Price List,Listino Prezzi
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} è ora l'anno fiscale predefinito. Si prega di aggiornare il browser perché la modifica abbia effetto .
apps/erpnext/erpnext/projects/doctype/task/task.js +45,Expense Claims,Rimborsi spese
DocType: Issue,Support,Post Vendita
,BOM Search,BOM Ricerca
DocType: Item,"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.",Pubblica &quot;in magazzino&quot; o &quot;non in magazzino&quot; su Hub sulla base di magazzino disponibile in questo magazzino.
DocType: Vehicle,Fuel Type,Tipo di carburante
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +27,Please specify currency in Company,Si prega di specificare la valuta in azienda
DocType: Workstation,Wages per hour,Salari all'ora
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +47,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Equilibrio Stock in Lotto {0} sarà negativo {1} per la voce {2} a Warehouse {3}
apps/erpnext/erpnext/templates/emails/reorder_item.html +1,Following Material Requests have been raised automatically based on Item's re-order level,A seguito di richieste di materiale sono state sollevate automaticamente in base al livello di riordino della Voce
DocType: Email Digest,Pending Sales Orders,In attesa di ordini di vendita
apps/erpnext/erpnext/controllers/accounts_controller.py +302,Account {0} is invalid. Account Currency must be {1},Account {0} non valido. La valuta del conto deve essere {1}
DocType: Healthcare Settings,Remind Before,Ricorda prima
apps/erpnext/erpnext/buying/utils.py +34,UOM Conversion factor is required in row {0},Fattore di conversione Unità di Misurà è obbligatoria sulla riga {0}
DocType: Production Plan Item,material_request_item,material_request_item
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1060,"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry","Row # {0}: Riferimento Tipo di documento deve essere uno dei ordini di vendita, fattura di vendita o diario"
DocType: Salary Component,Deduction,Deduzioni
DocType: Item,Retain Sample,Conservare il campione
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +115,Row {0}: From Time and To Time is mandatory.,Riga {0}: From Time To Time ed è obbligatoria.
DocType: Stock Reconciliation Item,Amount Difference,importo Differenza
apps/erpnext/erpnext/stock/get_item_details.py +349,Item Price added for {0} in Price List {1},Prezzo Articolo aggiunto per {0} in Listino Prezzi {1}
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +8,Please enter Employee Id of this sales person,Inserisci ID dipendente di questa persona di vendite
DocType: Territory,Classification of Customers by region,Classificazione dei Clienti per regione
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +71,In Production,In produzione
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +59,Difference Amount must be zero,Differenza L&#39;importo deve essere pari a zero
DocType: Project,Gross Margin,Margine lordo
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +61,Please enter Production Item first,Inserisci Produzione articolo prima
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +45,Calculated Bank Statement balance,Calcolato equilibrio estratto conto
DocType: Normal Test Template,Normal Test Template,Modello di prova normale
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +64,disabled user,utente disabilitato
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +913,Quotation,Preventivo
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +982,Cannot set a received RFQ to No Quote,Impossibile impostare un RFQ ricevuto su No Quote
DocType: Quotation,QTN-,QTN-
DocType: Salary Slip,Total Deduction,Deduzione totale
,Production Analytics,Analytics di produzione
apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +6,This is based on transactions against this Patient. See timeline below for details,Questo è basato sulle transazioni contro questo paziente. Per dettagli vedere la sequenza temporale qui sotto
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +201,Cost Updated,Costo Aggiornato
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48,Item Code &gt; Item Group &gt; Brand,Codice articolo&gt; Gruppo articoli&gt; Marca
DocType: Patient,Date of Birth,Data Compleanno
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +129,Item {0} has already been returned,L'articolo {0} è già stato restituito
DocType: Fiscal Year,**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,**Anno Fiscale** rappresenta un anno contabile. Tutte le voci contabili e le altre operazioni importanti sono tracciati per **Anno Fiscale**.
DocType: Opportunity,Customer / Lead Address,Indirizzo Cliente / Lead
DocType: Supplier Scorecard Period,Supplier Scorecard Setup,Impostazione Scorecard Fornitore
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +133,Assessment Plan Name,Nome del piano di valutazione
apps/erpnext/erpnext/stock/doctype/item/item.py +222,Warning: Invalid SSL certificate on attachment {0},Attenzione: certificato SSL non valido sull&#39;attaccamento {0}
apps/erpnext/erpnext/utilities/activation.py +64,"Leads help you get business, add all your contacts and more as your leads","I Leads ti aiutano ad incrementare il tuo business, aggiungi tutti i tuoi contatti come tuoi leads"
DocType: Production Order Operation,Actual Operation Time,Tempo lavoro effettiva
DocType: Authorization Rule,Applicable To (User),Applicabile a (Utente)
DocType: Purchase Taxes and Charges,Deduct,Detrarre
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +236,Job Description,Descrizione Del Lavoro
DocType: Student Applicant,Applied,Applicato
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +859,Re-open,Riaprire
DocType: Sales Invoice Item,Qty as per Stock UOM,Quantità come da UOM Archivio
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59,Guardian2 Name,Nome Guardian2
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +127,"Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series","Caratteri speciali tranne ""-"" ""."", ""#"", e ""/"" non consentito in denominazione serie"
DocType: Campaign,"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.","Mantenere traccia delle campagne di vendita, dei Leads, Preventivi, Ordini di Vendita ecc per determinare il ritorno sull'investimento."
DocType: Expense Claim,Approver,Responsabile / Approvatore
,SO Qty,SO Quantità
DocType: Guardian,Work Address,Indirizzo di lavoro
DocType: Appraisal,Calculate Total Score,Calcolare il punteggio totale
DocType: Asset Repair,Manufacturing Manager,Responsabile di produzione
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +191,Serial No {0} is under warranty upto {1},Serial No {0} è in garanzia fino a {1}
DocType: Plant Analysis Criteria,Minimum Permissible Value,Valore minimo consentito
apps/erpnext/erpnext/education/doctype/guardian/guardian.py +42,User {0} already exists,L&#39;&#39;utente {0} esiste già
apps/erpnext/erpnext/hooks.py +109,Shipments,Spedizioni
DocType: Payment Entry,Total Allocated Amount (Company Currency),Totale importo assegnato (Valuta della Società)
DocType: Purchase Order Item,To be delivered to customer,Da consegnare al cliente
DocType: BOM,Scrap Material Cost,Costo rottami Materiale
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +227,Serial No {0} does not belong to any Warehouse,N. di serie {0} non appartiene ad alcun magazzino
DocType: Grant Application,Email Notification Sent,Email di notifica inviata
DocType: Purchase Invoice,In Words (Company Currency),In Parole (Azienda valuta)
DocType: Pricing Rule,Supplier,Fornitore
DocType: Consultation,Consultation Time,Tempo di consultazione
DocType: C-Form,Quarter,Trimestrale
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +106,Miscellaneous Expenses,Spese Varie
DocType: Global Defaults,Default Company,Azienda Predefinita
apps/erpnext/erpnext/controllers/stock_controller.py +227,Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,La spesa o il conto differenziato sono obbligatori per l'articolo {0} in quanto hanno un impatto sul valore complessivo del magazzino
DocType: Payment Request,PR,PR
DocType: Cheque Print Template,Bank Name,Nome Banca
apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +29,-Above,-Sopra
DocType: Employee Loan,Employee Loan Account,Impiegato account di prestito
DocType: Leave Application,Total Leave Days,Totale Lascia Giorni
DocType: Email Digest,Note: Email will not be sent to disabled users,Nota: E-mail non sarà inviata agli utenti disabilitati
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14,Number of Interaction,Numero di interazione
apps/erpnext/erpnext/stock/doctype/item/item.js +105,Item Variant Settings,Impostazioni delle varianti dell&#39;elemento
apps/erpnext/erpnext/manufacturing/page/production_analytics/production_analytics.js +39,Select Company...,Seleziona Company ...
DocType: Leave Control Panel,Leave blank if considered for all departments,Lasciare vuoto se considerato per tutti i reparti
apps/erpnext/erpnext/config/hr.py +228,"Types of employment (permanent, contract, intern etc.).","Tipi di occupazione (permanente , contratti , ecc intern ) ."
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +428,{0} is mandatory for Item {1},{0} è obbligatorio per la voce {1}
DocType: Payroll Entry,Fortnightly,Quindicinale
DocType: Currency Exchange,From Currency,Da Valuta
DocType: Vital Signs,Weight (In Kilogram),Peso (in chilogrammo)
DocType: Chapter,"chapters/chapter_name
leave blank automatically set after saving chapter.",capitoli / chapter_name lascia vuoto automaticamente impostato dopo aver salvato il capitolo.
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +170,"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Seleziona importo assegnato, Tipo fattura e fattura numero in almeno uno di fila"
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +128,Cost of New Purchase,Costo del nuovo acquisto
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +97,Sales Order required for Item {0},Ordine di Vendita necessario per l'Articolo {0}
DocType: Grant Application,Grant Description,Descrizione della sovvenzione
DocType: Purchase Invoice Item,Rate (Company Currency),Prezzo (Valuta Azienda)
DocType: Student Guardian,Others,Altri
DocType: Payment Entry,Unallocated Amount,Importo non assegnato
apps/erpnext/erpnext/templates/includes/product_page.js +71,Cannot find a matching Item. Please select some other value for {0}.,Non riesco a trovare un prodotto trovato. Si prega di selezionare un altro valore per {0}.
DocType: POS Profile,Taxes and Charges,Tasse e Costi
DocType: Item,"A Product or a Service that is bought, sold or kept in stock.","Un prodotto o un servizio che viene acquistato, venduto o conservato in magazzino."
apps/erpnext/erpnext/hr/doctype/employee/employee.py +24,Please setup Employee Naming System in Human Resource &gt; HR Settings,Configurare il sistema di denominazione dei dipendenti in Risorse umane&gt; Impostazioni HR
apps/erpnext/erpnext/hr/page/team_updates/team_updates.js +44,No more updates,Nessun altro aggiornamento
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +171,Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,Non è possibile selezionare il tipo di carica come 'On Fila Indietro Importo ' o 'On Precedente totale riga ' per la prima fila
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +6,This covers all scorecards tied to this Setup,Ciò copre tutte le scorecard legate a questo programma di installazione
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,L'elemento figlio non dovrebbe essere un pacchetto di prodotti. Si prega di rimuovere l'elemento `{0}` e salvare
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +12,Banking,bancario
apps/erpnext/erpnext/utilities/activation.py +108,Add Timesheets,Aggiungere schede attività
DocType: Vehicle Service,Service Item,servizio Voce
DocType: Bank Guarantee,Bank Guarantee,Garanzia bancaria
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +39,Please click on 'Generate Schedule' to get schedule,Si prega di cliccare su ' Generate Schedule ' per ottenere pianificazione
DocType: Bin,Ordered Quantity,Quantità Ordinata
apps/erpnext/erpnext/public/js/setup_wizard.js +118,"e.g. ""Build tools for builders""","p. es. "" Costruire strumenti per i costruttori """
DocType: Grading Scale,Grading Scale Intervals,Intervalli di classificazione di scala
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +125,{0} {1}: Accounting Entry for {2} can only be made in currency: {3},{0} {1}: La scrittura contabile {2} può essere effettuate solo in : {3}
DocType: Fee Schedule,In Process,In Process
DocType: Authorization Rule,Itemwise Discount,Sconto Itemwise
apps/erpnext/erpnext/config/accounts.py +75,Tree of financial accounts.,Albero dei conti finanziari.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +362,{0} against Sales Order {1},{0} per ordine di vendita {1}
DocType: Account,Fixed Asset,Asset fisso
apps/erpnext/erpnext/config/stock.py +320,Serialized Inventory,Serialized Inventario
DocType: Employee Loan,Account Info,Informazioni sull&#39;account
DocType: Activity Type,Default Billing Rate,Tariffa predefinita
DocType: Fees,Include Payment,Includi il pagamento
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77,{0} Student Groups created.,{0} Gruppo Studenti creato.
DocType: Sales Invoice,Total Billing Amount,Importo Totale di Fatturazione
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.,Ci deve essere un difetto in arrivo account e-mail abilitato per far funzionare tutto questo. Si prega di configurare un account e-mail di default in entrata (POP / IMAP) e riprovare.
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +50,Program in the Fee Structure and Student Group {0} are different.,Il programma nella struttura tariffaria e nel gruppo di studenti {0} sono diversi.
DocType: Fee Schedule,Receivable Account,Conto Crediti
apps/erpnext/erpnext/controllers/accounts_controller.py +597,Row #{0}: Asset {1} is already {2},Row # {0}: Asset {1} è già {2}
DocType: Quotation Item,Stock Balance,Saldo Delle Scorte
apps/erpnext/erpnext/config/selling.py +316,Sales Order to Payment,Ordine di vendita a pagamento
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +123,CEO,Amministratore delegato
DocType: Purchase Invoice,With Payment of Tax,Con pagamento di imposta
DocType: Expense Claim Detail,Expense Claim Detail,Dettaglio Rimborso Spese
DocType: Purchase Invoice,TRIPLICATE FOR SUPPLIER,TRIPLICATO PER IL FORNITORE
DocType: Land Unit,Is Container,È contenitore
DocType: Crop Cycle,This will be day 1 of the crop cycle,Questo sarà il giorno 1 del ciclo colturale
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +869,Please select correct account,Seleziona account corretto
DocType: Purchase Invoice Item,Weight UOM,Peso UOM
DocType: Salary Structure Employee,Salary Structure Employee,Stipendio Struttura dei dipendenti
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js +45,Show Variant Attributes,Mostra attributi Variant
DocType: Student,Blood Group,Gruppo Discendenza
DocType: Course,Course Name,Nome del corso
DocType: Employee Leave Approver,Users who can approve a specific employee's leave applications,Utenti che possono approvare le domande di permesso di un dipendente specifico
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +52,Office Equipments,Apparecchiature per ufficio
DocType: Purchase Invoice Item,Qty,Qtà
DocType: Fiscal Year,Companies,Aziende
DocType: Supplier Scorecard,Scoring Setup,Impostazione del punteggio
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +24,Electronics,Elettronica
DocType: Stock Settings,Raise Material Request when stock reaches re-order level,Crea un Richiesta Materiale quando la scorta raggiunge il livello di riordino
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +98,Full-time,Tempo pieno
DocType: Payroll Entry,Employees,I dipendenti
DocType: Employee,Contact Details,Dettagli Contatto
DocType: C-Form,Received Date,Data Received
DocType: Delivery Note,"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.","Se è stato creato un modello standard di imposte delle entrate e oneri modello, selezionare uno e fare clic sul pulsante qui sotto."
DocType: BOM Scrap Item,Basic Amount (Company Currency),Importo di base (Società di valuta)
DocType: Student,Guardians,Guardiani
DocType: Shopping Cart Settings,Prices will not be shown if Price List is not set,I prezzi non verranno visualizzati se listino non è impostata
DocType: Stock Entry,Total Incoming Value,Totale Valore Incoming
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +356,Debit To is required,Debito A è richiesto
apps/erpnext/erpnext/utilities/activation.py +109,"Timesheets help keep track of time, cost and billing for activites done by your team","Schede attività per tenere traccia del tempo, i costi e la fatturazione per attività fatta per tua squadra"
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,Purchase Price List,Acquisto Listino Prezzi
apps/erpnext/erpnext/config/buying.py +155,Templates of supplier scorecard variables.,Modelli delle variabili dei scorecard fornitori.
DocType: Offer Letter Term,Offer Term,Termine Offerta
DocType: Asset,Quality Manager,Responsabile Qualità
DocType: Job Applicant,Job Opening,Offerte di Lavoro
DocType: Payment Reconciliation,Payment Reconciliation,Pagamento Riconciliazione
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +153,Please select Incharge Person's name,Si prega di selezionare il nome del Incharge persona
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +51,Technology,Tecnologia
DocType: Hub Settings,Unregister from Hub,Annullare la registrazione da Hub
apps/erpnext/erpnext/public/js/utils.js +102,Total Unpaid: {0},Totale non pagato: {0}
DocType: BOM Website Operation,BOM Website Operation,BOM Pagina web
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +13,Offer Letter,Lettera di Offerta
apps/erpnext/erpnext/config/manufacturing.py +18,Generate Material Requests (MRP) and Production Orders.,Generare richieste di materiali (MRP) e ordini di produzione.
DocType: Supplier Scorecard,Supplier Score,Punteggio del fornitore
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +87,Total Invoiced Amt,Importo Totale Fatturato
DocType: Supplier,Warn RFQs,Avvisa RFQ
DocType: BOM,Conversion Rate,Tasso di conversione
apps/erpnext/erpnext/templates/pages/product_search.html +3,Product Search,Ricerca prodotto
DocType: Assessment Plan,To Time,Per Tempo
DocType: Authorization Rule,Approving Role (above authorized value),Approvazione di ruolo (di sopra del valore autorizzato)
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +118,Credit To account must be a Payable account,Il conto in Accredita a  deve essere Conto Fornitore
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +43,Please select Student Admission which is mandatory for the paid student applicant,Si prega di scegliere l&#39;ammissione all&#39;allievo che è obbligatoria per il candidato scolastico pagato
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +338,BOM recursion: {0} cannot be parent or child of {2},BOM ricorsivo: {0} non può essere un padre o un figlio di {2}
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +23,Please select a Price List to publish pricing,Seleziona un listino prezzi per pubblicare i prezzi
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +38,Budget List,Elenco dei budget
DocType: Production Order Operation,Completed Qty,Q.tà Completata
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +146,"For {0}, only debit accounts can be linked against another credit entry","Per {0}, solo gli account di debito possono essere collegati contro un'altra voce di credito"
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +27,Price List {0} is disabled,Prezzo di listino {0} è disattivato
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +127,Row {0}: Completed Qty cannot be more than {1} for operation {2},Riga {0}: Quantità completato non può essere superiore a {1} per il funzionamento {2}
DocType: Manufacturing Settings,Allow Overtime,Consenti Overtime
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +146,"Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry","L&#39;elemento serializzato {0} non può essere aggiornato utilizzando la riconciliazione di riserva, utilizzare l&#39;opzione Stock Entry"
DocType: Training Event Employee,Training Event Employee,Employee Training Event
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +976,Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,Gli esempi massimi - {0} possono essere conservati per Batch {1} e Item {2}.
apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +6,Add Time Slots,Aggiungi slot di tempo
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +201,{0} Serial Numbers required for Item {1}. You have provided {2}.,{0} numeri di serie necessari per la voce {1}. Lei ha fornito {2}.
DocType: Stock Reconciliation Item,Current Valuation Rate,Corrente Tasso di Valorizzazione
DocType: Item,Customer Item Codes,Codici Voce clienti
DocType: Training Event,Advance,Avanzare
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,for making recurring again.,per fare di nuovo ricorrenti.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +122,Exchange Gain/Loss,Guadagno Exchange / Perdita
DocType: Opportunity,Lost Reason,Motivo della perdita
apps/erpnext/erpnext/public/js/templates/address_list.html +22,New Address,Nuovo indirizzo
DocType: Quality Inspection,Sample Size,Dimensione del campione
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +47,Please enter Receipt Document,Si prega di inserire prima il Documento di Ricevimento
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +369,All items have already been invoiced,Tutti gli articoli sono già stati fatturati
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +49,Please specify a valid 'From Case No.',Si prega di specificare una valida &#39;Dalla sentenza n&#39;
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +24,Further cost centers can be made under Groups but entries can be made against non-Groups,Ulteriori centri di costo possono essere fatte in Gruppi ma le voci possono essere fatte contro i non-Gruppi
apps/erpnext/erpnext/config/setup.py +66,Users and Permissions,Utenti e Permessi
DocType: Vehicle Log,VLOG.,VIDEO BLOG.
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +994,Production Orders Created: {0},Ordini produzione creata: {0}
DocType: Branch,Branch,Ramo
DocType: Soil Analysis,Ca/(K+Ca+Mg),Ca / (K + Ca + Mg)
DocType: Delivery Trip,Fulfillment User,Utente di adempimento
apps/erpnext/erpnext/config/setup.py +61,Printing and Branding,Stampa e Branding
DocType: Company,Total Monthly Sales,Totale vendite mensili
DocType: Agriculture Analysis Criteria,Weather,Tempo metereologico
DocType: Bin,Actual Quantity,Quantità reale
DocType: Shipping Rule,example: Next Day Shipping,esempio: Spedizione il Giorno Successivo
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +187,Serial No {0} not found,Serial No {0} non trovato
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +289,Subscription has been {0},L&#39;abbonamento è stato {0}
DocType: Fee Schedule Program,Fee Schedule Program,Programma di programmazione delle tasse
DocType: Fee Schedule Program,Student Batch,Batch Student
apps/erpnext/erpnext/utilities/activation.py +119,Make Student,Crea Studente
DocType: Supplier Scorecard Scoring Standing,Min Grade,Min Grado
apps/erpnext/erpnext/projects/doctype/project/project.py +214,You have been invited to collaborate on the project: {0},Sei stato invitato a collaborare al progetto: {0}
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +107,Physician not available on {0},Medico non disponibile su {0}
DocType: Leave Block List Date,Block Date,Data Blocco
DocType: Crop,Crop,raccolto
DocType: Purchase Receipt,Supplier Delivery Note,Nota di consegna del fornitore
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +70,Apply Now,Applica ora
apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25,Actual Qty {0} / Waiting Qty {1},Quantità effettiva {0} / Quantità attesa {1}
DocType: Purchase Invoice,E-commerce GSTIN,E-commerce GSTIN
DocType: Sales Order,Not Delivered,Non Consegnati
apps/erpnext/erpnext/controllers/buying_controller.py +422,Expected Date cannot be before Transaction Date,La data prevista non può essere prima della data di transazione
,Bank Clearance Summary,Sintesi Liquidazione Banca
apps/erpnext/erpnext/config/setup.py +106,"Create and manage daily, weekly and monthly email digests.","Creare e gestire giornalieri , settimanali e mensili digerisce email ."
DocType: Appraisal Goal,Appraisal Goal,Obiettivo di Valutazione
DocType: Stock Reconciliation Item,Current Amount,Importo attuale
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +58,Buildings,edifici
DocType: Fee Schedule,Fee Structure,Fee Struttura
DocType: Timesheet Detail,Costing Amount,Costing Importo
DocType: Student Admission Program,Application Fee,Tassa d&#39;iscrizione
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +50,Submit Salary Slip,Presenta Busta Paga
apps/erpnext/erpnext/controllers/selling_controller.py +133,Maxiumm discount for Item {0} is {1}%,Sconto Max per la voce {0} {1} %
apps/erpnext/erpnext/stock/doctype/item_price/item_price.js +16,Import in Bulk,Importazione Collettiva
DocType: Sales Partner,Address & Contacts,Indirizzi & Contatti
DocType: SMS Log,Sender Name,Nome mittente
DocType: Agriculture Analysis Criteria,Agriculture Analysis Criteria,Criteri di analisi dell&#39;agricoltura
apps/erpnext/erpnext/hub_node/page/hub/hub.js +193,Sort by Criteria,Ordina per Criteri
DocType: POS Profile,[Select],[Seleziona]
DocType: Vital Signs,Blood Pressure (diastolic),Pressione sanguigna (diastolica)
DocType: SMS Log,Sent To,Inviato A
DocType: Agriculture Task,Holiday Management,Gestione delle vacanze
DocType: Payment Request,Make Sales Invoice,Crea Fattura di vendita
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +61,Softwares,software
apps/erpnext/erpnext/crm/doctype/lead/lead.py +51,Next Contact Date cannot be in the past,Successivo Contattaci data non puó essere in passato
DocType: Company,For Reference Only.,Per riferimento soltanto.
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +99,Physician {0} not available on {1},Medico {0} non disponibile in {1}
apps/erpnext/erpnext/accounts/page/pos/pos.js +2538,Select Batch No,Seleziona il numero di lotto
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +52,Invalid {0}: {1},Non valido {0}: {1}
DocType: Purchase Invoice,PINV-RET-,PINV-RET-
DocType: Fee Validity,Reference Inv,Riferimento Inv
DocType: Sales Invoice Advance,Advance Amount,Importo Anticipo
DocType: Manufacturing Settings,Capacity Planning,Capacity Planning
DocType: Supplier Quotation,Rounding Adjustment (Company Currency,Regolazione arrotondamento (Valuta Società
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +43,'From Date' is required,"La ""data iniziale"" è richiesta"
DocType: Journal Entry,Reference Number,Numero di riferimento
DocType: Employee,Employment Details,Dettagli Dipendente
DocType: Employee,New Workplace,Nuovo posto di lavoro
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17,Set as Closed,Imposta come Chiuso
apps/erpnext/erpnext/stock/get_item_details.py +125,No Item with Barcode {0},Nessun articolo con codice a barre {0}
DocType: Normal Test Items,Require Result Value,Richiedi valore di risultato
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +51,Case No. cannot be 0,Caso No. Non può essere 0
DocType: Item,Show a slideshow at the top of the page,Visualizzare una presentazione in cima alla pagina
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +517,Boms,Distinte Materiali
apps/erpnext/erpnext/stock/doctype/item/item.py +151,Stores,negozi
DocType: Project Type,Projects Manager,Responsabile Progetti
DocType: Serial No,Delivery Time,Tempo Consegna
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +27,Ageing Based On,Invecchiamento Basato Su
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +66,Appointment cancelled,Appuntamento annullato
DocType: Item,End of Life,Fine Vita
apps/erpnext/erpnext/demo/setup/setup_data.py +331,Travel,viaggi
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +182,No active or default Salary Structure found for employee {0} for the given dates,Nessuna struttura attiva o stipendio predefinito trovato per dipendente {0} per le date indicate
DocType: Leave Block List,Allow Users,Consentire Utenti
DocType: Purchase Order,Customer Mobile No,Clienti mobile No
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +1,Recurring,Periodico
DocType: Cost Center,Track separate Income and Expense for product verticals or divisions.,Traccia reddito separata e spesa per verticali di prodotto o divisioni.
DocType: Rename Tool,Rename Tool,Rename Tool
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +72,Update Cost,Aggiorna il Costo
DocType: Item Reorder,Item Reorder,Articolo riordino
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +463,Show Salary Slip,Visualizza foglio paga
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +848,Transfer Material,Material Transfer
DocType: Fees,Send Payment Request,Invia richiesta di pagamento
DocType: BOM,"Specify the operations, operating cost and give a unique Operation no to your operations.","Specificare le operazioni, costi operativi e dare una gestione unica di no a vostre operazioni."
DocType: Water Analysis,Origin,Origine
apps/erpnext/erpnext/controllers/status_updater.py +201,This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,Questo documento è oltre il limite da {0} {1} per item {4}. State facendo un altro {3} contro lo stesso {2}?
apps/erpnext/erpnext/public/js/controllers/transaction.js +1086,Please set recurring after saving,Si prega di impostare ricorrenti dopo il salvataggio
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +763,Select change amount account,conto importo Selezionare cambiamento
DocType: Purchase Invoice,Price List Currency,Prezzo di listino Valuta
DocType: Naming Series,User must always select,L&#39;utente deve sempre selezionare
DocType: Stock Settings,Allow Negative Stock,Permetti Scorte Negative
DocType: Installation Note,Installation Note,Nota Installazione
DocType: Soil Texture,Clay,Argilla
DocType: Topic,Topic,Argomento
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +40,Cash Flow from Financing,Flusso di cassa da finanziamento
DocType: Budget Account,Budget Account,Il budget dell&#39;account
DocType: Quality Inspection,Verified By,Verificato da
apps/erpnext/erpnext/setup/doctype/company/company.py +70,"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Non è possibile cambiare la valuta di default dell'azienda , perché ci sono le transazioni esistenti . Le operazioni devono essere cancellate per cambiare la valuta di default ."
DocType: Grading Scale Interval,Grade Description,Grade Descrizione
DocType: Stock Entry,Purchase Receipt No,Ricevuta di Acquisto N.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +30,Earnest Money,Caparra
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +34,Traceability,tracciabilità
DocType: Asset Maintenance Log,Actions performed,Azioni eseguite
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +137,Source of Funds (Liabilities),Fonte di Fondi ( Passivo )
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +406,Quantity in row {0} ({1}) must be same as manufactured quantity {2},Quantità in riga {0} ( {1} ) deve essere uguale quantità prodotta {2}
DocType: Supplier Scorecard Scoring Standing,Employee,Dipendente
DocType: Asset Repair,Failure Date,Data di fallimento
DocType: Sample Collection,Collected Time,Tempo raccolto
DocType: Company,Sales Monthly History,Vendite storiche mensili
DocType: Asset Maintenance Task,Next Due Date,Prossima data di scadenza
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +214,Select Batch,Seleziona Batch
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +242,{0} {1} is fully billed,{0} {1} è completamente fatturato
apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +48,Vital Signs,Segni vitali
DocType: Training Event,End Time,Ora fine
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +63,Active Salary Structure {0} found for employee {1} for the given dates,Struttura Stipendio attivo {0} trovato per dipendente {1} per le date indicate
DocType: Payment Entry,Payment Deductions or Loss,"Trattenute, Deduzioni di pagamento o Perdite"
DocType: Soil Analysis,Soil Analysis Criterias,Criteri di analisi del suolo
apps/erpnext/erpnext/config/setup.py +42,Standard contract terms for Sales or Purchase.,Condizioni contrattuali standard per la vendita o di acquisto.
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +100,Group by Voucher,Raggruppa per Voucher
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +195,Are you sure you want to cancel this appointment?,Sei sicuro di voler annullare questo appuntamento?
apps/erpnext/erpnext/config/crm.py +6,Sales Pipeline,pipeline di vendita
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +201,Please set default account in Salary Component {0},Si prega di impostare account predefinito di stipendio componente {0}
apps/erpnext/erpnext/templates/form_grid/material_request_grid.html +7,Required On,Richiesto On
DocType: Rename Tool,File to Rename,File da rinominare
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +200,Please select BOM for Item in Row {0},Seleziona BOM per la voce nella riga {0}
apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +28,Account {0} does not match with Company {1} in Mode of Account: {2},L&#39;account {0} non corrisponde con la società {1} in modalità di account: {2}
apps/erpnext/erpnext/controllers/buying_controller.py +271,Specified BOM {0} does not exist for Item {1},BOM specificato {0} non esiste per la voce {1}
DocType: Soil Texture,Sandy Loam,Terreno sabbioso
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +232,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Programma di manutenzione {0} deve essere cancellato prima di annullare questo ordine di vendita
DocType: POS Profile,Applicable for Users,Applicabile agli Utenti
DocType: Notification Control,Expense Claim Approved,Rimborso Spese Approvato
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +321,Salary Slip of employee {0} already created for this period,Foglio paga del dipendente {0} già creato per questo periodo
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +155,Pharmaceutical,Farmaceutico
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Cost of Purchased Items,Costo dei beni acquistati
DocType: Selling Settings,Sales Order Required,Ordine di Vendita richiesto
DocType: Purchase Invoice,Credit To,Credito a
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +31,Active Leads / Customers,Leads attivi / Clienti
DocType: Employee Education,Post Graduate,Post Laurea
DocType: Maintenance Schedule Detail,Maintenance Schedule Detail,Dettaglio programma di manutenzione
DocType: Supplier Scorecard,Warn for new Purchase Orders,Avvisa per i nuovi ordini di acquisto
DocType: Quality Inspection Reading,Reading 9,Lettura 9
DocType: Supplier,Is Frozen,È Congelato
apps/erpnext/erpnext/stock/utils.py +222,Group node warehouse is not allowed to select for transactions,magazzino nodo di gruppo non è permesso di selezionare per le transazioni
DocType: Buying Settings,Buying Settings,Impostazioni Acquisto
DocType: Stock Entry Detail,BOM No. for a Finished Good Item,N. BOM per quantità buona completata
DocType: Upload Attendance,Attendance To Date,Data Fine Frequenza
DocType: Request for Quotation Supplier,No Quote,Nessuna cifra
DocType: Warranty Claim,Raised By,Sollevata dal
DocType: Payment Gateway Account,Payment Account,Conto di Pagamento
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +906,Please specify Company to proceed,Si prega di specificare Società di procedere
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +22,Net Change in Accounts Receivable,Variazione netta dei crediti
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +88,Compensatory Off,compensativa Off
DocType: Offer Letter,Accepted,Accettato
DocType: Grant Application,Organization,Organizzazione
DocType: BOM Update Tool,BOM Update Tool,Strumento di aggiornamento BOM
DocType: SG Creation Tool Course,Student Group Name,Nome gruppo Student
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +7,Creating Fees,Creazione di tariffe
apps/erpnext/erpnext/setup/doctype/company/company.js +62,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.,Assicurati di voler cancellare tutte le transazioni di questa azienda. I dati anagrafici rimarranno così com&#39;è. Questa azione non può essere annullata.
DocType: Room,Room Number,Numero di Camera
apps/erpnext/erpnext/utilities/transaction_base.py +96,Invalid reference {0} {1},Riferimento non valido {0} {1}
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +187,{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},{0} ({1}) non può essere superiore alla quantità pianificata ({2}) nell'ordine di produzione {3}
DocType: Shipping Rule,Shipping Rule Label,Etichetta Tipo di Spedizione
DocType: Journal Entry Account,Payroll Entry,Ingresso del libro paga
apps/erpnext/erpnext/public/js/conf.js +28,User Forum,Forum utente
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +308,Raw Materials cannot be blank.,Materie prime non può essere vuoto.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +492,"Could not update stock, invoice contains drop shipping item.","Impossibile aggiornare magazzino, fattura contiene articoli di trasporto di goccia."
DocType: Lab Test Sample,Lab Test Sample,Campione di prova del laboratorio
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +492,Quick Journal Entry,Breve diario
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +200,You can not change rate if BOM mentioned agianst any item,Non è possibile cambiare tariffa se la distinta (BOM) è già assegnata a un articolo
DocType: Restaurant,Invoice Series Prefix,Prefisso della serie di fatture
DocType: Employee,Previous Work Experience,Precedente Esperienza Lavoro
DocType: Stock Entry,For Quantity,Per Quantità
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +205,Please enter Planned Qty for Item {0} at row {1},Inserisci pianificato quantità per la voce {0} alla riga {1}
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +102,Google Maps integration is not enabled,L&#39;integrazione con Google Maps non è abilitata
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +239,{0} {1} is not submitted,{0} {1} non è confermato
DocType: Production Planning Tool,Separate production order will be created for each finished good item.,Ordine di produzione separata verrà creato per ogni buon prodotto finito.
DocType: Member,Membership Expiry Date,Data di scadenza dell&#39;appartenenza
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +127,{0} must be negative in return document,{0} deve essere negativo nel documento di reso
,Minutes to First Response for Issues,Minuti per la prima risposta alla controversia
DocType: Purchase Invoice,Terms and Conditions1,Termini e Condizioni
apps/erpnext/erpnext/public/js/setup_wizard.js +109,The name of the institute for which you are setting up this system.,Il nome dell&#39;istituto per il quale si sta impostando questo sistema.
DocType: Accounts Settings,"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Registrazione contabile congelato fino a questa data, nessuno può / Modifica voce eccetto ruolo specificato di seguito."
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +116,Please save the document before generating maintenance schedule,Si prega di salvare il documento prima di generare il programma di manutenzione
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.js +30,Latest price updated in all BOMs,Ultimo prezzo aggiornato in tutte le BOM
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +28,Project Status,Stato del progetto
DocType: UOM,Check this to disallow fractions. (for Nos),Seleziona per disabilitare frazioni. (per NOS)
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +424,The following Production Orders were created:,sono stati creati i seguenti ordini di produzione:
DocType: Student Admission Program,Naming Series (for Student Applicant),Denominazione Serie (per studenti candidati)
DocType: Delivery Note,Transporter Name,Trasportatore Nome
DocType: Authorization Rule,Authorized Value,Valore Autorizzato
DocType: BOM,Show Operations,Mostra Operations
,Minutes to First Response for Opportunity,Minuti per First Response per Opportunità
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Absent,Totale Assente
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +823,Item or Warehouse for row {0} does not match Material Request,Voce o Magazzino per riga {0} non corrisponde Material Request
apps/erpnext/erpnext/config/stock.py +187,Unit of Measure,Unità di Misura
DocType: Fiscal Year,Year End Date,Data di fine anno
DocType: Task Depends On,Task Depends On,L'attività dipende da
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1024,Opportunity,Opportunità
,Completed Production Orders,Completati gli ordini di produzione
DocType: Operation,Default Workstation,Workstation predefinita
DocType: Notification Control,Expense Claim Approved Message,Messaggio Rimborso Spese Approvato
DocType: Payment Entry,Deductions or Loss,"Trattenute, Deduzioni o Perdite"
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +245,{0} {1} is closed,{0} {1} è stato chiuso
DocType: Email Digest,How frequently?,Con quale frequenza?
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +58,Total Collected: {0},Totale Raccolto: {0}
DocType: Purchase Receipt,Get Current Stock,Richiedi disponibilità
apps/erpnext/erpnext/config/manufacturing.py +46,Tree of Bill of Materials,Albero di Bill of Materials
DocType: Student,Joining Date,Unire Data
,Employees working on a holiday,I dipendenti che lavorano in un giorno festivo
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +152,Mark Present,Segna come Presente
DocType: Project,% Complete Method,% Completamento
apps/erpnext/erpnext/healthcare/setup.py +181,Drug,Droga
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +200,Maintenance start date can not be before delivery date for Serial No {0},La data di inizio manutenzione non può essere precedente alla consegna del Serial No {0}
DocType: Production Order,Actual End Date,Data di fine effettiva
DocType: BOM,Operating Cost (Company Currency),Costi di funzionamento (Società di valuta)
DocType: Purchase Invoice,PINV-,PINV-
DocType: Authorization Rule,Applicable To (Role),Applicabile a (Ruolo)
DocType: BOM Update Tool,Replace BOM,Sostituire il BOM
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +110,Code {0} already exist,Il codice {0} esiste già
DocType: Employee Advance,Purpose,Scopo
DocType: Company,Fixed Asset Depreciation Settings,Impostazioni di ammortamento di immobilizzazioni
DocType: Item,Will also apply for variants unless overrridden,Si applica anche per le varianti meno overrridden
DocType: Purchase Invoice,Advances,Avanzamenti
DocType: Production Order,Manufacture against Material Request,Produzione relativa alla Richiesta Materiale
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +10,Assessment Group: ,Gruppo di valutazione:
DocType: Item Reorder,Request for,Richiesta di
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +32,Approving User cannot be same as user the rule is Applicable To,Approvazione utente non può essere uguale all'utente la regola è applicabile ad
DocType: Stock Entry Detail,Basic Rate (as per Stock UOM),Valore base (come da UOM)
DocType: SMS Log,No of Requested SMS,Num. di SMS richiesto
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +245,Leave Without Pay does not match with approved Leave Application records,Lascia senza pagare non corrisponde con i record Leave Application approvati
DocType: Campaign,Campaign-.####,Campagna . # # # #
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +21,Next Steps,Prossimi passi
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +794,Please supply the specified items at the best possible rates,Si prega di fornire gli elementi specificati ai migliori prezzi possibili
DocType: Membership,USD,Dollaro statunitense
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +28,Make Invoice,Crea Fattura
DocType: Selling Settings,Auto close Opportunity after 15 days,Chiudi automaticamente Opportunità dopo 15 giorni
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +76,Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,Gli ordini di acquisto non sono consentiti per {0} a causa di una posizione di scorecard di {1}.
apps/erpnext/erpnext/public/js/financial_statements.js +83,End Year,fine Anno
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23,Quot/Lead %,Quot / Lead%
apps/erpnext/erpnext/hr/doctype/employee/employee.py +124,Contract End Date must be greater than Date of Joining,Data fine contratto deve essere maggiore di Data di giunzione
DocType: Driver,Driver,autista
DocType: Vital Signs,Nutrition Values,Valori nutrizionali
DocType: Lab Test Template,Is billable,È fatturabile
DocType: Delivery Note,DN-,DN-
apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +44,"Both ""Physician Schedule"" and Time Per Appointment"" must be set for Dr {0}",Sia &quot;Physician Schedule&quot; che Time per Appointment devono essere impostati per Dr {0}
DocType: Sales Partner,A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,Un distributore / agenzia / affiliato / rivenditore che vende i prodotti delle aziende per una commissione.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +374,{0} against Purchase Order {1},{0} contro ordine di acquisto {1}
DocType: Patient,Patient Demographics,Demografia del paziente
DocType: Task,Actual Start Date (via Time Sheet),Data di inizio effettiva (da Time Sheet)
apps/erpnext/erpnext/portal/doctype/homepage/homepage.py +15,This is an example website auto-generated from ERPNext,Questo è un sito di esempio generato automaticamente da ERPNext
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +37,Ageing Range 1,Gamma invecchiamento 1
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +226,Total advance amount cannot be greater than total claimed amount,L&#39;importo totale anticipato non può essere superiore all&#39;importo totale richiesto
DocType: Purchase Taxes and Charges Template,"Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.

#### Note

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

#### Description of Columns

1. Calculation Type: 
    - This can be on **Net Total** (that is the sum of basic amount).
    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.
    - **Actual** (as mentioned).
2. Account Head: The Account ledger under which this tax will be booked
3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.
4. Description: Description of the tax (that will be printed in invoices / quotes).
5. Rate: Tax rate.
6. Amount: Tax amount.
7. Total: Cumulative total to this point.
8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).
9. Consider Tax or Charge for: In this section you can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.
10. Add or Deduct: Whether you want to add or deduct the tax.","Modello fiscale standard che può essere applicato a tutte le transazioni di acquisto. Questo modello può contenere l'elenco delle teste fiscali e anche altri capi di spesa come ""spedizione"", ""Assicurazioni"", ""Gestione"", ecc 

 #### Nota 

 Il tax rate si definisce qui sarà l'aliquota standard per tutti gli articoli ** **. Se ci sono gli articoli ** ** che hanno tariffe diverse, devono essere aggiunti nella voce imposte ** ** tavolo in ** ** Item master.

 #### Descrizione di colonne 

 1. Tipo di calcolo: 
 - Questo può essere di ** Net Total ** (che è la somma di importo di base).
 - ** Il Fila Indietro Total / Importo ** (per le imposte o tasse cumulative). Selezionando questa opzione, l'imposta sarà applicata come percentuale della riga precedente (nella tabella fiscale) importo o totale.
 - ** ** Actual (come detto).
 2. Account testa: Il registro account con cui questa imposta sarà prenotato 
 3. Centro di costo: se l'imposta / tassa è di un reddito (come il trasporto) o spese deve essere prenotato contro un centro di costo.
 4. Descrizione: Descrizione della tassa (che sarà stampato in fatture / virgolette).
 5. Vota: Aliquota.
 6. Importo: Ammontare IVA.
 7. Totale: totale cumulativo a questo punto.
 8. Inserisci Row: se sulla base di ""Previous totale riga"" è possibile selezionare il numero di riga che sarà preso come base per il calcolo (di default è la riga precedente).
 9. Considerare fiscale o Charge per: In questa sezione è possibile specificare se l'imposta / tassa è solo per la valutazione (non una parte del totale) o solo per totale (non aggiunge valore al prodotto) o per entrambi.
 10. Aggiungi o dedurre: Se si desidera aggiungere o detrarre l'imposta."
DocType: Homepage,Homepage,Homepage
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +71,Select Physician...,Seleziona medico ...
DocType: Grant Application,Grant Application Details ,Concedere i dettagli dell&#39;applicazione
DocType: Purchase Receipt Item,Recd Quantity,RECD Quantità
apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +59,Fee Records Created - {0},Records Fee Creato - {0}
DocType: Asset Category Account,Asset Category Account,Asset Categoria account
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +137,Cannot produce more Item {0} than Sales Order quantity {1},Non può produrre più Voce {0} di Sales Order quantità {1}
apps/erpnext/erpnext/stock/doctype/item/item.js +360,Select Attribute Values,Seleziona i valori degli attributi
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +537,Stock Entry {0} is not submitted,Movimento di magazzino {0} non confermato
DocType: Payment Reconciliation,Bank / Cash Account,Conto Banca / Cassa
apps/erpnext/erpnext/crm/doctype/lead/lead.py +45,Next Contact By cannot be same as the Lead Email Address,Successivo Contatto Con non può coincidere con l'email del Lead
DocType: Tax Rule,Billing City,Città di fatturazione
DocType: Asset,Manual,Manuale
DocType: Salary Component Account,Salary Component Account,Conto Stipendio Componente
DocType: Global Defaults,Hide Currency Symbol,Nascondi Simbolo Valuta
apps/erpnext/erpnext/config/non_profit.py +58,Donor information.,Informazioni sui donatori
apps/erpnext/erpnext/config/accounts.py +330,"e.g. Bank, Cash, Credit Card","p. es. Banca, Bonifico, Contanti, Carta di credito"
DocType: Lead Source,Source Name,Source Name
DocType: Vital Signs,"Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""","La pressione sanguigna normale in un adulto è di circa 120 mmHg sistolica e 80 mmHg diastolica, abbreviata &quot;120/80 mmHg&quot;"
DocType: Journal Entry,Credit Note,Nota di Credito
DocType: Warranty Claim,Service Address,Service Indirizzo
DocType: Asset Maintenance Task,Calibration,Calibrazione
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +49,Furnitures and Fixtures,Mobili e Infissi
DocType: Item,Manufacture,Produzione
apps/erpnext/erpnext/utilities/user_progress.py +24,Setup Company,Configura società
,Lab Test Report,Lab Test Report
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +13,Please Delivery Note first,Si prega di compilare prima il DDT
DocType: Student Applicant,Application Date,Data di applicazione
DocType: Salary Detail,Amount based on formula,Importo basato sul formula
DocType: Purchase Invoice,Currency and Price List,Listino Prezzi e Valuta
DocType: Opportunity,Customer / Lead Name,Nome Cliente / Lead
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +99,Clearance Date not mentioned,Liquidazione data non menzionato
apps/erpnext/erpnext/config/manufacturing.py +7,Production,produzione
DocType: Guardian,Occupation,Occupazione
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +74,Row {0}:Start Date must be before End Date,Riga {0} : Data di inizio deve essere precedente Data di fine
DocType: Crop,Planting Area,Area di impianto
apps/erpnext/erpnext/controllers/trends.py +19,Total(Qty),Totale (Quantità)
DocType: Installation Note Item,Installed Qty,Qtà installata
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +4,This could be because of some invalid Email Addresses in the,Ciò potrebbe essere dovuto a alcuni indirizzi email non validi nel
apps/erpnext/erpnext/utilities/user_progress.py +28,You added ,Hai aggiunto
DocType: Purchase Taxes and Charges,Parenttype,ParentType
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +10,Training Result,Formazione Risultato
DocType: Purchase Invoice,Is Paid,È pagato
DocType: Salary Structure,Total Earning,Guadagnare totale
DocType: Purchase Receipt,Time at which materials were received,Ora in cui sono stati ricevuti i materiali
DocType: Products Settings,Products per Page,Prodotti per pagina
DocType: Stock Ledger Entry,Outgoing Rate,Tasso di uscita
apps/erpnext/erpnext/config/hr.py +233,Organization branch master.,Ramo Organizzazione master.
apps/erpnext/erpnext/controllers/accounts_controller.py +303, or ,oppure
DocType: Sales Order,Billing Status,Stato Fatturazione
apps/erpnext/erpnext/public/js/conf.js +32,Report an Issue,Segnala un problema
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +120,Utility Expenses,Spese di utenza
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +64,90-Above,90-Sopra
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +241,Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher,Row # {0}: diario {1} non ha conto {2} o già confrontato con un altro buono
DocType: Supplier Scorecard Criteria,Criteria Weight,Criteri Peso
DocType: Buying Settings,Default Buying Price List,Predefinito acquisto Prezzo di listino
DocType: Payroll Entry,Salary Slip Based on Timesheet,Stipendio slip Sulla base di Timesheet
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +19,Buying Rate,Tasso di acquisto
DocType: Notification Control,Sales Order Message,Sales Order Messaggio
apps/erpnext/erpnext/config/setup.py +15,"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Impostare i valori predefiniti , come Società , valuta , corrente anno fiscale , ecc"
DocType: Payment Entry,Payment Type,Tipo di pagamento
apps/erpnext/erpnext/stock/doctype/batch/batch.py +140,Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,Seleziona un batch per l&#39;articolo {0}. Impossibile trovare un unico batch che soddisfi questo requisito
DocType: Hub Category,Parent Category,Categoria Parent
DocType: Payroll Entry,Select Employees,Selezionare Dipendenti
DocType: Opportunity,Potential Sales Deal,Deal potenziale di vendita
DocType: Complaint,Complaints,"Denunce, contestazioni"
DocType: Payment Entry,Cheque/Reference Date,Data di riferimento
DocType: Purchase Invoice,Total Taxes and Charges,Totale imposte e oneri
DocType: Employee,Emergency Contact,Contatto di emergenza
DocType: Bank Reconciliation Detail,Payment Entry,Registrazione di pagamento
DocType: Item,Quality Parameters,Parametri di Qualità
,sales-browser,vendite browser
apps/erpnext/erpnext/accounts/doctype/account/account.js +79,Ledger,Ledger
DocType: Patient Medical Record,PMR-,PMR-
DocType: Drug Prescription,Drug Code,Codice di droga
DocType: Target Detail,Target  Amount,L&#39;importo previsto
DocType: POS Profile,Print Format for Online,Formato di stampa per Online
DocType: Shopping Cart Settings,Shopping Cart Settings,Carrello Impostazioni
DocType: Journal Entry,Accounting Entries,Scritture contabili
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +24,Duplicate Entry. Please check Authorization Rule {0},Duplicate Entry. Si prega di controllare Autorizzazione Regola {0}
DocType: Journal Entry Account,Reference Due Date,Data di scadenza di riferimento
DocType: Purchase Order,Ref SQ,Rif. SQ
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +55,Receipt document must be submitted,La Ricevuta deve essere presentata
DocType: Purchase Invoice Item,Received Qty,Quantità ricevuta
DocType: Stock Entry Detail,Serial No / Batch,Serial n / Batch
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +340,Not Paid and Not Delivered,Non pagato ma non ritirato
DocType: Product Bundle,Parent Item,Parent Item
DocType: Account,Account Type,Tipo di account
DocType: Delivery Note,DN-RET-,DN-RET-
apps/erpnext/erpnext/templates/pages/projects.html +58,No time sheets,Non ci sono fogli di presenza
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +123,Leave Type {0} cannot be carry-forwarded,Lascia tipo {0} non può essere trasmessa carry-
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +215,Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',Programma di manutenzione non generato per tutte le voci. Rieseguire 'Genera Programma'
,To Produce,per produrre
apps/erpnext/erpnext/config/hr.py +93,Payroll,Libro paga
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +196,"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Per riga {0} a {1}. Per includere {2} a tasso Item, righe {3} deve essere inclusa anche"
apps/erpnext/erpnext/utilities/activation.py +101,Make User,Crea Utente
DocType: Packing Slip,Identification of the package for the delivery (for print),Identificazione del pacchetto per la consegna (per la stampa)
DocType: Bin,Reserved Quantity,Riservato Quantità
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34,Please enter valid email address,Inserisci indirizzo email valido
DocType: Volunteer Skill,Volunteer Skill,Abilità volontaria
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +713,Please select an item in the cart,Seleziona un elemento nel carrello
DocType: Landed Cost Voucher,Purchase Receipt Items,Acquistare oggetti Receipt
apps/erpnext/erpnext/config/learn.py +21,Customizing Forms,Personalizzazione dei moduli
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +74,Arrear,arretrato
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +158,Depreciation Amount during the period,Quota di ammortamento durante il periodo
apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py +38,Disabled template must not be default template,modello disabili non deve essere modello predefinito
DocType: Account,Income Account,Conto Proventi
DocType: Payment Request,Amount in customer's currency,Importo nella valuta del cliente
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +823,Delivery,Consegna
DocType: Volunteer,Weekdays,Nei giorni feriali
DocType: Stock Reconciliation Item,Current Qty,Quantità corrente
DocType: Restaurant Menu,Restaurant Menu,Ristorante Menu
apps/erpnext/erpnext/templates/generators/item_group.html +36,Prev,prev
DocType: Appraisal Goal,Key Responsibility Area,Area Responsabilità Chiave
apps/erpnext/erpnext/utilities/activation.py +127,"Student Batches help you track attendance, assessments and fees for students","I lotti degli studenti aiutano a tenere traccia di presenza, le valutazioni e le tasse per gli studenti"
DocType: Payment Entry,Total Allocated Amount,Totale importo assegnato
apps/erpnext/erpnext/setup/doctype/company/company.py +140,Set default inventory account for perpetual inventory,Imposta l&#39;account di inventario predefinito per l&#39;inventario perpetuo
DocType: Item Reorder,Material Request Type,Tipo di richiesta materiale
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +252,Accural Journal Entry for salaries from {0} to {1},Accural diario per gli stipendi da {0} a {1}
apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js +17,Send Grant Review Email,Invia e-mail di revisione di Grant
apps/erpnext/erpnext/accounts/page/pos/pos.js +839,"LocalStorage is full, did not save","LocalStorage è pieno, non ha salvato"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +90,Row {0}: UOM Conversion Factor is mandatory,Riga {0}: UOM fattore di conversione è obbligatoria
apps/erpnext/erpnext/utilities/user_progress.py +232,Room Capacity,Capacità della camera
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +14,Ref,Rif
DocType: Lab Test,LP-,LP-
DocType: Healthcare Settings,Registration Fee,Commissione di iscrizione
DocType: Budget,Cost Center,Centro di Costo
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +45,Voucher #,Voucher #
DocType: Notification Control,Purchase Order Message,Ordine di acquisto Message
DocType: Tax Rule,Shipping Country,Spedizione Nazione
DocType: Selling Settings,Hide Customer's Tax Id from Sales Transactions,Nascondere P. IVA / Cod. Fiscale dei clienti dai documenti di vendita
DocType: Upload Attendance,Upload HTML,Carica HTML
DocType: Employee,Relieving Date,Alleviare Data
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +14,"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.","Regola Pricing è fatto per sovrascrivere Listino Prezzi / definire la percentuale di sconto, sulla base di alcuni criteri."
DocType: Serial No,Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Magazzino può essere modificato solo tramite Inserimento Giacenza / Bolla (DDT) / Ricevuta d'acquisto
DocType: Employee Education,Class / Percentage,Classe / Percentuale
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +134,Head of Marketing and Sales,Responsabile Marketing e Vendite
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +72,Income Tax,Tassazione Proventi
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +17,"If selected Pricing Rule is made for 'Price', it will overwrite Price List. Pricing Rule price is the final price, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.","Se regola tariffaria selezionato è fatta per 'prezzo', che sovrascriverà Listino. Prezzo Regola Il prezzo è il prezzo finale, in modo che nessun ulteriore sconto deve essere applicato. Quindi, in operazioni come ordine di vendita, ordine di acquisto, ecc, che viene prelevato in campo 'Tasso', piuttosto che il campo 'Listino Rate'."
apps/erpnext/erpnext/config/selling.py +174,Track Leads by Industry Type.,Monitora i Leads per settore.
apps/erpnext/erpnext/utilities/user_progress.py +98,Go to Letterheads,Vai a carta intestata
DocType: Item Supplier,Item Supplier,Articolo Fornitore
apps/erpnext/erpnext/public/js/controllers/transaction.js +1187,Please enter Item Code to get batch no,Inserisci il codice Item per ottenere lotto non
apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +874,Please select a value for {0} quotation_to {1},Si prega di selezionare un valore per {0} quotation_to {1}
apps/erpnext/erpnext/config/selling.py +46,All Addresses.,Tutti gli indirizzi.
DocType: Company,Stock Settings,Impostazioni Giacenza
apps/erpnext/erpnext/accounts/doctype/account/account.py +185,"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","La fusione è possibile solo se le seguenti proprietà sono le stesse in entrambi i record. E' un Gruppo, Tipo Radice, Azienda"
DocType: Vehicle,Electric,Elettrico
DocType: Task,% Progress,% Avanzamento
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +123,Gain/Loss on Asset Disposal,Profitti/Perdite su Asset in smaltimento
DocType: Task,Depends on Tasks,Dipende Compiti
apps/erpnext/erpnext/config/selling.py +36,Manage Customer Group Tree.,Gestire cliente con raggruppamento ad albero
DocType: Shopping Cart Settings,Attachments can be shown without enabling the shopping cart,Gli allegati possono essere visualizzati senza abilitare il carrello
DocType: Normal Test Items,Result Value,Valore risultato
DocType: Supplier Quotation,SQTN-,SQTN-
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +22,New Cost Center Name,Nuovo Nome Centro di costo
DocType: Leave Control Panel,Leave Control Panel,Lascia il Pannello di controllo
DocType: Project,Task Completion,Completamento dell'attività
apps/erpnext/erpnext/templates/includes/product_page.js +21,Not in Stock,Non in Stock
DocType: Volunteer,Volunteer Skills,Abilità di volontariato
DocType: Appraisal,HR User,HR utente
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +36,POS?,POS?
DocType: Purchase Invoice,Taxes and Charges Deducted,Tasse e oneri dedotti
apps/erpnext/erpnext/hooks.py +142,Issues,Controversie
apps/erpnext/erpnext/controllers/status_updater.py +12,Status must be one of {0},Stato deve essere uno dei {0}
DocType: Sales Invoice,Debit To,Addebito a
DocType: Restaurant Menu Item,Restaurant Menu Item,Menu del menu del ristorante
DocType: Delivery Note,Required only for sample item.,Richiesto solo per la voce di esempio.
DocType: Stock Ledger Entry,Actual Qty After Transaction,Q.tà reale post-transazione
apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +79,No salary slip found between {0} and {1},Nessun slittamento di stipendio trovato tra {0} e {1}
,Pending SO Items For Purchase Request,Elementi in sospeso così per Richiesta di Acquisto
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +35,Student Admissions,Ammissioni di studenti
apps/erpnext/erpnext/accounts/party.py +376,{0} {1} is disabled,{0} {1} è disabilitato
DocType: Supplier,Billing Currency,Fatturazione valuta
DocType: Sales Invoice,SINV-RET-,SINV-RET-
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +200,Extra Large,Extra Large
DocType: Crop,Scientific Name,Nome scientifico
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Leaves,Foglie totali
DocType: Consultation,In print,In stampa
,Profit and Loss Statement,Conto Economico
DocType: Bank Reconciliation Detail,Cheque Number,Numero Assegno
,Sales Browser,Browser vendite
DocType: Journal Entry,Total Credit,Totale credito
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +540,Warning: Another {0} # {1} exists against stock entry {2},Attenzione: Un altro {0} # {1} esiste per l'entrata Giacenza {2}
apps/erpnext/erpnext/utilities/user_progress_utils.py +66,Local,Locale
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +26,Loans and Advances (Assets),Crediti ( Assets )
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +12,Debtors,Debitori
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +199,Large,Grande
DocType: Homepage Featured Product,Homepage Featured Product,Homepage prodotto in vetrina
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +246,All Assessment Groups,Tutti i gruppi di valutazione
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +15,New Warehouse Name,Nuovo nome Magazzino
apps/erpnext/erpnext/accounts/report/financial_statements.py +233,Total {0} ({1}),Totale {0} ({1})
DocType: C-Form Invoice Detail,Territory,Territorio
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +151,Please mention no of visits required,Si prega di citare nessuna delle visite richieste
DocType: Stock Settings,Default Valuation Method,Metodo di valorizzazione predefinito
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +26,Fee,tassa
apps/erpnext/erpnext/setup/doctype/company/company.js +125,Update in progress. It might take a while.,Aggiornamento in corso. Potrebbe volerci un po &#39;.
DocType: Vehicle Log,Fuel Qty,Quantità di carburante
DocType: Production Order Operation,Planned Start Time,Ora di inizio prevista
DocType: Course,Assessment,Valutazione
DocType: Payment Entry Reference,Allocated,Assegnati
apps/erpnext/erpnext/config/accounts.py +267,Close Balance Sheet and book Profit or Loss.,Chiudere Stato Patrimoniale e il libro utile o perdita .
DocType: Student Applicant,Application Status,Stato dell&#39;applicazione
DocType: Sensitivity Test Items,Sensitivity Test Items,Elementi di prova di sensibilità
DocType: Fees,Fees,tasse
DocType: Currency Exchange,Specify Exchange Rate to convert one currency into another,Specificare Tasso di cambio per convertire una valuta in un'altra
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +159,Quotation {0} is cancelled,Preventivo {0} è annullato
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +25,Total Outstanding Amount,Totale Importo Dovuto
DocType: Sales Partner,Targets,Obiettivi
DocType: Price List,Price List Master,Listino Principale
DocType: Sales Person,All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,Tutte le transazioni di vendita possono essere etichettati contro più persone ** ** di vendita in modo da poter impostare e monitorare gli obiettivi.
,S.O. No.,S.O. No.
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +241,Please create Customer from Lead {0},Si prega di creare il Cliente dal Lead {0}
apps/erpnext/erpnext/healthcare/page/medical_record/patient_select.html +3,Select Patient,Selezionare Paziente
DocType: Price List,Applicable for Countries,Applicabile per i paesi
DocType: Supplier Scorecard Scoring Variable,Parameter Name,Nome del parametro
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +52,Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,Solo Lasciare applicazioni con lo stato &#39;approvato&#39; e &#39;rifiutato&#39; possono essere presentate
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +52,Student Group Name is mandatory in row {0},Student Nome gruppo è obbligatoria in riga {0}
DocType: Homepage,Products to be shown on website homepage,I prodotti che devono figurare home page del sito
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js +13,This is a root customer group and cannot be edited.,Si tratta di un gruppo di clienti root e non può essere modificato .
DocType: Student,AB-,AB-
DocType: POS Profile,Ignore Pricing Rule,Ignora regola tariffaria
DocType: Employee Education,Graduate,Laureato
DocType: Leave Block List,Block Days,Giorno Blocco
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +83,"Shipping Address does not have country, which is required for this Shipping Rule","Indirizzo di spedizione non ha paese, che è richiesto per questa regola di spedizione"
DocType: Journal Entry,Excise Entry,Excise Entry
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +65,Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Attenzione: ordini di vendita {0} esiste già contro Ordine di Acquisto del Cliente {1}
DocType: Terms and Conditions,"Standard Terms and Conditions that can be added to Sales and Purchases.

Examples:

1. Validity of the offer.
1. Payment Terms (In Advance, On Credit, part advance etc).
1. What is extra (or payable by the Customer).
1. Safety / usage warning.
1. Warranty if any.
1. Returns Policy.
1. Terms of shipping, if applicable.
1. Ways of addressing disputes, indemnity, liability, etc.
1. Address and Contact of your Company.","Condizioni generali e condizioni che possono essere aggiunti alle Vendite e Acquisti.

 Esempi: 

 1. Validità dell'offerta.
 1. Termini di pagamento (in anticipo, a credito, parte prima, ecc).
 1. Che cosa è extra (o da pagare da parte del cliente).
 1. Warning Sicurezza / utilizzo.
 1. Garanzia se presente.
 1. Recesso.
 1. Condizioni di trasporto, se applicabile.
 1. Modi di controversie indirizzamento, indennità, responsabilità, ecc 
 1. Indirizzo e contatti della vostra azienda."
DocType: Issue,Issue Type,tipo di problema
DocType: Attendance,Leave Type,Lascia Tipo
DocType: Purchase Invoice,Supplier Invoice Details,Dettagli Fattura Fornitore
DocType: Agriculture Task,Ignore holidays,Ignora le vacanze
apps/erpnext/erpnext/controllers/stock_controller.py +233,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Expense / account Differenza ({0}) deve essere un 'utile o perdita' conto
DocType: Project,Copied From,Copiato da
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +96,Name error: {0},Nome errore: {0}
apps/erpnext/erpnext/stock/doctype/item/item_list.js +12,Shortage,Carenza
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +18,Attendance for employee {0} is already marked,Assistenza per dipendente {0} è già contrassegnata
DocType: Packing Slip,If more than one package of the same type (for print),Se più di un pacchetto dello stesso tipo (per la stampa)
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +27,Please set default customer in Restaurant Settings,Impostare il cliente predefinito in Impostazioni ristorante
,Salary Register,stipendio Register
DocType: Warehouse,Parent Warehouse,Magazzino Parent
DocType: C-Form Invoice Detail,Net Total,Totale Netto
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +526,Default BOM not found for Item {0} and Project {1},La BOM di default non è stata trovata per l&#39;oggetto {0} e il progetto {1}
apps/erpnext/erpnext/config/hr.py +168,Define various loan types,Definire i vari tipi di prestito
DocType: Bin,FCFS Rate,FCFS Rate
DocType: Opening Invoice Creation Tool Item,Outstanding Amount,Importo Dovuto
apps/erpnext/erpnext/templates/generators/bom.html +71,Time(in mins),Tempo (in minuti)
DocType: Project Task,Working,Lavorando
DocType: Stock Ledger Entry,Stock Queue (FIFO),Code Giacenze (FIFO)
apps/erpnext/erpnext/public/js/setup_wizard.js +127,Financial Year,Anno finanziario
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +46,{0} does not belong to Company {1},{0} non appartiene alla società {1}
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +66,Could not solve criteria score function for {0}. Make sure the formula is valid.,Impossibile risolvere la funzione di valutazione dei criteri per {0}. Assicurarsi che la formula sia valida.
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +122,Cost as on,Costo come in
DocType: Healthcare Settings,Out Patient Settings,Impostazioni paziente
DocType: Account,Round Off,Arrotondare
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +252,Quantity must be positive,La quantità deve essere positiva
,Requested Qty,richiesto Quantità
DocType: Tax Rule,Use for Shopping Cart,Uso per Carrello
apps/erpnext/erpnext/controllers/item_variant.py +96,Value {0} for Attribute {1} does not exist in the list of valid Item Attribute Values for Item {2},Valore {0} per l&#39;attributo {1} non esiste nella lista della voce valida Attributo Valori per la voce {2}
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +79,Select Serial Numbers,Selezionare i numeri di serie
DocType: BOM Item,Scrap %,Scrap%
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +46,"Charges will be distributed proportionately based on item qty or amount, as per your selection","Spese saranno distribuiti proporzionalmente basate su qty voce o importo, secondo la vostra selezione"
DocType: Maintenance Visit,Purposes,Scopi
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +111,Atleast one item should be entered with negative quantity in return document,Atleast un elemento deve essere introdotto con quantità negativa nel documento ritorno
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","Operazione {0} più di tutte le ore di lavoro disponibili a workstation {1}, abbattere l&#39;operazione in più operazioni"
DocType: Membership,Membership Status,Stato di appartenenza
,Requested,richiesto
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +93,No Remarks,Nessun Commento
DocType: Asset,In Maintenance,In manutenzione
DocType: Purchase Invoice,Overdue,In ritardo
DocType: Account,Stock Received But Not Billed,Giacenza Ricevuta ma non Fatturata
apps/erpnext/erpnext/accounts/doctype/account/account.py +86,Root Account must be a group,Account root deve essere un gruppo
DocType: Consultation,Drug Prescription,Prescrizione di farmaci
DocType: Fees,FEE.,FEE.
DocType: Employee Loan,Repaid/Closed,Rimborsato / Chiuso
DocType: Item,Total Projected Qty,Totale intermedio Quantità proiettata
DocType: Monthly Distribution,Distribution Name,Nome della Distribuzione
apps/erpnext/erpnext/stock/stock_ledger.py +471,"Valuation rate not found for the Item {0}, which is required to do accounting entries for {1} {2}. If the item is transacting as a zero valuation rate item in the {1}, please mention that in the {1} Item table. Otherwise, please create an incoming stock transaction for the item or mention valuation rate in the Item record, and then try submiting/cancelling this entry","Tasso di valutazione non trovato per l&#39;elemento {0}, che è necessario per le voci di contabilità per {1} {2}. Se l&#39;elemento sta trattando come elemento di tasso di valutazione zero nel {1}, si prega di menzionarlo nella tabella {1} Item. Altrimenti, crea un&#39;operazione di transazione in arrivo per la voce di valutazione di voce o di menzione nell&#39;annotazione dell&#39;articolo e prova quindi a inviare / annullare questa voce"
DocType: Course,Course Code,Codice del corso
apps/erpnext/erpnext/controllers/stock_controller.py +331,Quality Inspection required for Item {0},Controllo qualità richiesta per la voce {0}
DocType: POS Settings,Use POS in Offline Mode,Utilizza POS in modalità Offline
DocType: Supplier Scorecard,Supplier Variables,Variabili del fornitore
DocType: Quotation,Rate at which customer's currency is converted to company's base currency,Tasso al quale la valuta del cliente viene convertito in valuta di base dell&#39;azienda
DocType: Purchase Invoice Item,Net Rate (Company Currency),Tasso Netto (Valuta Azienda)
DocType: Salary Detail,Condition and Formula Help,Condizione e Formula Aiuto
apps/erpnext/erpnext/config/selling.py +105,Manage Territory Tree.,Gestire territorio ad albero
DocType: Journal Entry Account,Sales Invoice,Fattura di Vendita
DocType: Journal Entry Account,Party Balance,Saldo del Partner
apps/erpnext/erpnext/accounts/page/pos/pos.js +497,Please select Apply Discount On,Si prega di selezionare Applica sconto su
DocType: Stock Settings,Sample Retention Warehouse,Magazzino di conservazione dei campioni
DocType: Company,Default Receivable Account,Account Crediti Predefinito
DocType: Physician,Physician Schedule,Schedule del medico
DocType: Purchase Invoice,Deemed Export,Deemed Export
DocType: Stock Entry,Material Transfer for Manufacture,Trasferimento materiali  per Produzione
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +20,Discount Percentage can be applied either against a Price List or for all Price List.,Percentuale di sconto può essere applicato sia contro un listino prezzi o per tutti Listino.
DocType: Subscription,Half-yearly,Semestrale
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +406,Accounting Entry for Stock,Voce contabilità per giacenza
DocType: Lab Test,LabTest Approver,LabTest Approver
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +49,You have already assessed for the assessment criteria {}.,Hai già valutato i criteri di valutazione {}.
DocType: Vehicle Service,Engine Oil,Olio motore
DocType: Sales Invoice,Sales Team1,Vendite Team1
apps/erpnext/erpnext/stock/doctype/item/item.py +521,Item {0} does not exist,L'articolo {0} non esiste
DocType: Sales Invoice,Customer Address,Indirizzo Cliente
DocType: Employee Loan,Loan Details,prestito Dettagli
DocType: Company,Default Inventory Account,Account di inventario predefinito
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +124,Row {0}: Completed Qty must be greater than zero.,Riga {0}: Quantità compilato deve essere maggiore di zero.
DocType: Antibiotic,Antibiotic Name,Nome antibiotico
DocType: Purchase Invoice,Apply Additional Discount On,Applicare lo Sconto Aggiuntivo su
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +69,Select Type...,Seleziona tipo ...
DocType: Crop Cycle,A link to all the Land Units in which the Crop is growing,Un link a tutte le unità di terra in cui cresce il raccolto
DocType: Account,Root Type,Root Tipo
DocType: Item,FIFO,FIFO
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +132,Row # {0}: Cannot return more than {1} for Item {2},Row # {0}: Impossibile restituire più di {1} per la voce {2}
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +45,Plot,trama
DocType: Item Group,Show this slideshow at the top of the page,Mostra questo slideshow in cima alla pagina
DocType: BOM,Item UOM,Articolo UOM
DocType: Sales Taxes and Charges,Tax Amount After Discount Amount (Company Currency),Valore Tasse Dopo Sconto dell'Importo(Valuta Società)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +155,Target warehouse is mandatory for row {0},Il Magazzino di Destinazione per il rigo {0}
DocType: Cheque Print Template,Primary Settings,Impostazioni primarie
DocType: Purchase Invoice,Select Supplier Address,Selezionare l'indirizzo del Fornitore
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +397,Add Employees,Aggiungere dipendenti
DocType: Purchase Invoice Item,Quality Inspection,Controllo Qualità
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +196,Extra Small,Extra Small
DocType: Company,Standard Template,Template Standard
DocType: Training Event,Theory,Teoria
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +805,Warning: Material Requested Qty is less than Minimum Order Qty,Attenzione : Materiale Qty richiesto è inferiore minima quantità
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +211,Account {0} is frozen,Il Conto {0} è congelato
DocType: Company,Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,Entità Legale / Controllata con un grafico separato di conti appartenenti all'organizzazione.
DocType: Payment Request,Mute Email,Email muta
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +29,"Food, Beverage & Tobacco","Prodotti alimentari , bevande e tabacco"
DocType: Account,Account Number,Numero di conto
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +714,Can only make payment against unbilled {0},Posso solo effettuare il pagamento non ancora fatturate contro {0}
apps/erpnext/erpnext/controllers/selling_controller.py +98,Commission rate cannot be greater than 100,Tasso Commissione non può essere superiore a 100
DocType: Volunteer,Volunteer,Volontario
DocType: Stock Entry,Subcontract,Conto lavoro
apps/erpnext/erpnext/public/js/utils/party.js +165,Please enter {0} first,Si prega di inserire {0} prima
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +87,No replies from,Nessuna replica da
DocType: Production Order Operation,Actual End Time,Ora di fine effettiva
DocType: Production Planning Tool,Download Materials Required,Scaricare Materiali Richiesti
DocType: Item,Manufacturer Part Number,Codice articolo Produttore
DocType: Production Order Operation,Estimated Time and Cost,Tempo e Costo Stimato
DocType: Bin,Bin,Bin
DocType: Crop,Crop Name,Nome del raccolto
DocType: SMS Log,No of Sent SMS,Num. di SMS Inviati
DocType: Antibiotic,Healthcare Administrator,Amministratore sanitario
apps/erpnext/erpnext/utilities/user_progress.py +44,Set a Target,Imposta un target
DocType: Dosage Strength,Dosage Strength,Forza di dosaggio
DocType: Account,Expense Account,Conto uscite
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +49,Software,software
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +203,Colour,Colore
DocType: Assessment Plan Criteria,Assessment Plan Criteria,Criteri di valutazione del Piano
DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Impedire gli ordini di acquisto
apps/erpnext/erpnext/healthcare/setup.py +258,Susceptible,suscettibile
DocType: Patient Appointment,Scheduled,Pianificate
apps/erpnext/erpnext/config/buying.py +18,Request for quotation.,Richiesta di offerta.
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","Si prega di selezionare la voce dove &quot;è articolo di&quot; è &quot;No&quot; e &quot;Is Voce di vendita&quot; è &quot;Sì&quot;, e non c&#39;è nessun altro pacchetto di prodotti"
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.js +148,Select Customer,Seleziona cliente
DocType: Student Log,Academic,Accademico
DocType: Patient,Personal and Social History,Storia personale e sociale
apps/erpnext/erpnext/education/doctype/guardian/guardian.py +52,User {0} created,L&#39;utente {0} creato
DocType: Fee Schedule,Fee Breakup for each student,Scomposizione per ogni studente
apps/erpnext/erpnext/controllers/accounts_controller.py +520,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),L'Anticipo totale ({0}) relativo all'ordine {1} non può essere superiore al totale complessivo ({2})
DocType: Sales Partner,Select Monthly Distribution to unevenly distribute targets across months.,Selezionare distribuzione mensile per distribuire in modo non uniforme obiettivi attraverso mesi.
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +78,Change Code,Cambiare il codice
DocType: Purchase Invoice Item,Valuation Rate,Tasso di Valorizzazione
DocType: Stock Reconciliation,SR/,SR /
DocType: Vehicle,Diesel,diesel
apps/erpnext/erpnext/stock/get_item_details.py +381,Price List Currency not selected,Listino Prezzi Valuta non selezionati
apps/erpnext/erpnext/config/healthcare.py +46,Results,risultati
,Student Monthly Attendance Sheet,Presenze mensile Scheda
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +96,Shipping rule only applicable for Selling,Regola di spedizione applicabile solo per la vendita
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +185,Employee {0} has already applied for {1} between {2} and {3},Employee {0} ha già presentato domanda di {1} tra {2} e {3}
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Project Start Date,Data di inizio del progetto
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +5,Until,Fino a
DocType: Rename Tool,Rename Log,Rinominare Entra
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +27,Student Group or Course Schedule is mandatory,Il gruppo studente o il corso è obbligatorio
DocType: HR Settings,Maintain Billing Hours and Working Hours Same on Timesheet,Ore fatturate e Ore lavorate allienate allo stesso Valore
DocType: Maintenance Visit Purpose,Against Document No,Per Documento N
DocType: BOM,Scrap,rottame
apps/erpnext/erpnext/utilities/user_progress.py +214,Go to Instructors,Vai agli istruttori
apps/erpnext/erpnext/config/selling.py +110,Manage Sales Partners.,Gestire punti vendita
DocType: Quality Inspection,Inspection Type,Tipo di ispezione
DocType: Fee Validity,Visited yet,Visitato ancora
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +135,Warehouses with existing transaction can not be converted to group.,Magazzini con transazione esistenti non possono essere convertiti in gruppo.
DocType: Assessment Result Tool,Result HTML,risultato HTML
apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +6,Memeber Activity,Attività memoriale
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +35,Expires On,Scade il
apps/erpnext/erpnext/utilities/activation.py +117,Add Students,Aggiungere studenti
apps/erpnext/erpnext/public/js/utils.js +264,Please select {0},Si prega di selezionare {0}
DocType: C-Form,C-Form No,C-Form N.
DocType: BOM,Exploded_items,Articoli_esplosi
apps/erpnext/erpnext/utilities/user_progress.py +136,List your products or services that you buy or sell.,Elenca i tuoi prodotti o servizi acquistati o venduti.
DocType: Water Analysis,Storage Temperature,Temperatura di conservazione
DocType: Employee Attendance Tool,Unmarked Attendance,Partecipazione non contrassegnata
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +137,Researcher,ricercatore
DocType: Program Enrollment Tool Student,Program Enrollment Tool Student,Programma Strumento di Iscrizione per studenti
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.py +16,Start date should be less than end date for task {0},La data di inizio dovrebbe essere inferiore alla data di fine per l&#39;attività {0}
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +25,Name or Email is mandatory,Nome o e-mail è obbligatorio
DocType: Purchase Order Item,Returned Qty,Tornati Quantità
DocType: Student,Exit,Esci
apps/erpnext/erpnext/accounts/doctype/account/account.py +158,Root Type is mandatory,Root Type è obbligatorio
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +29,Failed to install presets,Impossibile installare i preset
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +42,"{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.","{0} è attualmente in possesso di un {1} Scorecard del fornitore, e le richieste di autorizzazione a questo fornitore dovrebbero essere rilasciate con cautela."
DocType: Chapter,Non Profit Manager,Manager non profit
DocType: BOM,Total Cost(Company Currency),Costo totale (Società di valuta)
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +315,Serial No {0} created,Serial No {0} creato
DocType: Homepage,Company Description for website homepage,Descrizione della società per home page del sito
DocType: Item Customer Detail,"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Per la comodità dei clienti, questi codici possono essere utilizzati in formati di stampa, come fatture e Documenti di Trasporto"
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +18,Suplier Name,Nome suplier
apps/erpnext/erpnext/accounts/report/financial_statements.py +152,Could not retrieve information for {0}.,Impossibile recuperare le informazioni per {0}.
DocType: Sales Invoice,Time Sheet List,Lista schede attività
DocType: Employee,You can enter any date manually,È possibile immettere qualsiasi data manualmente
DocType: Healthcare Settings,Result Printed,Risultato Stampato
DocType: Asset Category Account,Depreciation Expense Account,Ammortamento spese account
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +231,Probationary Period,Periodo Di Prova
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +32,View {0},Visualizza {0}
DocType: Customer Group,Only leaf nodes are allowed in transaction,Solo i nodi foglia sono ammessi nelle transazioni
DocType: Project,Total Costing Amount (via Timesheets),Total Costing Amount (via Timesheets)
DocType: Employee Advance,Expense Approver,Responsabile Spese
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +134,Row {0}: Advance against Customer must be credit,Riga {0}: Advance contro il Cliente deve essere di credito
apps/erpnext/erpnext/accounts/doctype/account/account.js +89,Non-Group to Group,Non-gruppo a gruppo
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58,Batch is mandatory in row {0},Il gruppo è obbligatorio nella riga {0}
DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Ricevuta di Acquisto Articolo Fornito
DocType: Payment Entry,Pay,Paga
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,To Datetime,Per Data Ora
apps/erpnext/erpnext/config/selling.py +297,Logs for maintaining sms delivery status,I registri per il mantenimento dello stato di consegna sms
DocType: Accounts Settings,Make Payment via Journal Entry,Effettua il pagamento tramite Registrazione Contabile
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +97,Printed On,Stampato su
DocType: Item,Inspection Required before Delivery,Ispezione richiesta prima della consegna
DocType: Item,Inspection Required before Purchase,Ispezione Richiesto prima di Acquisto
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +93,Pending Activities,Attività in sospeso
DocType: Patient Appointment,Reminded,ricordato
DocType: Patient,PID-,PId-
DocType: Chapter Member,Chapter Member,Membro del Capitolo
apps/erpnext/erpnext/public/js/setup_wizard.js +106,Your Organization,La tua organizzazione
DocType: Fee Component,Fees Category,tasse Categoria
apps/erpnext/erpnext/hr/doctype/employee/employee.py +134,Please enter relieving date.,Inserisci la data alleviare .
apps/erpnext/erpnext/controllers/trends.py +149,Amt,Amt
DocType: Supplier Scorecard,Notify Employee,Notifica dipendente
DocType: Opportunity,Enter name of campaign if source of enquiry is campaign,Inserisci il nome della Campagna se la sorgente di indagine è la campagna
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +38,Newspaper Publishers,Editori Giornali
apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +30,Select Fiscal Year,Selezionare l'anno fiscale
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +115,Expected Delivery Date should be after Sales Order Date,La data di consegna prevista dovrebbe essere dopo la data di ordine di vendita
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +43,Reorder Level,Riordina Level
DocType: Company,Chart Of Accounts Template,Modello del Piano dei Conti
DocType: Attendance,Attendance Date,Data Presenza
apps/erpnext/erpnext/stock/get_item_details.py +345,Item Price updated for {0} in Price List {1},Prezzo Articolo aggiornato per {0} nel Listino {1}
DocType: Salary Structure,Salary breakup based on Earning and Deduction.,Stipendio rottura basato sul guadagno e di deduzione.
apps/erpnext/erpnext/accounts/doctype/account/account.py +130,Account with child nodes cannot be converted to ledger,Account con nodi figlio non può essere convertito in libro mastro
DocType: Purchase Invoice Item,Accepted Warehouse,Magazzino accettazione
DocType: Bank Reconciliation Detail,Posting Date,Data di Registrazione
DocType: Item,Valuation Method,Metodo di Valorizzazione
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +203,Mark Half Day,Segna come Mezza giornata
DocType: Sales Invoice,Sales Team,Team di vendita
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +85,Duplicate entry,Duplicate entry
DocType: Program Enrollment Tool,Get Students,ottenere gli studenti
DocType: Serial No,Under Warranty,In Garanzia
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +515,[Error],[Errore]
DocType: Sales Order,In Words will be visible once you save the Sales Order.,In parole saranno visibili una volta che si salva l&#39;ordine di vendita.
,Employee Birthday,Compleanno Dipendente
apps/erpnext/erpnext/assets/doctype/asset_repair/asset_repair.py +14,Please select Completion Date for Completed Repair,Selezionare la data di completamento per la riparazione completata
DocType: Student Batch Attendance Tool,Student Batch Attendance Tool,Studente Batch presenze Strumento
apps/erpnext/erpnext/controllers/status_updater.py +210,Limit Crossed,limite Crossed
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js +22,Scheduled Upto,Pianificato Upto
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +55,Venture Capital,capitale a rischio
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +40,An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,Un termine accademico con questo &#39;Anno Accademico&#39; {0} e &#39;Term Nome&#39; {1} esiste già. Si prega di modificare queste voci e riprovare.
DocType: UOM,Must be Whole Number,Deve essere un Numero Intero
DocType: Leave Control Panel,New Leaves Allocated (In Days),Nuove ferie attribuiti (in giorni)
DocType: Purchase Invoice,Invoice Copy,Copia fattura
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +49,Serial No {0} does not exist,Serial No {0} non esiste
DocType: Sales Invoice Item,Customer Warehouse (Optional),Deposito Cliente (opzionale)
DocType: Pricing Rule,Discount Percentage,Percentuale di sconto
DocType: Payment Reconciliation Invoice,Invoice Number,Numero Fattura
DocType: Shopping Cart Settings,Orders,Ordini
DocType: Employee Leave Approver,Leave Approver,Responsabile Ferie
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +285,Please select a batch,Seleziona un batch
DocType: Assessment Group,Assessment Group Name,Nome gruppo di valutazione
DocType: Manufacturing Settings,Material Transferred for Manufacture,Materiale trasferito per Produzione
DocType: Expense Claim,"A user with ""Expense Approver"" role","Un utente con ruolo di ""Responsabile Spese"""
DocType: Landed Cost Item,Receipt Document Type,Ricevuta tipo di documento
DocType: Daily Work Summary Settings,Select Companies,selezionare le imprese
,Issued Items Against Production Order,Articoli emesso contro Ordine di produzione
DocType: Antibiotic,Healthcare,Assistenza sanitaria
DocType: Target Detail,Target Detail,Obiettivo Particolare
apps/erpnext/erpnext/stock/doctype/item/item.js +65,Single Variant,Variante singola
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +24,All Jobs,tutti i lavori
DocType: Sales Order,% of materials billed against this Sales Order,% dei materiali fatturati su questo Ordine di Vendita
DocType: Program Enrollment,Mode of Transportation,Modo di trasporto
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +49,Period Closing Entry,Entrata Periodo di chiusura
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +75,Select Department...,Seleziona Dipartimento ...
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +38,Cost Center with existing transactions can not be converted to group,Centro di costo con le transazioni esistenti non può essere convertito in gruppo
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +361,Amount {0} {1} {2} {3},Importo {0} {1} {2} {3}
DocType: Account,Depreciation,ammortamento
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +49,Supplier(s),Fornitore(i)
DocType: Employee Attendance Tool,Employee Attendance Tool,Impiegato presenze Strumento
DocType: Guardian Student,Guardian Student,Guardiano Student
DocType: Supplier,Credit Limit,Limite Credito
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70,Avg. Selling Price List Rate,Avg. Tasso di listino prezzi di vendita
DocType: Production Plan Sales Order,Salse Order Date,Salse Data ordine
DocType: Salary Component,Salary Component,stipendio Componente
apps/erpnext/erpnext/accounts/utils.py +492,Payment Entries {0} are un-linked,Le voci di pagamento {0} sono non-linked
DocType: GL Entry,Voucher No,Voucher No
,Lead Owner Efficiency,Efficienza del proprietario del cavo
apps/erpnext/erpnext/hub_node/page/hub/hub.js +195,Most Popular,Più popolare
DocType: Leave Allocation,Leave Allocation,Lascia Allocazione
DocType: Payment Request,Recipient Message And Payment Details,Destinatario del Messaggio e Modalità di Pagamento
DocType: Training Event,Trainer Email,Trainer-mail
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +548,Material Requests {0} created,Richieste di materiale {0} creato
DocType: Restaurant Reservation,No of People,No di persone
DocType: Production Planning Tool,Include sub-contracted raw materials,Includere le materie prime in subappalto
apps/erpnext/erpnext/config/selling.py +164,Template of terms or contract.,Template di termini o di contratto.
DocType: Purchase Invoice,Address and Contact,Indirizzo e contatto
DocType: Cheque Print Template,Is Account Payable,E' un Conto Fornitore
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +276,Stock cannot be updated against Purchase Receipt {0},Stock non può essere aggiornato nei confronti di acquisto ricevuta {0}
DocType: Company,Last Day of the Next Month,Ultimo giorno del mese prossimo
DocType: Support Settings,Auto close Issue after 7 days,Chiudi la controversia automaticamente dopo 7 giorni
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}","Ferie non possono essere assegnati prima {0}, come equilibrio congedo è già stato inoltrato carry-in futuro record di assegnazione congedo {1}"
apps/erpnext/erpnext/accounts/party.py +320,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Nota: La data scadenza / riferimento supera i giorni ammessi per il credito dei clienti da {0} giorno (i)
apps/erpnext/erpnext/education/doctype/program/program.js +8,Student Applicant,Student Richiedente
DocType: Purchase Invoice,ORIGINAL FOR RECIPIENT,ORIGINALE PER IL RECIPIENTE
DocType: Asset Category Account,Accumulated Depreciation Account,Conto per il fondo ammortamento
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +11,This email is autogenerated,Questa email è autogenerata
DocType: Stock Settings,Freeze Stock Entries,Congela scorta voci
DocType: Program Enrollment,Boarding Student,Studente di imbarco
DocType: Asset,Expected Value After Useful Life,Valore atteso After Life utile
DocType: Item,Reorder level based on Warehouse,Livello di riordino sulla base di Magazzino
DocType: Activity Cost,Billing Rate,Fatturazione Tasso
,Qty to Deliver,Qtà di Consegna
,Stock Analytics,Analytics Archivio
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +508,Operations cannot be left blank,Le operazioni non possono essere lasciati in bianco
DocType: Maintenance Visit Purpose,Against Document Detail No,Per Dettagli Documento N
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +99,Party Type is mandatory,Tipo Partner è obbligatorio
DocType: Quality Inspection,Outgoing,In partenza
DocType: Material Request,Requested For,richiesto Per
DocType: Quotation Item,Against Doctype,Per Doctype
apps/erpnext/erpnext/controllers/buying_controller.py +396,{0} {1} is cancelled or closed,{0} {1} è stato chiuso o eliminato
DocType: Asset,Calculate Depreciation,Calcola l&#39;Ammortamento
DocType: Delivery Note,Track this Delivery Note against any Project,Sottoscrivi questa bolla di consegna contro ogni progetto
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +30,Net Cash from Investing,Di cassa netto da investimenti
DocType: Production Order,Work-in-Progress Warehouse,Magazzino Lavori in corso
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +111,Asset {0} must be submitted,Asset {0} deve essere presentata
DocType: Fee Schedule Program,Total Students,Totale studenti
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +56,Attendance Record {0} exists against Student {1},Record di presenze {0} esiste contro Student {1}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +352,Reference #{0} dated {1},Riferimento # {0} datato {1}
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +164,Depreciation Eliminated due to disposal of assets,Gli ammortamenti Eliminato causa della cessione di attività
DocType: Member,Member,Membro
apps/erpnext/erpnext/templates/includes/cart/cart_address.html +15,Manage Addresses,Gestire indirizzi
DocType: Pricing Rule,Item Code,Codice Articolo
DocType: Production Planning Tool,Create Production Orders,Crea Ordine Prodotto
DocType: Serial No,Warranty / AMC Details,Garanzia / AMC Dettagli
apps/erpnext/erpnext/education/doctype/student_group/student_group.js +116,Select students manually for the Activity based Group,Selezionare manualmente gli studenti per il gruppo basato sulle attività
DocType: Journal Entry,User Remark,Osservazioni dell'utente
DocType: Lead,Market Segment,Segmento di Mercato
DocType: Crop,Agriculture Manager,Responsabile Agricoltura
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +950,Paid Amount cannot be greater than total negative outstanding amount {0},L'Importo versato non può essere maggiore del totale importo dovuto negativo {0}
DocType: Supplier Scorecard Period,Variables,variabili
DocType: Employee Internal Work History,Employee Internal Work History,Storia lavorativa Interna del Dipendente
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +246,Closing (Dr),Chiusura (Dr)
DocType: Cheque Print Template,Cheque Size,Dimensione Assegno
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +232,Serial No {0} not in stock,Serial No {0} non in magazzino
apps/erpnext/erpnext/config/selling.py +169,Tax template for selling transactions.,Modelli fiscali per le transazioni di vendita.
DocType: Sales Invoice,Write Off Outstanding Amount,Importo di svalutazione in sospeso
apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py +27,Account {0} does not match with Company {1},L&#39;account {0} non corrisponde con l&#39;azienda {1}
DocType: Education Settings,Current Academic Year,Anno Accademico Corrente
DocType: Stock Settings,Default Stock UOM,UdM predefinita per Giacenza
DocType: Asset,Number of Depreciations Booked,Numero di ammortamenti Prenotato
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +32,Against Employee Loan: {0},Contro prestito dipendenti: {0}
DocType: Landed Cost Item,Receipt Document,Documento di Ricevuta
DocType: Production Planning Tool,Create Material Requests,Creare Richieste Materiale
DocType: Employee Education,School/University,Scuola / Università
DocType: Payment Request,Reference Details,Riferimento Dettagli
apps/erpnext/erpnext/assets/doctype/asset/asset.py +59,Expected Value After Useful Life must be less than Gross Purchase Amount,Il valore atteso dopo la durata utile deve essere inferiore all' importo di acquisto lordo
DocType: Sales Invoice Item,Available Qty at Warehouse,Quantità Disponibile a magazzino
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Billed Amount,Importo Fatturato
DocType: Asset,Double Declining Balance,Doppia valori residui
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +180,Closed order cannot be cancelled. Unclose to cancel.,ordine chiuso non può essere cancellato. Unclose per annullare.
DocType: Student Guardian,Father,Padre
apps/erpnext/erpnext/controllers/accounts_controller.py +606,'Update Stock' cannot be checked for fixed asset sale,&#39;Aggiornamento della&#39; non può essere controllato per vendita asset fissi
DocType: Bank Reconciliation,Bank Reconciliation,Conciliazione Banca
DocType: Attendance,On Leave,In ferie
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +7,Get Updates,Ricevi aggiornamenti
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +96,{0} {1}: Account {2} does not belong to Company {3},{0} {1}: Il conto {2} non appartiene alla società {3}
apps/erpnext/erpnext/stock/doctype/item/item.js +366,Select at least one value from each of the attributes.,Seleziona almeno un valore da ciascuno degli attributi.
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +156,Material Request {0} is cancelled or stopped,Richiesta materiale {0} è stato annullato o interrotto
apps/erpnext/erpnext/config/hr.py +310,Leave Management,Lascia Gestione
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +106,Group by Account,Raggruppa per Conto
DocType: Sales Order,Fully Delivered,Completamente Consegnato
DocType: Lead,Lower Income,Reddito più basso
DocType: Restaurant Order Entry,Current Order,Ordine attuale
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +174,Source and target warehouse cannot be same for row {0},Magazzino di origine e di destinazione non possono essere uguali per rigo {0}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +241,"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry","Account La differenza deve essere un account di tipo attività / passività, dal momento che questo Stock riconciliazione è una voce di apertura"
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +107,Disbursed Amount cannot be greater than Loan Amount {0},Importo erogato non può essere superiore a prestito Importo {0}
apps/erpnext/erpnext/utilities/user_progress.py +173,Go to Programs,Vai a Programmi
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +219,Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2},Riga {0} # L&#39;importo assegnato {1} non può essere maggiore dell&#39;importo non reclamato {2}
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +89,Purchase Order number required for Item {0},Numero ordine di acquisto richiesto per la voce {0}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +943,Production Order not created,Ordine di produzione non ha creato
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +18,'From Date' must be after 'To Date',' Dalla Data' deve essere successivo a 'Alla Data'
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +39,Cannot change status as student {0} is linked with student application {1},Impossibile cambiare status di studente {0} è collegata con l&#39;applicazione studente {1}
DocType: Asset,Fully Depreciated,completamente ammortizzato
,Stock Projected Qty,Qtà Prevista Giacenza
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +438,Customer {0} does not belong to project {1},Cliente {0} non appartiene a proiettare {1}
DocType: Employee Attendance Tool,Marked Attendance HTML,Marcata presenze HTML
apps/erpnext/erpnext/utilities/activation.py +73,"Quotations are proposals, bids you have sent to your customers","Le quotazioni sono proposte, offerte che hai inviato ai tuoi clienti"
DocType: Sales Order,Customer's Purchase Order,Ordine di Acquisto del Cliente
DocType: Consultation,Patient,Paziente
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +47,Bypass credit check at Sales Order ,Bypassare il controllo del credito in ordine cliente
DocType: Land Unit,Check if it is a hydroponic unit,Controlla se è un&#39;unità idroponica
apps/erpnext/erpnext/config/stock.py +109,Serial No and Batch,N. di serie e batch
DocType: Warranty Claim,From Company,Da Azienda
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +40,Sum of Scores of Assessment Criteria needs to be {0}.,Somma dei punteggi di criteri di valutazione deve essere {0}.
apps/erpnext/erpnext/assets/doctype/asset/asset.py +77,Please set Number of Depreciations Booked,Si prega di impostare Numero di ammortamenti Prenotato
DocType: Supplier Scorecard Period,Calculations,calcoli
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +89,Value or Qty,Valore o Quantità
DocType: Payment Terms Template,Payment Terms,Termini di pagamento
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +426,Productions Orders cannot be raised for:,Produzioni ordini non possono essere sollevati per:
apps/erpnext/erpnext/utilities/user_progress.py +144,Minute,Minuto
DocType: Purchase Invoice,Purchase Taxes and Charges,Acquisto Tasse e Costi
DocType: Chapter,Meetup Embed HTML,Meetup Incorpora HTML
apps/erpnext/erpnext/utilities/user_progress.py +118,Go to Suppliers,Vai a Fornitori
,Qty to Receive,Qtà da Ricevere
DocType: Leave Block List,Leave Block List Allowed,Lascia Block List ammessi
DocType: Grading Scale Interval,Grading Scale Interval,Grading Scale Intervallo
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +49,Expense Claim for Vehicle Log {0},Rimborso spese per veicolo Log {0}
DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,Sconto (%) sul prezzo di listino con margine
apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py +59,All Warehouses,Tutti i Depositi
DocType: Sales Partner,Retailer,Dettagliante
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +115,Credit To account must be a Balance Sheet account,Credito Per account deve essere un account di Stato Patrimoniale
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +122,All Supplier Types,Tutti i tipi di fornitori
DocType: Donor,Donor,Donatore
DocType: Global Defaults,Disable In Words,Disattiva in parole
apps/erpnext/erpnext/stock/doctype/item/item.py +49,Item Code is mandatory because Item is not automatically numbered,Codice Articolo è obbligatoria in quanto articolo non è numerato automaticamente
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +98,Quotation {0} not of type {1},Preventivo {0} non di tipo {1}
DocType: Maintenance Schedule Item,Maintenance Schedule Item,Voce del Programma di manutenzione
DocType: Sales Order,%  Delivered,%  Consegnato
apps/erpnext/erpnext/education/doctype/fees/fees.js +105,Please set the Email ID for the Student to send the Payment Request,Impostare l&#39;ID di posta elettronica per lo studente per inviare la richiesta di pagamento
DocType: Production Order,PRO-,PRO-
DocType: Patient,Medical History,Storia medica
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +157,Bank Overdraft Account,Conto di scoperto bancario
DocType: Patient,Patient ID,ID paziente
DocType: Physician Schedule,Schedule Name,Nome Schedule
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +48,Make Salary Slip,Crea Busta paga
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +838,Add All Suppliers,Aggiungi tutti i fornitori
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +83,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Riga # {0}: L'Importo assegnato non può essere superiore all'importo dovuto.
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +75,Browse BOM,Sfoglia BOM
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +155,Secured Loans,Prestiti garantiti
DocType: Purchase Invoice,Edit Posting Date and Time,Modifica data e ora di registrazione
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +101,Please set Depreciation related Accounts in Asset Category {0} or Company {1},Si prega di impostare gli account relativi ammortamenti nel settore Asset Categoria {0} o {1} società
DocType: Lab Test Groups,Normal Range,Intervallo normale
DocType: Academic Term,Academic Year,Anno accademico
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72,Available Selling,Vendita disponibile
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +169,Opening Balance Equity,Apertura Balance Equità
DocType: Lead,CRM,CRM
DocType: Purchase Invoice,N,N
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +175,Remaining,Disponibile
DocType: Appraisal,Appraisal,Valutazione
DocType: Purchase Invoice,GST Details,Dettagli GST
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +154,Email sent to supplier {0},E-mail inviata al fornitore {0}
DocType: Item,Default Sales Unit of Measure,Unità di vendita predefinita di misura
DocType: Opportunity,OPTY-,OPTY-
apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py +19,Date is repeated,La Data si Ripete
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +27,Authorized Signatory,Firma autorizzata
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +215,Leave approver must be one of {0},Il responsabile ferie deve essere uno fra {0}
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +67,Create Fees,Crea tariffe
DocType: Project,Total Purchase Cost (via Purchase Invoice),Costo totale di acquisto (tramite acquisto fattura)
DocType: Training Event,Start Time,Ora di inizio
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +399,Select Quantity,Seleziona Quantità
DocType: Customs Tariff Number,Customs Tariff Number,Numero della tariffa doganale
DocType: Patient Appointment,Patient Appointment,Appuntamento paziente
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +34,Approving Role cannot be same as role the rule is Applicable To,Approvazione ruolo non può essere lo stesso ruolo la regola è applicabile ad
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +64,Unsubscribe from this Email Digest,Disiscriviti da questo Email Digest
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +828,Get Suppliers By,Ottenere fornitori di
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +170,{0} not found for Item {1},{0} non trovato per l&#39;articolo {1}
apps/erpnext/erpnext/utilities/user_progress.py +194,Go to Courses,Vai ai corsi
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +28,Message Sent,Messaggio Inviato
apps/erpnext/erpnext/accounts/doctype/account/account.py +100,Account with child nodes cannot be set as ledger,Il conto con nodi figli non può essere impostato come libro mastro
DocType: C-Form,II,II
DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Tasso al quale Listino valuta viene convertita in valuta di base del cliente
DocType: Purchase Invoice Item,Net Amount (Company Currency),Importo netto (Valuta Azienda)
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +229,Total advance amount cannot be greater than total sanctioned amount,L&#39;importo totale anticipato non può essere maggiore dell&#39;importo sanzionato totale
DocType: Salary Slip,Hour Rate,Rapporto Orario
DocType: Stock Settings,Item Naming By,Creare il Nome Articolo da
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +46,Another Period Closing Entry {0} has been made after {1},Un'altra voce periodo di chiusura {0} è stato fatto dopo {1}
DocType: Production Order,Material Transferred for Manufacturing,Materiale trasferito per produzione
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +32,Account {0} does not exists,Il Conto {0} non esiste
DocType: Project,Project Type,Tipo di progetto
apps/erpnext/erpnext/projects/doctype/task/task.py +142,Child Task exists for this Task. You can not delete this Task.,Non è possibile eliminare questa attività; esiste un'altra Attività dipendente da questa.
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +16,Either target qty or target amount is mandatory.,Sia qty destinazione o importo obiettivo è obbligatoria .
apps/erpnext/erpnext/hub_node/page/hub/hub.js +731,No more results,Nessun altro risultato
apps/erpnext/erpnext/config/projects.py +51,Cost of various activities,Costo di varie attività
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +60,"Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}","Impostazione Eventi a {0}, in quanto il dipendente attaccato al di sotto personale di vendita non dispone di un ID utente {1}"
DocType: Timesheet,Billing Details,Dettagli di fatturazione
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +155,Source and target warehouse must be different,Magazzino di Origine e di Destinazione devono essere diversi
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +101,Not allowed to update stock transactions older than {0},Non è permesso di aggiornare i documenti di magazzino di età superiore a {0}
DocType: Purchase Invoice Item,PR Detail,PR Dettaglio
DocType: Driving License Category,Class,Classe
DocType: Sales Order,Fully Billed,Completamente Fatturato
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +101,Shipping rule only applicable for Buying,Regola di spedizione applicabile solo per l&#39;acquisto
DocType: Vital Signs,BMI,BMI
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +20,Cash In Hand,Cash In Hand
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +137,Delivery warehouse required for stock item {0},Deposito di consegna richiesto per l'articolo {0}
DocType: Packing Slip,The gross weight of the package. Usually net weight + packaging material weight. (for print),Il peso lordo del pacchetto. Di solito peso netto + peso materiale di imballaggio. (Per la stampa)
apps/erpnext/erpnext/education/doctype/course/course.js +3,Program,Programma
DocType: Accounts Settings,Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Gli utenti con questo ruolo sono autorizzati a impostare conti congelati e creare / modificare le voci contabili nei confronti di conti congelati
DocType: Serial No,Is Cancelled,È Annullato
DocType: Student Group,Group Based On,Gruppo basato
DocType: Journal Entry,Bill Date,Data Fattura
DocType: Healthcare Settings,Laboratory SMS Alerts,Laboratorio SMS Avvisi
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +20,"Service Item,Type,frequency and expense amount are required","Servizio Voce, tipo, la frequenza e la quantità spesa sono necessari"
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +45,"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","Anche se ci sono più regole sui prezzi con la priorità più alta, si applicano quindi le seguenti priorità interne:"
DocType: Plant Analysis Criteria,Plant Analysis Criteria,Criteri di analisi delle piante
DocType: Cheque Print Template,Cheque Height,Altezza Assegno
DocType: Supplier,Supplier Details,Dettagli del Fornitore
DocType: Setup Progress,Setup Progress,Avanzamento configurazione
DocType: Expense Claim,Approval Status,Stato Approvazione
DocType: Hub Settings,Publish Items to Hub,Pubblicare Articoli al Hub
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +35,From value must be less than to value in row {0},Dal valore deve essere inferiore al valore nella riga {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +182,Wire Transfer,Bonifico bancario
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +92,Check all,Seleziona tutto
DocType: Vehicle Log,Invoice Ref,fattura Rif
DocType: Company,Default Income Account,Conto predefinito Entrate
apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +32,Customer Group / Customer,Gruppi clienti / clienti
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +37,Unclosed Fiscal Years Profit / Loss (Credit),Anni fiscali non chiusi - Utile/Perdita (credito)
DocType: Sales Invoice,Time Sheets,Schede attività
DocType: Lab Test Template,Change In Item,Modifica nell&#39;articolo
DocType: Payment Gateway Account,Default Payment Request Message,Predefinito Richiesta Pagamento Messaggio
DocType: Item Group,Check this if you want to show in website,Seleziona se vuoi mostrare nel sito web
apps/erpnext/erpnext/config/accounts.py +134,Banking and Payments,Banche e Pagamenti
,Welcome to ERPNext,Benvenuti a ERPNext
apps/erpnext/erpnext/config/learn.py +102,Lead to Quotation,Lead a Preventivo
DocType: Patient,A Negative,Un Negativo
apps/erpnext/erpnext/templates/includes/product_list.js +45,Nothing more to show.,Niente di più da mostrare.
DocType: Lead,From Customer,Da Cliente
apps/erpnext/erpnext/demo/setup/setup_data.py +327,Calls,chiamate
apps/erpnext/erpnext/utilities/user_progress.py +140,A Product,Un prodotto
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +207,Batches,lotti
apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js +34,Make Fee Schedule,Effettuare la programmazione dei costi
DocType: Purchase Order Item Supplied,Stock UOM,UdM Giacenza
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +233,Purchase Order {0} is not submitted,L'ordine di Acquisto {0} non è stato presentato
DocType: Vital Signs,Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),L&#39;intervallo di riferimento normale per un adulto è 16-20 breaths / min (RCP 2012)
DocType: Customs Tariff Number,Tariff Number,Numero tariffario
DocType: Production Order Item,Available Qty at WIP Warehouse,Quantità disponibile presso WIP Warehouse
apps/erpnext/erpnext/stock/doctype/item/item.js +39,Projected,proiettata
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +222,Serial No {0} does not belong to Warehouse {1},Serial No {0} non appartiene al Warehouse {1}
apps/erpnext/erpnext/controllers/status_updater.py +174,Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,Nota : Il sistema non controlla over - consegna e over -booking per la voce {0} come la quantità o la quantità è 0
DocType: Notification Control,Quotation Message,Messaggio Preventivo
DocType: Employee Loan,Employee Loan Application,Impiegato Loan Application
DocType: Issue,Opening Date,Data di apertura
apps/erpnext/erpnext/education/api.py +80,Attendance has been marked successfully.,La partecipazione è stata segnata con successo.
DocType: Program Enrollment,Public Transport,Trasporto pubblico
DocType: Soil Texture,Silt Composition (%),Composizione di silt (%)
DocType: Journal Entry,Remark,Osservazione
DocType: Healthcare Settings,Avoid Confirmation,Evita la conferma
DocType: Purchase Receipt Item,Rate and Amount,Prezzo e Importo
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +165,Account Type for {0} must be {1},Tipo di account per {0} deve essere {1}
DocType: Healthcare Settings,Default income accounts to be used if not set in Physician to book Consultation charges.,Utilizzare i conti di reddito di default se non è impostato in Medico per prenotare le spese di consultazione.
apps/erpnext/erpnext/config/hr.py +55,Leaves and Holiday,Ferie e vacanze
DocType: Education Settings,Current Academic Term,Termine accademico attuale
DocType: Sales Order,Not Billed,Non Fatturata
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +77,Both Warehouse must belong to same Company,Entrambi i magazzini devono appartenere alla stessa società
apps/erpnext/erpnext/public/js/templates/contact_list.html +34,No contacts added yet.,Nessun contatto ancora aggiunto.
DocType: Purchase Invoice Item,Landed Cost Voucher Amount,Landed Cost Voucher Importo
apps/erpnext/erpnext/config/accounts.py +17,Bills raised by Suppliers.,Fatture emesse dai fornitori.
DocType: POS Profile,Write Off Account,Conto per Svalutazioni
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +89,Debit Note Amt,Debito Nota Amt
apps/erpnext/erpnext/templates/print_formats/includes/taxes.html +5,Discount Amount,Importo sconto
DocType: Purchase Invoice,Return Against Purchase Invoice,Ritorno Contro Acquisto Fattura
DocType: Item,Warranty Period (in days),Periodo di garanzia (in giorni)
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +61,Failed to set defaults,Impossibile impostare i valori predefiniti
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +56,Relation with Guardian1,Rapporto con Guardian1
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +797,Please select BOM against item {0},Seleziona la BOM rispetto all&#39;articolo {0}
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +18,Make Invoices,Fai fatture
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +18,Net Cash from Operations,Cassa netto da attività
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +26,Item 4,Articolo 4
DocType: Student Admission,Admission End Date,L&#39;ammissione Data fine
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py +30,Sub-contracting,Subappalto
DocType: Journal Entry Account,Journal Entry Account,Addebito Journal
apps/erpnext/erpnext/education/doctype/academic_year/academic_year.js +3,Student Group,Gruppo Student
DocType: Shopping Cart Settings,Quotation Series,Serie Preventivi
apps/erpnext/erpnext/setup/doctype/item_group/item_group.py +56,"An item exists with same name ({0}), please change the item group name or rename the item","Un elemento esiste con lo stesso nome ( {0} ) , si prega di cambiare il nome del gruppo o di rinominare la voce"
DocType: Soil Analysis Criteria,Soil Analysis Criteria,Criteri di analisi del suolo
apps/erpnext/erpnext/accounts/page/pos/pos.js +2020,Please select customer,Seleziona cliente
DocType: C-Form,I,io
DocType: Company,Asset Depreciation Cost Center,Asset Centro di ammortamento dei costi
DocType: Sales Order Item,Sales Order Date,Ordine di vendita Data
DocType: Sales Invoice Item,Delivered Qty,Q.tà Consegnata
DocType: Production Planning Tool,"If checked, all the children of each production item will be included in the Material Requests.","Se selezionato, tutti i figli di ogni elemento di produzione saranno inclusi nelle Request materiali."
DocType: Assessment Plan,Assessment Plan,Piano di valutazione
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +93,Customer {0} is created.,Il cliente {0} viene creato.
DocType: Stock Settings,Limit Percent,limite percentuale
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +82, Currently no stock available in any warehouse,Articolo attualmente non presente in nessun magazzino
,Payment Period Based On Invoice Date,Periodo di pagamento basati su Data fattura
DocType: Sample Collection,No. of print,Numero di stampa
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +58,Missing Currency Exchange Rates for {0},Manca valuta Tassi di cambio in {0}
DocType: Assessment Plan,Examiner,Esaminatore
DocType: Student,Siblings,fratelli
DocType: Journal Entry,Stock Entry,Movimento di magazzino
DocType: Payment Entry,Payment References,Riferimenti di pagamento
DocType: C-Form,C-FORM-,C-form-
DocType: Vehicle,Insurance Details,Dettagli Assicurazione
DocType: Account,Payable,Pagabile
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +113,Please enter Repayment Periods,Si prega di inserire periodi di rimborso
apps/erpnext/erpnext/shopping_cart/cart.py +376,Debtors ({0}),Debitori ({0})
DocType: Pricing Rule,Margin,Margine
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57,New Customers,Nuovi clienti
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +75,Gross Profit %,Utile lordo %
DocType: Appraisal Goal,Weightage (%),Weightage (%)
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +489,Change POS Profile,Cambia profilo POS
DocType: Bank Reconciliation Detail,Clearance Date,Data Liquidazione
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +7,Assessment Report,Rapporto di valutazione
apps/erpnext/erpnext/assets/doctype/asset/asset.py +62,Gross Purchase Amount is mandatory,Gross Importo acquisto è obbligatoria
DocType: Lead,Address Desc,Desc. indirizzo
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +102,Party is mandatory,Il Partner è obbligatorio
DocType: Journal Entry,JV-,JV-
apps/erpnext/erpnext/controllers/accounts_controller.py +687,Rows with duplicate due dates in other rows were found: {list},Sono state trovate righe con date di scadenza duplicate in altre righe: {lista}
DocType: Topic,Topic Name,Nome argomento
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +36,Atleast one of the Selling or Buying must be selected,", Almeno una delle vendere o acquistare deve essere selezionata"
apps/erpnext/erpnext/public/js/setup_wizard.js +36,Select the nature of your business.,Selezionare la natura della vostra attività.
DocType: Lab Test Template,"Single for results which require only a single input, result UOM and normal value 
<br>
Compound for results which require multiple input fields with corresponding event names, result UOMs and normal values
<br>
Descriptive for tests which have multiple result components and corresponding result entry fields. 
<br>
Grouped for test templates which are a group of other test templates.
<br>
No Result for tests with no results. Also, no Lab Test is created. e.g.. Sub Tests for Grouped results.","Singolo per i risultati che richiedono solo un singolo ingresso, risultato UOM e valore normale <br> Compound per risultati che richiedono più campi di input con nomi di eventi corrispondenti, risultati UOM e valori normali <br> Descrittivo per test che dispongono di più componenti di risultato e campi di inserimento dei risultati corrispondenti. <br> Raggruppati per i modelli di prova che sono un gruppo di altri modelli di test. <br> Nessun risultato per test senza risultati. Inoltre, non viene creato alcun test di laboratorio. per esempio. Sub test per risultati raggruppati."
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +75,Row #{0}: Duplicate entry in References {1} {2},Riga # {0}: duplica la voce nei riferimenti {1} {2}
apps/erpnext/erpnext/config/manufacturing.py +57,Where manufacturing operations are carried.,Dove si svolgono le operazioni di fabbricazione.
DocType: Asset Movement,Source Warehouse,Magazzino di provenienza
DocType: Installation Note,Installation Date,Data di installazione
apps/erpnext/erpnext/controllers/accounts_controller.py +585,Row #{0}: Asset {1} does not belong to company {2},Row # {0}: Asset {1} non appartiene alla società {2}
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +206,Sales Invoice {0} created,La fattura di vendita {0} è stata creata
DocType: Employee,Confirmation Date,conferma Data
DocType: C-Form,Total Invoiced Amount,Importo Totale Fatturato
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +49,Min Qty can not be greater than Max Qty,La quantità Min non può essere maggiore della quantità Max
DocType: Soil Texture,Silty Clay,Silty Clay
DocType: Account,Accumulated Depreciation,Fondo di ammortamento
DocType: Supplier Scorecard Scoring Standing,Standing Name,Nome permanente
DocType: Stock Entry,Customer or Supplier Details,Dettagli Cliente o Fornitore
DocType: Employee Loan Application,Required by Date,Richiesto per data
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +222,Closing Balance (Dr - Cr),Saldo finale (Dr - Cr)
DocType: Lead,Lead Owner,Responsabile Lead
DocType: Bin,Requested Quantity,la quantita &#39;richiesta
DocType: Patient,Marital Status,Stato civile
DocType: Stock Settings,Auto Material Request,Richiesta Automatica Materiale
DocType: Delivery Note Item,Available Batch Qty at From Warehouse,Disponibile Quantità batch a partire Warehouse
DocType: Customer,CUST-,CUST-
DocType: Salary Slip,Gross Pay - Total Deduction - Loan Repayment,Pay Gross - Deduzione totale - Rimborso prestito
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +26,Current BOM and New BOM can not be same,BOM corrente e New BOM non può essere lo stesso
apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +45,Salary Slip ID,Stipendio slittamento ID
apps/erpnext/erpnext/hr/doctype/employee/employee.py +118,Date Of Retirement must be greater than Date of Joining,La Data di pensionamento deve essere successiva alla Data Assunzione
apps/erpnext/erpnext/stock/doctype/item/item.js +68,Multiple Variants,Varianti multiple
DocType: Sales Invoice,Against Income Account,Per Reddito Conto
apps/erpnext/erpnext/controllers/website_list_for_contact.py +117,{0}% Delivered,{0}% Consegnato
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +96,Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Articolo {0}: Qtà ordinata {1} non può essere inferiore a Qtà minima per ordine {2} (definita per l'Articolo).
DocType: Monthly Distribution Percentage,Monthly Distribution Percentage,Percentuale Distribuzione Mensile
apps/erpnext/erpnext/hub_node/page/hub/hub.js +90,Please login as another user.,Accedi come un altro utente.
DocType: Territory,Territory Targets,Obiettivi Territorio
DocType: Soil Analysis,Ca/Mg,Ca / Mg
DocType: Delivery Note,Transporter Info,Info Transporter
apps/erpnext/erpnext/accounts/utils.py +499,Please set default {0} in Company {1},Si prega di impostare di default {0} nell&#39;azienda {1}
DocType: Cheque Print Template,Starting position from top edge,posizione dal bordo superiore Avvio
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +31,Same supplier has been entered multiple times,Lo Stesso fornitore è stato inserito più volte
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py +152,Gross Profit / Loss,Utile lordo / Perdita
DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Articolo dell'Ordine di Acquisto Fornito
apps/erpnext/erpnext/public/js/setup_wizard.js +94,Company Name cannot be Company,Nome azienda non può essere azienda
apps/erpnext/erpnext/config/setup.py +27,Letter Heads for print templates.,Lettera intestazioni per modelli di stampa .
apps/erpnext/erpnext/config/setup.py +32,Titles for print templates e.g. Proforma Invoice.,Titoli di modelli di stampa p. es. Fattura proforma
DocType: Program Enrollment,Walking,A passeggio
DocType: Student Guardian,Student Guardian,Student Guardiano
DocType: Member,Member Name,Nome del membro
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +218,Valuation type charges can not marked as Inclusive,Spese tipo di valutazione non possono contrassegnata come Inclusive
DocType: POS Profile,Update Stock,Aggiornare Giacenza
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10,in the subscription,nell&#39;abbonamento
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +100,Different UOM for items will lead to incorrect (Total) Net Weight value. Make sure that Net Weight of each item is in the same UOM.,"Una diversa Unità di Misura degli articoli darà come risultato un Peso Netto (Totale) non corretto.
Assicurarsi che il peso netto di ogni articolo sia nella stessa Unità di Misura."
DocType: Membership,Payment Details,Dettagli del pagamento
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,BOM Rate,BOM Tasso
DocType: Asset,Journal Entry for Scrap,Diario di rottami
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +83,Please pull items from Delivery Note,Si prega di tirare oggetti da DDT
apps/erpnext/erpnext/accounts/utils.py +469,Journal Entries {0} are un-linked,Journal Entries {0} sono un-linked
apps/erpnext/erpnext/config/crm.py +92,"Record of all communications of type email, phone, chat, visit, etc.","Salva tutte le comunicazioni di tipo e-mail, telefono, chat, visita, ecc"
DocType: Supplier Scorecard Scoring Standing,Supplier Scorecard Scoring Standing,Scorecard fornitore punteggio in piedi
DocType: Manufacturer,Manufacturers used in Items,Produttori utilizzati in Articoli
apps/erpnext/erpnext/accounts/general_ledger.py +168,Please mention Round Off Cost Center in Company,Si prega di citare Arrotondamento centro di costo in azienda
DocType: Purchase Invoice,Terms,Termini
DocType: Academic Term,Term Name,termine Nome
DocType: Buying Settings,Purchase Order Required,Ordine di Acquisto Obbligatorio
,Item-wise Sales History,Articolo-saggio Storia Vendite
DocType: Expense Claim,Total Sanctioned Amount,Totale importo sanzionato
DocType: Land Unit,Land Unit,Unità di terra
,Purchase Analytics,Acquisto Analytics
DocType: Sales Invoice Item,Delivery Note Item,Articolo del Documento di Trasporto
DocType: Asset Maintenance Log,Task,Attività
DocType: Purchase Taxes and Charges,Reference Row #,Riferimento Row #
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +76,Batch number is mandatory for Item {0},Numero di lotto obbligatoria per la voce {0}
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +13,This is a root sales person and cannot be edited.,Si tratta di una persona di vendita di root e non può essere modificato .
DocType: Salary Detail,"If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ","Se selezionato, il valore specificato o calcolato in questo componente non contribuirà agli utili o alle deduzioni. Tuttavia, il suo valore può essere riferito da altri componenti che possono essere aggiunti o detratti."
,Stock Ledger,Inventario
apps/erpnext/erpnext/templates/includes/cart/cart_items.html +29,Rate: {0},Prezzo: {0}
DocType: Company,Exchange Gain / Loss Account,Guadagno Exchange / Conto Economico
apps/erpnext/erpnext/config/hr.py +7,Employee and Attendance,Dipendenti e presenze
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +83,Purpose must be one of {0},Scopo deve essere uno dei {0}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +116,Fill the form and save it,Compila il modulo e salva
DocType: Production Planning Tool,Download a report containing all raw materials with their latest inventory status,Scaricare un report contenete tutte le materie prime con il loro recente stato di inventario
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +26,Community Forum,Forum Community
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +51,Actual qty in stock,Quantità disponibile
DocType: Homepage,"URL for ""All Products""",URL per &quot;tutti i prodotti&quot;
DocType: Leave Application,Leave Balance Before Application,Lascia bilancio prima applicazione
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +46,Send SMS,Invia SMS
DocType: Supplier Scorecard Criteria,Max Score,Punteggio massimo
DocType: Cheque Print Template,Width of amount in word,Importo in parole
DocType: Company,Default Letter Head,Predefinito Carta Intestata
DocType: Purchase Order,Get Items from Open Material Requests,Ottenere elementi dal Richieste Aperto Materiale
DocType: Lab Test Template,Standard Selling Rate,Prezzo di Vendita Standard
DocType: Account,Rate at which this tax is applied,Tasso a cui viene applicata questa tassa
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +75,Reorder Qty,Riordina Quantità
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +28,Current Job Openings,Offerte di lavoro
DocType: Company,Stock Adjustment Account,Conto di regolazione Archivio
apps/erpnext/erpnext/public/js/payment/pos_payment.html +17,Write Off,Svalutazione
DocType: Timesheet Detail,Operation ID,ID Operazione
DocType: Employee,"System User (login) ID. If set, it will become default for all HR forms.","Utente di sistema (login) ID. Se impostato, esso diventerà di default per tutti i moduli HR."
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +16,{0}: From {1},{0}: Da {1}
DocType: Task,depends_on,dipende da
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +49,Queued for updating latest price in all Bill of Materials. It may take a few minutes.,In coda per aggiornare il prezzo più recente in tutte le fatture dei materiali. Può richiedere alcuni minuti.
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +26,Name of new Account. Note: Please don't create accounts for Customers and Suppliers,Nome del nuovo conto. Nota: Si prega di non creare account per Clienti e Fornitori
apps/erpnext/erpnext/config/setup.py +37,Country wise default Address Templates,Modelli Country saggio di default Indirizzo
DocType: Water Analysis,Appearance,Aspetto
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70,Avg. Buying Price List Rate,Avg. Comprare il listino prezzi
DocType: Sales Order Item,Supplier delivers to Customer,il Fornitore consegna al Cliente
apps/erpnext/erpnext/config/non_profit.py +23,Member information.,Informazioni sui membri
apps/erpnext/erpnext/utilities/bot.py +34,[{0}](#Form/Item/{0}) is out of stock,[{0}](#Form/Item/{0}) è esaurito
apps/erpnext/erpnext/assets/doctype/asset/asset.js +58,Asset Maintenance,Manutenzione delle risorse
,Sales Payment Summary,Riepilogo dei pagamenti di vendita
DocType: Restaurant,Restaurant,Ristorante
apps/erpnext/erpnext/accounts/party.py +323,Due / Reference Date cannot be after {0},Data / Reference Data non può essere successiva {0}
apps/erpnext/erpnext/config/setup.py +51,Data Import and Export,Importazione ed esportazione dati
DocType: Patient,Account Details,Dettagli Account
DocType: Crop,Materials Required,Materiali richiesti
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +76,No students Found,Nessun studenti hanno trovato
DocType: Medical Department,Medical Department,Dipartimento di Medicina
DocType: Supplier Scorecard Scoring Criteria,Supplier Scorecard Scoring Criteria,Criteri di valutazione del punteggio fornitore
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +55,Invoice Posting Date,Fattura Data Pubblicazione
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +25,Sell,Vendere
DocType: Purchase Invoice,Rounded Total,Totale arrotondato
DocType: Product Bundle,List items that form the package.,Voci di elenco che formano il pacchetto.
apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py +26,Percentage Allocation should be equal to 100%,Percentuale di ripartizione dovrebbe essere pari al 100 %
DocType: Crop Cycle,Linked Land Unit,Unità di terra collegata
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +584,Please select Posting Date before selecting Party,Si prega di selezionare la data di registrazione prima di selezionare il Partner
DocType: Program Enrollment,School House,school House
DocType: Serial No,Out of AMC,Fuori di AMC
apps/erpnext/erpnext/assets/doctype/asset/asset.py +82,Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Numero degli ammortamenti prenotata non può essere maggiore di Numero totale degli ammortamenti
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +47,Make Maintenance Visit,Aggiungi visita manutenzione
apps/erpnext/erpnext/selling/doctype/customer/customer.py +198,Please contact to the user who have Sales Master Manager {0} role,Si prega di contattare l'utente che hanno Sales Master Responsabile {0} ruolo
DocType: Company,Default Cash Account,Conto cassa predefinito
apps/erpnext/erpnext/config/accounts.py +62,Company (not Customer or Supplier) master.,Azienda ( non cliente o fornitore ) master.
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +6,This is based on the attendance of this Student,Questo si basa sulla presenza di questo Student
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +178,No Students in,Nessun studente dentro
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +171,Add more items or open full form,Aggiungi altri elementi o apri modulo completo
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +212,Delivery Notes {0} must be cancelled before cancelling this Sales Order,I Documenti di Trasporto {0} devono essere cancellati prima di annullare questo Ordine di Vendita
apps/erpnext/erpnext/utilities/user_progress.py +256,Go to Users,Vai agli Utenti
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +85,Paid amount + Write Off Amount can not be greater than Grand Total,Importo pagato + Importo svalutazione non può essere superiore a Totale generale
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +78,{0} is not a valid Batch Number for Item {1},{0} non è un numero di lotto valido per la voce {1}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +149,Note: There is not enough leave balance for Leave Type {0},Nota : Non c'è equilibrio congedo sufficiente per Leave tipo {0}
apps/erpnext/erpnext/regional/india/utils.py +15,Invalid GSTIN or Enter NA for Unregistered,GSTIN non valido o Invio NA per non registrato
DocType: Training Event,Seminar,Seminario
DocType: Program Enrollment Fee,Program Enrollment Fee,Programma Tassa di iscrizione
DocType: Item,Supplier Items,Articoli Fornitore
DocType: Opportunity,Opportunity Type,Tipo di Opportunità
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +16,New Company,Nuova Azienda
apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py +17,Transactions can only be deleted by the creator of the Company,Le transazioni possono essere eliminati solo dal creatore della Società
apps/erpnext/erpnext/accounts/general_ledger.py +21,Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Numero della scrittura in contabilità generale non corretto. Potresti aver selezionato un conto sbagliato nella transazione.
DocType: Employee,Prefered Contact Email,Preferenziale di contatto e-mail
DocType: Cheque Print Template,Cheque Width,Larghezza Assegno
DocType: Selling Settings,Validate Selling Price for Item against Purchase Rate or Valuation Rate,Convalida il prezzo di vendita dell'articolo dal prezzo di acquisto o dal tasso di valutazione
DocType: Fee Schedule,Fee Schedule,Tariffario
DocType: Hub Settings,Publish Availability,Pubblicare Disponibilità
DocType: Company,Create Chart Of Accounts Based On,Crea il Piano dei conti in base a
apps/erpnext/erpnext/projects/doctype/task/task.js +91,Cannot convert it to non-group. Child Tasks exist.,Non è possibile convertire in non gruppo. Esistono attività dipendenti.
apps/erpnext/erpnext/hr/doctype/employee/employee.py +112,Date of Birth cannot be greater than today.,Data di nascita non può essere maggiore rispetto a oggi.
,Stock Ageing,Invecchiamento Archivio
apps/erpnext/erpnext/education/doctype/student/student.py +38,Student {0} exist against student applicant {1},Studente {0} esiste contro richiedente studente {1}
DocType: Purchase Invoice,Rounding Adjustment (Company Currency),Adattamento arrotondamento (Valuta Società)
apps/erpnext/erpnext/projects/doctype/task/task.js +39,Timesheet,Scheda attività
DocType: Volunteer,Afternoon,Pomeriggio
apps/erpnext/erpnext/controllers/accounts_controller.py +256,{0} '{1}' is disabled,{0} '{1}' è disabilitato
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +13,Set as Open,Imposta come Aperto
DocType: Cheque Print Template,Scanned Cheque,Assegno scansionato
DocType: Notification Control,Send automatic emails to Contacts on Submitting transactions.,Invia e-mail automatica ai contatti alla conferma.
DocType: Timesheet,Total Billable Amount,Importo Totale Fatturabile
DocType: Customer,Credit Limit and Payment Terms,Limite di credito e condizioni di pagamento
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +20,Item 3,Articolo 3
apps/erpnext/erpnext/restaurant/doctype/restaurant/restaurant.js +6,Order Entry,Inserimento ordini
DocType: Purchase Order,Customer Contact Email,Customer Contact Email
DocType: Warranty Claim,Item and Warranty Details,Voce e garanzia Dettagli
DocType: Chapter,Chapter Members,Membri del Capitolo
DocType: Sales Team,Contribution (%),Contributo (%)
apps/erpnext/erpnext/controllers/accounts_controller.py +100,Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,Nota : non verrà creato il pagamento poiché non è stato specificato 'conto bancario o fido'
apps/erpnext/erpnext/projects/doctype/project/project.py +67,Project {0} already exists,Il progetto {0} esiste già
DocType: Medical Department,Nursing User,Nursing User
DocType: Plant Analysis,Plant Analysis Criterias,Criteri di analisi delle piante
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +237,Responsibilities,Responsabilità
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +125,Validity period of this quotation has ended.,Il periodo di validità di questa quotazione è terminato.
DocType: Expense Claim Account,Expense Claim Account,Conto spese rivendicazione
DocType: Accounts Settings,Allow Stale Exchange Rates,Consenti tariffe scadenti
DocType: Sales Person,Sales Person Name,Vendite Nome persona
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +54,Please enter atleast 1 invoice in the table,Inserisci atleast 1 fattura nella tabella
apps/erpnext/erpnext/utilities/user_progress.py +244,Add Users,Aggiungi Utenti
DocType: POS Item Group,Item Group,Gruppo Articoli
DocType: Item,Safety Stock,Scorta di sicurezza
DocType: Healthcare Settings,Healthcare Settings,Impostazioni sanitarie
apps/erpnext/erpnext/projects/doctype/task/task.py +54,Progress % for a task cannot be more than 100.,Avanzamento % per un'attività non può essere superiore a 100.
DocType: Stock Reconciliation Item,Before reconciliation,Prima di riconciliazione
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +12,To {0},Per {0}
DocType: Purchase Invoice,Taxes and Charges Added (Company Currency),Tasse e spese aggiuntive (Azienda valuta)
apps/erpnext/erpnext/stock/doctype/item/item.py +461,Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,Voce fiscale Row {0} deve avere un account di tipo fiscale o di reddito o spese o addebitabile
DocType: Sales Order,Partly Billed,Parzialmente Fatturato
apps/erpnext/erpnext/assets/doctype/asset/asset.py +43,Item {0} must be a Fixed Asset Item,Voce {0} deve essere un asset Articolo fisso
apps/erpnext/erpnext/stock/doctype/item/item.js +341,Make Variants,Crea varianti
DocType: Item,Default BOM,Distinta Materiali Predefinita
DocType: Project,Total Billed Amount (via Sales Invoices),Importo fatturato totale (tramite fatture di vendita)
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +24,Debit Note Amount,Debito importo nota
apps/erpnext/erpnext/setup/doctype/company/company.js +60,Please re-type company name to confirm,Si prega di digitare nuovamente il nome della società per confermare
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +90,Total Outstanding Amt,Totale Outstanding Amt
DocType: Journal Entry,Printing Settings,Impostazioni di stampa
DocType: Employee Advance,Advance Account,Conto anticipato
DocType: Sales Invoice,Include Payment (POS),Includi pagamento (POS)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +290,Total Debit must be equal to Total Credit. The difference is {0},Debito totale deve essere pari al totale credito .
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +11,Automotive,Automotive
DocType: Vehicle,Insurance Company,Compagnia assicurativa
DocType: Asset Category Account,Fixed Asset Account,Fixed Asset Account
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +414,Variable,Variabile
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js +47,From Delivery Note,Da Documento di Trasporto
DocType: Chapter,Members,Utenti
DocType: Student,Student Email Address,Student Indirizzo e-mail
DocType: Item,Hub Warehouse,Magazzino Hub
DocType: Assessment Plan,From Time,Da Periodo
apps/erpnext/erpnext/public/js/pos/pos_bill_item.html +12,In Stock: ,In Stock:
DocType: Notification Control,Custom Message,Messaggio Personalizzato
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +33,Investment Banking,Investment Banking
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +79,Cash or Bank Account is mandatory for making payment entry,Contanti o conto bancario è obbligatoria per effettuare il pagamento voce
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54,Student Address,Indirizzo studente
DocType: Purchase Invoice,Price List Exchange Rate,Listino Prezzi Tasso di Cambio
apps/erpnext/erpnext/accounts/doctype/account/account.py +253,Account Number {0} already used in account {1},Numero di conto {0} già utilizzato nell&#39;account {1}
DocType: POS Profile,POS Profile Name,Nome del profilo POS
DocType: Purchase Invoice Item,Rate,Prezzo
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +104,Intern,Stagista
DocType: Delivery Stop,Address Name,indirizzo Nome
DocType: Stock Entry,From BOM,Da Distinta Materiali
DocType: Assessment Code,Assessment Code,Codice Assessment
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +73,Basic,Base
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +94,Stock transactions before {0} are frozen,Operazioni Giacenza prima {0} sono bloccate
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +219,Please click on 'Generate Schedule',Si prega di cliccare su ' Generate Schedule '
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +120,Reference No is mandatory if you entered Reference Date,N. di riferimento è obbligatoria se hai inserito Reference Data
DocType: Bank Reconciliation Detail,Payment Document,Documento di Pagamento
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +37,Error evaluating the criteria formula,Errore durante la valutazione della formula dei criteri
apps/erpnext/erpnext/hr/doctype/employee/employee.py +115,Date of Joining must be greater than Date of Birth,Data di adesione deve essere maggiore di Data di nascita
DocType: Salary Slip,Salary Structure,Struttura salariale
DocType: Account,Bank,Banca
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +9,Airline,linea aerea
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +852,Issue Material,Fornire Materiale
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3,An error occured while creating recurring,Si è verificato un errore durante la creazione di ricorrenti
DocType: Material Request Item,For Warehouse,Per Magazzino
DocType: Employee,Offer Date,Data dell'offerta
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +33,Quotations,Preventivi
apps/erpnext/erpnext/accounts/page/pos/pos.js +726,You are in offline mode. You will not be able to reload until you have network.,Sei in modalità non in linea. Si potrà ricaricare quando tornerà disponibile la connessione alla rete.
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +47,No Student Groups created.,Non sono stati creati Gruppi Studenti
DocType: Purchase Invoice Item,Serial No,Serial No
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +119,Monthly Repayment Amount cannot be greater than Loan Amount,Rimborso mensile non può essere maggiore di prestito Importo
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +143,Please enter Maintaince Details first,Inserisci Maintaince dettagli prima
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +56,Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,Riga # {0}: Data di consegna prevista non può essere prima dell&#39;ordine di acquisto
DocType: Purchase Invoice,Print Language,Lingua di Stampa
DocType: Salary Slip,Total Working Hours,Orario di lavoro totali
DocType: Subscription,Next Schedule Date,Data di pianificazione successiva
DocType: Stock Entry,Including items for sub assemblies,Compresi articoli per sub assemblaggi
DocType: Opening Invoice Creation Tool Item,Temporary Opening Account,Conto di apertura temporaneo
apps/erpnext/erpnext/accounts/page/pos/pos.js +1943,Enter value must be positive,Inserire il valore deve essere positivo
apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +392,All Territories,tutti i Territori
DocType: Purchase Invoice,Items,Articoli
apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +28,Student is already enrolled.,Studente è già registrato.
DocType: Fiscal Year,Year Name,Nome Anno
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +240,There are more holidays than working days this month.,Ci sono più feste che giorni di lavoro questo mese.
DocType: Product Bundle Item,Product Bundle Item,Prodotto Bundle Voce
DocType: Sales Partner,Sales Partner Name,Nome partner vendite
apps/erpnext/erpnext/hooks.py +136,Request for Quotations,Richieste di offerta
DocType: Payment Reconciliation,Maximum Invoice Amount,Importo Massimo Fattura
apps/erpnext/erpnext/healthcare/setup.py +210,Haematology,Ematologia
DocType: Normal Test Items,Normal Test Items,Elementi di prova normali
DocType: Student Language,Student Language,Student Lingua
apps/erpnext/erpnext/config/selling.py +23,Customers,Clienti
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +24,Order/Quot %,Ordine / Quota%
apps/erpnext/erpnext/config/healthcare.py +25,Record Patient Vitals,Registra i pazienti pazienti
DocType: Fee Schedule,Institution,Istituzione
DocType: Asset,Partially Depreciated,parzialmente ammortizzati
DocType: Issue,Opening Time,Tempo di apertura
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +92,From and To dates required,Data Inizio e Fine sono obbligatorie
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +46,Securities & Commodity Exchanges,Securities & borse merci
apps/erpnext/erpnext/stock/doctype/item/item.py +661,Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Unità di misura predefinita per la variante &#39;{0}&#39; deve essere lo stesso in Template &#39;{1}&#39;
DocType: Shipping Rule,Calculate Based On,Calcola in base a
DocType: Delivery Note Item,From Warehouse,Dal Deposito
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +59,No employees for the mentioned criteria,Nessun dipendente per i criteri indicati
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +944,No Items with Bill of Materials to Manufacture,Non ci sono elementi con Bill of Materials per la produzione
DocType: Restaurant,Default Customer,Cliente predefinito
DocType: Assessment Plan,Supervisor Name,Nome supervisore
DocType: Healthcare Settings,Do not confirm if appointment is created for the same day,Non confermare se l&#39;appuntamento è stato creato per lo stesso giorno
DocType: Program Enrollment Course,Program Enrollment Course,Corso di iscrizione al programma
DocType: Purchase Taxes and Charges,Valuation and Total,Valorizzazione e Totale
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +11,Scorecards,Scorecards
DocType: Tax Rule,Shipping City,Spedizione Città
DocType: Notification Control,Customize the Notification,Personalizzare Notifica
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +19,Cash Flow from Operations,Cash flow operativo
DocType: Purchase Invoice,Shipping Rule,Tipo di Spedizione
DocType: Patient Relation,Spouse,Sposa
DocType: Lab Test Groups,Add Test,Aggiungi Test
DocType: Manufacturer,Limited to 12 characters,Limitato a 12 caratteri
DocType: Journal Entry,Print Heading,Intestazione di stampa
apps/erpnext/erpnext/config/stock.py +146,Delivery Trip service tours to customers.,Consegna Viaggi di servizio di viaggio ai clienti.
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +57,Total cannot be zero,Totale non può essere zero
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +16,'Days Since Last Order' must be greater than or equal to zero,'Giorni dall'ultimo Ordine' deve essere maggiore o uguale a zero
DocType: Plant Analysis Criteria,Maximum Permissible Value,Massimo valore consentito
DocType: Journal Entry Account,Employee Advance,Employee Advance
DocType: Payroll Entry,Payroll Frequency,Payroll Frequenza
DocType: Lab Test Template,Sensitivity,sensibilità
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +62,Raw Material,Materia prima
DocType: Leave Application,Follow via Email,Seguire via Email
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +55,Plants and Machineries,Impianti e Macchinari
DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Valore Tasse Dopo Sconto dell'Importo
DocType: Daily Work Summary Settings,Daily Work Summary Settings,Impostazioni riepilogo giornaliero lavori
DocType: Payment Entry,Internal Transfer,Trasferimento interno
DocType: Asset Maintenance,Maintenance Tasks,Attività di manutenzione
apps/erpnext/erpnext/setup/doctype/territory/territory.py +19,Either target qty or target amount is mandatory,Sia qty destinazione o importo obiettivo è obbligatoria
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +367,Please select Posting Date first,Seleziona Data Pubblicazione primo
apps/erpnext/erpnext/public/js/account_tree_grid.js +210,Opening Date should be before Closing Date,Data di apertura dovrebbe essere prima Data di chiusura
DocType: Leave Control Panel,Carry Forward,Portare Avanti
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +30,Cost Center with existing transactions can not be converted to ledger,Centro di costo con le transazioni esistenti non può essere convertito in contabilità
DocType: Department,Days for which Holidays are blocked for this department.,Giorni per i quali le festività sono bloccate per questo reparto.
DocType: Crop Cycle,Detected Disease,Malattia rilevata
,Produced,prodotto
DocType: Item,Item Code for Suppliers,Codice Articolo per Fornitori
DocType: Issue,Raised By (Email),Sollevata da (e-mail)
DocType: Training Event,Trainer Name,Nome Trainer
DocType: Mode of Payment,General,Generale
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28,Last Communication,Ultima comunicazione
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +372,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',Non può dedurre quando categoria è di ' valutazione ' o ' Valutazione e Total '
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +234,Serial Nos Required for Serialized Item {0},Serial Nos Obbligatorio per la voce Serialized {0}
apps/erpnext/erpnext/config/accounts.py +144,Match Payments with Invoices,Partita pagamenti con fatture
DocType: Journal Entry,Bank Entry,Registrazione bancaria
DocType: Authorization Rule,Applicable To (Designation),Applicabile a (Designazione)
,Profitability Analysis,Analisi redditività
DocType: Fees,Student Email,Email dell&#39;allievo
DocType: Supplier,Prevent POs,Impedire le PO
DocType: Patient,"Allergies, Medical and Surgical History","Allergie, storia medica e chirurgica"
apps/erpnext/erpnext/templates/generators/item.html +62,Add to Cart,Aggiungi al carrello
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.js +28,Group By,Raggruppa per
DocType: Guardian,Interests,Interessi
apps/erpnext/erpnext/config/accounts.py +298,Enable / disable currencies.,Abilitare / disabilitare valute.
DocType: Production Planning Tool,Get Material Request,Get Materiale Richiesta
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +111,Postal Expenses,spese postali
apps/erpnext/erpnext/controllers/trends.py +19,Total(Amt),Totale (Amt)
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +26,Entertainment & Leisure,Intrattenimento e tempo libero
,Item Variant Details,Dettagli della variante dell&#39;articolo
DocType: Quality Inspection,Item Serial No,Articolo N. d&#39;ordine
apps/erpnext/erpnext/utilities/activation.py +135,Create Employee Records,Creare record dei dipendenti
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Present,Presente totale
apps/erpnext/erpnext/config/accounts.py +105,Accounting Statements,Prospetti contabili
DocType: Drug Prescription,Hour,Ora
DocType: Restaurant Order Entry,Last Sales Invoice,Fattura di ultima vendita
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +799,Please select Qty against item {0},Seleziona Qtà rispetto all&#39;articolo {0}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +29,New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,Un nuovo Serial No non può avere un magazzino. Il magazzino deve essere impostato  nell'entrata giacenza o su ricevuta d'acquisto
DocType: Lead,Lead Type,Tipo Lead
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +133,You are not authorized to approve leaves on Block Dates,Non sei autorizzato ad approvare foglie su Date Block
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +383,All these items have already been invoiced,Tutti questi elementi sono già stati fatturati
DocType: Company,Monthly Sales Target,Target di vendita mensile
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +37,Can be approved by {0},Può essere approvato da {0}
DocType: Item,Default Material Request Type,Predefinito Materiale Tipo di richiesta
DocType: Supplier Scorecard,Evaluation Period,Periodo di valutazione
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js +13,Unknown,Sconosciuto
DocType: Shipping Rule,Shipping Rule Conditions,Condizioni Tipo di Spedizione
DocType: Purchase Invoice,Export Type,Tipo di esportazione
DocType: Salary Slip Loan,Salary Slip Loan,Salario Slip Loan
DocType: BOM Update Tool,The new BOM after replacement,Il nuovo BOM dopo la sostituzione
,Point of Sale,Punto di vendita
DocType: Payment Entry,Received Amount,importo ricevuto
DocType: Patient,Widow,Vedova
DocType: GST Settings,GSTIN Email Sent On,Posta elettronica di GSTIN inviata
DocType: Program Enrollment,Pick/Drop by Guardian,Pick / Drop di Guardian
DocType: Production Planning Tool,"Create for full quantity, ignoring quantity already on order","Creare per la piena quantità, ignorando la quantità già in ordine"
DocType: Crop,Planting UOM,Piantare UOM
DocType: Account,Tax,Tassa
apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +45,Not Marked,non segnato
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +1,Opening Invoices Summary,Riepilogo delle fatture di apertura
DocType: Education Settings,Education Manager,Responsabile della formazione
DocType: Production Planning Tool,Production Planning Tool,Production Planning Tool
DocType: Crop Cycle,The minimum length between each plant in the field for optimum growth,La lunghezza minima tra ogni pianta nel campo per una crescita ottimale
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +150,"Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry","L&#39;elemento bloccato {0} non può essere aggiornato utilizzando Riconciliazione stock, invece utilizzare l&#39;opzione Stock Entry"
DocType: Quality Inspection,Report Date,Data Report
DocType: Student,Middle Name,Secondo nome
DocType: C-Form,Invoices,Fatture
DocType: Water Analysis,Type of Sample,Tipo di campione
DocType: Batch,Source Document Name,Nome del documento di origine
DocType: Job Opening,Job Title,Titolo Posizione
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py +84,"{0} indicates that {1} will not provide a quotation, but all items \
					have been quoted. Updating the RFQ quote status.","{0} indica che {1} non fornirà una quotazione, ma tutti gli elementi \ sono stati citati. Aggiornamento dello stato delle quote RFQ."
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +971,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Numero massimo di campioni: {0} sono già stati conservati per il batch {1} e l&#39;articolo {2} nel batch {3}.
DocType: Manufacturing Settings,Update BOM Cost Automatically,Aggiorna automaticamente il costo della BOM
DocType: Lab Test,Test Name,Nome del test
apps/erpnext/erpnext/utilities/activation.py +99,Create Users,creare utenti
apps/erpnext/erpnext/utilities/user_progress.py +144,Gram,Grammo
DocType: Supplier Scorecard,Per Month,Al mese
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +414,Quantity to Manufacture must be greater than 0.,Quantità di Fabbricazione deve essere maggiore di 0.
apps/erpnext/erpnext/config/maintenance.py +17,Visit report for maintenance call.,Visita rapporto per chiamata di manutenzione.
DocType: Stock Entry,Update Rate and Availability,Frequenza di aggiornamento e disponibilità
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.,Percentuale si è permesso di ricevere o consegnare di più contro la quantità ordinata. Per esempio: Se avete ordinato 100 unità. e il vostro assegno è 10% poi si è permesso di ricevere 110 unità.
DocType: POS Customer Group,Customer Group,Gruppo Cliente
apps/erpnext/erpnext/stock/doctype/batch/batch.js +120,New Batch ID (Optional),Nuovo ID batch (opzionale)
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +201,Expense account is mandatory for item {0},Conto spese è obbligatoria per l'elemento {0}
DocType: BOM,Website Description,Descrizione del sito
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +42,Net Change in Equity,Variazione netta Patrimonio
apps/erpnext/erpnext/hub_node/page/hub/hub.js +196,Newest,i più nuovi
apps/erpnext/erpnext/assets/doctype/asset/asset.py +163,Please cancel Purchase Invoice {0} first,Si prega di annullare Acquisto Fattura {0} prima
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +43,"Email Address must be unique, already exists for {0}","l' indirizzo e-mail deve essere univoco, esiste già per {0}"
DocType: Serial No,AMC Expiry Date,AMC Data Scadenza
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +865,Receipt,Ricevuta
,Sales Register,Registro Vendite
DocType: Daily Work Summary Settings Company,Send Emails At,Invia e-mail in
DocType: Quotation,Quotation Lost Reason,Motivo per la mancata vendita
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +368,Transaction reference no {0} dated {1},di riferimento della transazione non {0} {1} datato
apps/erpnext/erpnext/setup/doctype/supplier_type/supplier_type.js +5,There is nothing to edit.,Non c'è nulla da modificare.
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +476,Form View,Vista forma
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +116,Summary for this month and pending activities,Riepilogo per questo mese e le attività in corso
apps/erpnext/erpnext/utilities/user_progress.py +245,"Add users to your organization, other than yourself.","Aggiungi utenti alla tua organizzazione, diversa da te stesso."
DocType: Customer Group,Customer Group Name,Nome Gruppo Cliente
apps/erpnext/erpnext/public/js/pos/pos.html +98,No Customers yet!,Nessun Cliente ancora!
apps/erpnext/erpnext/public/js/financial_statements.js +56,Cash Flow Statement,Rendiconto finanziario
apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py +23,Loan Amount cannot exceed Maximum Loan Amount of {0},Importo del prestito non può superare il massimo importo del prestito {0}
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +22,License,Licenza
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +485,Please remove this Invoice {0} from C-Form {1},Si prega di rimuovere questo Invoice {0} dal 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,Si prega di selezionare il riporto se anche voi volete includere equilibrio precedente anno fiscale di parte per questo anno fiscale
DocType: GL Entry,Against Voucher Type,Per tipo Tagliando
DocType: Physician,Phone (R),Telefono (R)
apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +50,Time slots added,Fascia temporale aggiunta
DocType: Item,Attributes,Attributi
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +31,Enable Template,Abilita il modello
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +226,Please enter Write Off Account,Inserisci Conto per Svalutazioni
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +71,Last Order Date,Ultima data di ordine
DocType: Patient,B Negative,B Negativo
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +25,Maintenance Status has to be Cancelled or Completed to Submit,Lo stato di manutenzione deve essere annullato o completato per inviare
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +47,Account {0} does not belongs to company {1},Il Conto {0} non appartiene alla società {1}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +878,Serial Numbers in row {0} does not match with Delivery Note,I numeri seriali nella riga {0} non corrispondono alla nota di consegna
DocType: Student,Guardian Details,Guardiano Dettagli
DocType: C-Form,C-Form,C-Form
apps/erpnext/erpnext/config/hr.py +18,Mark Attendance for multiple employees,Segna come  Presenze per più Dipendenti
DocType: Agriculture Task,Start Day,Inizia il giorno
DocType: Vehicle,Chassis No,Telaio No
DocType: Payment Request,Initiated,Iniziato
DocType: Production Order,Planned Start Date,Data di inizio prevista
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +596,Please select a BOM,Seleziona una BOM
DocType: Serial No,Creation Document Type,Creazione tipo di documento
DocType: Project Task,View Timesheet,Visualizza scheda attività
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +54,End date must be greater than start date,La data di fine deve essere maggiore della data di inizio
DocType: Leave Type,Is Encash,È incassare
DocType: Leave Allocation,New Leaves Allocated,Nuove ferie allocate
apps/erpnext/erpnext/controllers/trends.py +269,Project-wise data is not available for Quotation,Dati di progetto non sono disponibile per Preventivo
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +30,End on,Finisci
DocType: Project,Expected End Date,Data di chiusura prevista
DocType: Budget Account,Budget Amount,budget Importo
DocType: Donor,Donor Name,Nome del donatore
DocType: Appraisal Template,Appraisal Template Title,Valutazione Titolo Modello
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +39,From Date {0} for Employee {1} cannot be before employee's joining Date {2},Da Data {0} per Employee {1} non può essere prima di unirsi Data del dipendente {2}
apps/erpnext/erpnext/utilities/user_progress_utils.py +29,Commercial,commerciale
DocType: Patient,Alcohol Current Use,Uso corrente di alcool
DocType: Student Admission Program,Student Admission Program,Programma di ammissione all&#39;allievo
DocType: Payment Entry,Account Paid To,Risorsa di deposito
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +24,Parent Item {0} must not be a Stock Item,Voce genitore {0} non deve essere un Articolo Articolo
apps/erpnext/erpnext/config/selling.py +57,All Products or Services.,Tutti i Prodotti o Servizi.
DocType: Expense Claim,More Details,Maggiori dettagli
DocType: Supplier Quotation,Supplier Address,Indirizzo Fornitore
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} budget per l'account {1} contro {2} {3} è {4}. Si supererà di {5}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +689,Row {0}# Account must be of type 'Fixed Asset',Riga {0} # account deve essere di tipo 'Bene Strumentale'
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Out Qty,out Quantità
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,and unchcked Disabled in the,e disattivato disabilitato nel
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +46,Series is mandatory,Series è obbligatorio
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +28,Financial Services,Servizi finanziari
DocType: Student Sibling,Student ID,Student ID
apps/erpnext/erpnext/hub_node/page/hub/hub.js +457,Supplier Email,Email del fornitore
apps/erpnext/erpnext/config/projects.py +46,Types of activities for Time Logs,Tipi di attività per i registri di tempo
DocType: Opening Invoice Creation Tool,Sales,Vendite
DocType: Stock Entry Detail,Basic Amount,Importo di base
DocType: Training Event,Exam,Esame
DocType: Complaint,Complaint,Denuncia
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +456,Warehouse required for stock Item {0},Magazzino richiesto per l'Articolo in Giacenza {0}
DocType: Leave Allocation,Unused leaves,Ferie non godute
DocType: Patient,Alcohol Past Use,Utilizzo passato di alcool
DocType: Fertilizer Content,Fertilizer Content,Contenuto di fertilizzanti
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +188,Cr,Cr
DocType: Tax Rule,Billing State,Stato di fatturazione
apps/erpnext/erpnext/assets/doctype/asset/asset.js +296,Transfer,Trasferimento
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +916,Fetch exploded BOM (including sub-assemblies),Fetch BOM esplosa ( inclusi sottoassiemi )
DocType: Authorization Rule,Applicable To (Employee),Applicabile a (Dipendente)
apps/erpnext/erpnext/controllers/accounts_controller.py +135,Due Date is mandatory,Data di scadenza è obbligatoria
apps/erpnext/erpnext/controllers/item_variant.py +80,Increment for Attribute {0} cannot be 0,Incremento per attributo {0} non può essere 0
DocType: Journal Entry,Pay To / Recd From,Paga a / Ricevuto Da
DocType: Naming Series,Setup Series,Serie Setup
DocType: Payment Reconciliation,To Invoice Date,Per Data fattura
DocType: Supplier,Contact HTML,Contatto HTML
DocType: Disease,Treatment Period,Periodo di trattamento
,Inactive Customers,I clienti inattivi
DocType: Student Admission Program,Maximum Age,Età massima
DocType: Landed Cost Voucher,LCV,LCV
DocType: Landed Cost Voucher,Purchase Receipts,Ricevute di acquisto
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +29,How Pricing Rule is applied?,Come viene applicata la Regola Tariffaria?
DocType: Stock Entry,Delivery Note No,Documento di Trasporto N.
DocType: Production Planning Tool,"If checked, only Purchase material requests for final raw materials will be included in the Material Requests. Otherwise, Material Requests for parent items will be created","Se selezionato, acquisto solo le richieste di materiale per le materie prime finali saranno inclusi nella sezione Richieste materiali. In caso contrario, verranno create le richieste dei materiali per gli articoli del genitore"
DocType: Cheque Print Template,Message to show,Messaggio da mostrare
apps/erpnext/erpnext/public/js/setup_wizard.js +28,Retail,Vendita al dettaglio
DocType: Student Attendance,Absent,Assente
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +591,Product Bundle,Bundle prodotto
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +38,Unable to find score starting at {0}. You need to have standing scores covering 0 to 100,Impossibile trovare il punteggio a partire da {0}. È necessario avere punteggi in piedi che coprono 0 a 100
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +206,No submitted Delivery Notes found,Non sono state trovate note di consegna inviate
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +210,Row {0}: Invalid reference {1},Riga {0}: Riferimento non valido {1}
DocType: Purchase Taxes and Charges Template,Purchase Taxes and Charges Template,Modelli di Imposte e Spese di Acquisto
DocType: Timesheet,TS-,TS
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +61,{0} {1}: Either debit or credit amount is required for {2},{0} {1}: Un importo a debito o a credito è richiesto per {2}
DocType: GL Entry,Remarks,Osservazioni
DocType: Payment Entry,Account Paid From,Risorsa di prelievo
DocType: Purchase Order Item Supplied,Raw Material Item Code,Codice Articolo Materia Prima
DocType: Task,Parent Task,Attività del genitore
DocType: Journal Entry,Write Off Based On,Svalutazione Basata Su
apps/erpnext/erpnext/utilities/activation.py +65,Make Lead,Crea un Lead
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +112,Print and Stationery,Di stampa e di cancelleria
DocType: Stock Settings,Show Barcode Field,Mostra campo del codice a barre
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +807,Send Supplier Emails,Inviare e-mail del fornitore
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.","Stipendio già elaborato per il periodo compreso tra {0} e {1}, Lascia periodo di applicazione non può essere tra questo intervallo di date."
DocType: Guardian Interest,Guardian Interest,Guardiano interesse
DocType: Volunteer,Availability,Disponibilità
apps/erpnext/erpnext/config/accounts.py +319,Setup default values for POS Invoices,Imposta i valori predefiniti per le fatture POS
apps/erpnext/erpnext/config/hr.py +182,Training,Formazione
DocType: Timesheet,Employee Detail,Dettaglio dei dipendenti
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58,Guardian1 Email ID,Email ID Guardian1
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +68,Next Date's day and Repeat on Day of Month must be equal,Il giorno dopo di Data e Ripetere sul Giorno del mese deve essere uguale
DocType: Lab Prescription,Test Code,Codice di prova
apps/erpnext/erpnext/config/website.py +11,Settings for website homepage,Impostazioni per homepage del sito
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +38,RFQs are not allowed for {0} due to a scorecard standing of {1},Le richieste di autorizzazione non sono consentite per {0} a causa di una posizione di scorecard di {1}
DocType: Delivery Stop,Select/Unselect Delivery Notes,Seleziona / deseleziona le note di consegna
DocType: Offer Letter,Awaiting Response,In attesa di risposta
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +60,Above,Sopra
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1375,Total Amount {0},Importo totale {0}
apps/erpnext/erpnext/controllers/item_variant.py +301,Invalid attribute {0} {1},attributo non valido {0} {1}
DocType: Supplier,Mention if non-standard payable account,Si ricorda se un conto non pagabile
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py +18,Please select the assessment group other than 'All Assessment Groups',Seleziona il gruppo di valutazione diverso da &#39;Tutti i gruppi di valutazione&#39;
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +67,Row {0}: Cost center is required for an item {1},Riga {0}: è necessario un centro di costo per un elemento {1}
DocType: Training Event Employee,Optional,Opzionale
DocType: Salary Slip,Earning & Deduction,Rendimento & Detrazione
DocType: Agriculture Analysis Criteria,Water Analysis,Analisi dell&#39;acqua
DocType: Chapter,Region,Regione
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +38,Optional. This setting will be used to filter in various transactions.,Facoltativo. Questa impostazione verrà utilizzato per filtrare in diverse operazioni .
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +108,Negative Valuation Rate is not allowed,Non è consentito un tasso di valorizzazione negativo
DocType: Holiday List,Weekly Off,Settimanale Off
apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.js +7,Reload Linked Analysis,Ricarica l&#39;analisi collegata
DocType: Fiscal Year,"For e.g. 2012, 2012-13","Per es. 2012, 2012-13"
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +96,Provisional Profit / Loss (Credit),Risultato provvisorio / Perdita (credito)
DocType: Sales Invoice,Return Against Sales Invoice,Di ritorno contro fattura di vendita
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +32,Item 5,Articolo 5
DocType: Serial No,Creation Time,Tempo di creazione
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +62,Total Revenue,Entrate totali
DocType: Patient,Other Risk Factors,Altri fattori di rischio
DocType: Sales Invoice,Product Bundle Help,Prodotto Bundle Aiuto
,Monthly Attendance Sheet,Foglio Presenze Mensile
DocType: Production Order Item,Production Order Item,Ordine di produzione del lotto
apps/erpnext/erpnext/healthcare/report/lab_test_report/lab_test_report.py +15,No record found,Nessun record trovato
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +140,Cost of Scrapped Asset,Costo di Asset Demolita
apps/erpnext/erpnext/controllers/stock_controller.py +236,{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: centro di costo è obbligatorio per la voce {2}
DocType: Vehicle,Policy No,Politica No
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +684,Get Items from Product Bundle,Ottenere elementi dal pacchetto di prodotti
DocType: Asset,Straight Line,Retta
DocType: Project User,Project User,progetto utente
apps/erpnext/erpnext/stock/doctype/batch/batch.js +64,Split,Diviso
DocType: GL Entry,Is Advance,È Advance
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +21,Attendance From Date and Attendance To Date is mandatory,Inizio e Fine data della frequenza soo obbligatori
apps/erpnext/erpnext/controllers/buying_controller.py +153,Please enter 'Is Subcontracted' as Yes or No,Si prega di specificare ' è un Conto lavoro ' come Si o No
DocType: Item,Default Purchase Unit of Measure,Unità di acquisto predefinita di misura
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29,Last Communication Date,Ultima data di comunicazione
DocType: Sales Team,Contact No.,Contatto N.
DocType: Bank Reconciliation,Payment Entries,Le voci di pagamento
DocType: Land Unit,Land Unit Details,Dettagli dell&#39;unità di terra
DocType: Land Unit,Latitude,Latitudine
DocType: Production Order,Scrap Warehouse,Scrap Magazzino
DocType: Production Order,Check if material transfer entry is not required,Controllare se non è richiesta la voce di trasferimento dei materiali
DocType: Program Enrollment Tool,Get Students From,Get studenti di
apps/erpnext/erpnext/config/learn.py +273,Publish Items on Website,Pubblicare Articoli sul sito web
apps/erpnext/erpnext/utilities/activation.py +126,Group your students in batches,Gruppo tuoi studenti in batch
DocType: Authorization Rule,Authorization Rule,Ruolo Autorizzazione
DocType: POS Profile,Offline POS Section,Sezione POS offline
DocType: Sales Invoice,Terms and Conditions Details,Termini e condizioni dettagli
apps/erpnext/erpnext/templates/generators/item.html +85,Specifications,specificazioni
DocType: Sales Taxes and Charges Template,Sales Taxes and Charges Template,Modelli di Imposte e spese di vendita
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +68,Total (Credit),Totale (Credito)
DocType: Repayment Schedule,Payment Date,Data di Pagamento
apps/erpnext/erpnext/stock/doctype/batch/batch.js +114,New Batch Qty,Nuovo Batch Qty
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +10,Apparel & Accessories,Abbigliamento e accessori
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +91,Could not solve weighted score function. Make sure the formula is valid.,Impossibile risolvere la funzione di punteggio ponderato. Assicurarsi che la formula sia valida.
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +67,Number of Order,Numero d'Ordine
DocType: Item Group,HTML / Banner that will show on the top of product list.,HTML / Banner che verrà mostrato nella parte superiore della lista dei prodotti.
DocType: Shipping Rule,Specify conditions to calculate shipping amount,Specificare le condizioni per determinare il valore di spedizione
DocType: Program Enrollment,Institute's Bus,Bus dell&#39;Istituto
DocType: Accounts Settings,Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Ruolo permesso di impostare conti congelati e modificare le voci congelati
DocType: Supplier Scorecard Scoring Variable,Path,Sentiero
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +28,Cannot convert Cost Center to ledger as it has child nodes,Impossibile convertire centro di costo a registro come ha nodi figlio
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +66,Opening Value,Valore di apertura
DocType: Salary Detail,Formula,Formula
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +47,Serial #,Serial #
DocType: Lab Test Template,Lab Test Template,Modello di prova del laboratorio
DocType: Purchase Invoice Item,Total Weight,Peso totale
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +94,Commission on Sales,Commissione sulle vendite
DocType: Offer Letter Term,Value / Description,Valore / Descrizione
apps/erpnext/erpnext/controllers/accounts_controller.py +609,"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Row # {0}: Asset {1} non può essere presentata, è già {2}"
DocType: Tax Rule,Billing Country,Nazione di fatturazione
DocType: Purchase Order Item,Expected Delivery Date,Data prevista di consegna
DocType: Restaurant Order Entry,Restaurant Order Entry,Inserimento ordine del ristorante
apps/erpnext/erpnext/accounts/general_ledger.py +132,Debit and Credit not equal for {0} #{1}. Difference is {2}.,Dare e Avere non uguale per {0} # {1}. La differenza è {2}.
DocType: Asset Maintenance Task,Assign To Name,Assegna al nome
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +98,Entertainment Expenses,Spese di rappresentanza
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +63,Make Material Request,Crea una Richiesta di Materiali
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +20,Open Item {0},Apri elemento {0}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +222,Sales Invoice {0} must be cancelled before cancelling this Sales Order,La fattura di vendita {0} deve essere cancellata prima di annullare questo ordine di vendita
DocType: Consultation,Age,Età
DocType: Sales Invoice Timesheet,Billing Amount,Fatturazione Importo
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +84,Invalid quantity specified for item {0}. Quantity should be greater than 0.,Quantità non valido specificato per l'elemento {0}. La quantità dovrebbe essere maggiore di 0.
DocType: Company,Default Employee Advance Account,Account avanzato dei dipendenti predefinito
apps/erpnext/erpnext/config/hr.py +60,Applications for leave.,Richieste di Ferie
apps/erpnext/erpnext/accounts/doctype/account/account.py +166,Account with existing transaction can not be deleted,Account con transazione registrate non può essere cancellato
DocType: Vehicle,Last Carbon Check,Ultima verifica carbon
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +102,Legal Expenses,Spese legali
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +140,Please select quantity on row ,Seleziona la quantità in fila
apps/erpnext/erpnext/config/accounts.py +277,Make Opening Sales and Purchase Invoices,Fai aprire le vendite e le fatture di acquisto
DocType: Purchase Invoice,Posting Time,Ora di Registrazione
DocType: Timesheet,% Amount Billed,% Importo Fatturato
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +102,"""Time Per Appointment"" hasn""t been set for Dr {0}. Add it in Physician master.",&quot;Time per Appointment&quot; non è stato impostato per Dr {0}. Aggiungerlo nel master del medico.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +118,Telephone Expenses,Spese telefoniche
DocType: Sales Partner,Logo,Logo
DocType: Naming Series,Check this if you want to force the user to select a series before saving. There will be no default if you check this.,"Seleziona se vuoi forzare l'utente a selezionare una serie prima di salvare, non ci sarà un valore di default."
apps/erpnext/erpnext/stock/get_item_details.py +129,No Item with Serial No {0},Nessun Articolo con Numero di Serie {0}
DocType: Email Digest,Open Notifications,Aperte Notifiche
DocType: Payment Entry,Difference Amount (Company Currency),Differenza Importo (Società di valuta)
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +79,Direct Expenses,spese dirette
apps/erpnext/erpnext/education/doctype/instructor/instructor.py +15,Please setup Instructor Naming System in Education &gt; Education Settings,Installa il Sistema di denominazione degli istruttori in Istruzione&gt; Impostazioni istruzione
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +60,New Customer Revenue,Nuovi Ricavi Cliente
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +119,Travel Expenses,Spese di viaggio
DocType: Maintenance Visit,Breakdown,Esaurimento
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +50,Add custom field Subscription in the doctype {0},Aggiungi abbonamento sul campo personalizzato nel doctype {0}
apps/erpnext/erpnext/controllers/accounts_controller.py +789,Account: {0} with currency: {1} can not be selected,Account: {0} con valuta: {1} non può essere selezionato
DocType: Purchase Receipt Item,Sample Quantity,Quantità del campione
DocType: Manufacturing Settings,"Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.","L&#39;aggiornamento dei costi BOM avviene automaticamente via Scheduler, in base all&#39;ultimo tasso di valutazione / prezzo di listino / ultimo tasso di acquisto di materie prime."
DocType: Bank Reconciliation Detail,Cheque Date,Data Assegno
apps/erpnext/erpnext/accounts/doctype/account/account.py +50,Account {0}: Parent account {1} does not belong to company: {2},Account {0}: conto derivato {1} non appartiene alla società: {2}
DocType: Program Enrollment Tool,Student Applicants,I candidati per studenti
apps/erpnext/erpnext/setup/doctype/company/company.js +77,Successfully deleted all transactions related to this company!,"Tutte le operazioni relative a questa società, sono state cancellate con successo!"
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +21,As on Date,Come in data
DocType: Appraisal,HR,HR
DocType: Program Enrollment,Enrollment Date,Iscrizione Data
DocType: Healthcare Settings,Out Patient SMS Alerts,Avvisi SMS di pazienti
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +100,Probation,prova
apps/erpnext/erpnext/config/hr.py +115,Salary Components,Componenti stipendio
DocType: Program Enrollment Tool,New Academic Year,Nuovo anno accademico
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +809,Return / Credit Note,Ritorno / nota di credito
DocType: Stock Settings,Auto insert Price List rate if missing,Inserimento automatico tasso Listino se mancante
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +23,Total Paid Amount,Importo totale pagato
DocType: Production Order Item,Transferred Qty,Quantità trasferito
apps/erpnext/erpnext/config/learn.py +11,Navigating,Navigazione
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +188,Planning,Pianificazione
DocType: Material Request,Issued,Emesso
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +14,Student Activity,Attività studentesca
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +80,Supplier Id,Id Fornitore
DocType: Payment Request,Payment Gateway Details,Payment Gateway Dettagli
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +267,Quantity should be greater than 0,Quantità deve essere maggiore di 0
DocType: Journal Entry,Cash Entry,Cash Entry
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +17,Child nodes can be only created under 'Group' type nodes,I nodi figli possono essere creati solo sotto i nodi di tipo &#39;Gruppo&#39;
DocType: Leave Application,Half Day Date,Data di mezza giornata
DocType: Academic Year,Academic Year Name,Nome Anno Accademico
DocType: Sales Partner,Contact Desc,Desc Contatto
apps/erpnext/erpnext/config/hr.py +65,"Type of leaves like casual, sick etc.","Tipo di foglie come casuale, malati ecc"
DocType: Email Digest,Send regular summary reports via Email.,Invia relazioni di sintesi periodiche via Email.
DocType: Payment Entry,PE-,PE
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +305,Please set default account in Expense Claim Type {0},Si prega di impostare account predefinito nel tipo di spesa rivendicazione {0}
DocType: Assessment Result,Student Name,Nome dello studente
DocType: Brand,Item Manager,Responsabile Articoli
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +143,Payroll Payable,Payroll da pagare
DocType: Buying Settings,Default Supplier Type,Tipo Fornitore Predefinito
DocType: Plant Analysis,Collection Datetime,Collezione Datetime
DocType: Production Order,Total Operating Cost,Totale costi di esercizio
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +171,Note: Item {0} entered multiple times,Nota : Articolo {0} inserito più volte
apps/erpnext/erpnext/config/selling.py +41,All Contacts.,Tutti i contatti.
apps/erpnext/erpnext/public/js/setup_wizard.js +71,Company Abbreviation,Abbreviazione Società
apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +57,User {0} does not exist,Utente {0} non esiste
DocType: Payment Term,Day(s) after invoice date,Giorno (i) dopo la data della fattura
DocType: Payment Schedule,Payment Schedule,Programma di pagamento
DocType: Subscription,SUB-,SUB-
DocType: Item Attribute Value,Abbreviation,Abbreviazione
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +182,Payment Entry already exists,La scrittura contabile del Pagamento esiste già
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +36,Not authroized since {0} exceeds limits,Non autorizzato poiché {0} supera i limiti
apps/erpnext/erpnext/config/hr.py +110,Salary template master.,Modello Stipendio master.
apps/erpnext/erpnext/healthcare/setup.py +241,Pathology,Patologia
DocType: Restaurant Order Entry,Restaurant Table,Ristorante Tavolo
DocType: Leave Type,Max Days Leave Allowed,Max giorni di ferie domestici
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +63,Set Tax Rule for shopping cart,Set di regole fiscali per carrello della spesa
DocType: Purchase Invoice,Taxes and Charges Added,Tasse e spese aggiuntive
,Sales Funnel,imbuto di vendita
apps/erpnext/erpnext/setup/doctype/company/company.py +48,Abbreviation is mandatory,L'abbreviazione è obbligatoria
DocType: Project,Task Progress,Avanzamento attività
apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html +7,Cart,Carrello
,Qty to Transfer,Qtà da Trasferire
apps/erpnext/erpnext/config/selling.py +13,Quotes to Leads or Customers.,Preventivo a Leads o a Clienti.
DocType: Stock Settings,Role Allowed to edit frozen stock,Ruolo ammessi da modificare stock congelato
,Territory Target Variance Item Group-Wise,Territorio di destinazione Varianza articolo Group- Wise
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +143,All Customer Groups,Tutti i gruppi di clienti
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +114,Accumulated Monthly,Accantonamento Mensile
apps/erpnext/erpnext/controllers/accounts_controller.py +750,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} è obbligatorio. Forse il record di cambio di valuta non è stato creato per {1} {2}.
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +41,Tax Template is mandatory.,Tax modello è obbligatoria.
apps/erpnext/erpnext/accounts/doctype/account/account.py +44,Account {0}: Parent account {1} does not exist,Account {0}: conto derivato {1} non esistente
DocType: Purchase Invoice Item,Price List Rate (Company Currency),Prezzo di listino (Valuta Azienda)
DocType: Products Settings,Products Settings,Impostazioni Prodotti
,Item Price Stock,Articolo Prezzo Stock
DocType: Lab Prescription,Test Created,Test creati
DocType: Healthcare Settings,Custom Signature in Print,Firma personalizzata in stampa
DocType: Account,Temporary,Temporaneo
DocType: Program,Courses,corsi
DocType: Monthly Distribution Percentage,Percentage Allocation,Percentuale di allocazione
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +128,Secretary,segretario
DocType: Global Defaults,"If disable, 'In Words' field will not be visible in any transaction","Se disable, &#39;In Words&#39; campo non saranno visibili in qualsiasi transazione"
DocType: Serial No,Distinct unit of an Item,Un'unità distinta di un elemento
DocType: Supplier Scorecard Criteria,Criteria Name,Criteri Nome
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1289,Please set Company,Imposti la Società
DocType: Pricing Rule,Buying,Acquisti
apps/erpnext/erpnext/config/agriculture.py +24,Diseases & Fertilizers,Malattie e fertilizzanti
DocType: HR Settings,Employee Records to be created by,Informazioni del dipendenti da creare a cura di
DocType: Patient,AB Negative,AB negativo
DocType: Sample Collection,SMPL-,SMPL-
DocType: POS Profile,Apply Discount On,Applicare sconto su
DocType: Member,Membership Type,Tipo di abbonamento
,Reqd By Date,Reqd Per Data
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +140,Creditors,Creditori
DocType: Assessment Plan,Assessment Name,Nome valutazione
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +96,Row # {0}: Serial No is mandatory,Fila # {0}: N. di serie è obbligatoria
DocType: Purchase Taxes and Charges,Item Wise Tax Detail,Voce Wise fiscale Dettaglio
apps/erpnext/erpnext/public/js/setup_wizard.js +71,Institute Abbreviation,Abbreviazione Institute
,Item-wise Price List Rate,Articolo -saggio Listino Tasso
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +966,Supplier Quotation,Preventivo Fornitore
DocType: Quotation,In Words will be visible once you save the Quotation.,"""In Parole"" sarà visibile una volta che si salva il Preventivo."
apps/erpnext/erpnext/utilities/transaction_base.py +153,Quantity ({0}) cannot be a fraction in row {1},La quantità ({0}) non può essere una frazione nella riga {1}
DocType: Consultation,C-,C-
DocType: Attendance,ATT-,la tentata
apps/erpnext/erpnext/stock/doctype/item/item.py +473,Barcode {0} already used in Item {1},Codice a barre {0} già utilizzato nel Prodotto {1}
apps/erpnext/erpnext/config/selling.py +86,Rules for adding shipping costs.,Regole per l'aggiunta di spese di spedizione .
DocType: Item,Opening Stock,Disponibilità Iniziale
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +20,Customer is required,Il Cliente è tenuto
DocType: Lab Test,Result Date,Data di risultato
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +20,{0} is mandatory for Return,{0} è obbligatorio per Return
DocType: Purchase Order,To Receive,Ricevere
apps/erpnext/erpnext/utilities/user_progress.py +249,user@example.com,user@example.com
DocType: Asset,Asset Owner,Proprietario del bene
DocType: Employee,Personal Email,Email personale
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +57,Total Variance,Varianza totale
DocType: Accounts Settings,"If enabled, the system will post accounting entries for inventory automatically.","Se abilitato, il sistema pubblicherà le scritture contabili per l&#39;inventario automatico."
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +15,Brokerage,mediazione
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +232,Attendance for employee {0} is already marked for this day,Assistenza per dipendente {0} è già contrassegnata per questo giorno
DocType: Production Order Operation,"in Minutes
Updated via 'Time Log'",Aggiornato da pochi minuti tramite 'Time Log'
DocType: Customer,From Lead,Da Contatto
apps/erpnext/erpnext/config/manufacturing.py +13,Orders released for production.,Gli ordini rilasciati per la produzione.
apps/erpnext/erpnext/public/js/account_tree_grid.js +66,Select Fiscal Year...,Selezionare l'anno fiscale ...
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +561,POS Profile required to make POS Entry,POS Profilo tenuto a POS Entry
DocType: Program Enrollment Tool,Enroll Students,iscrivere gli studenti
DocType: Lab Test,Approved Date,Data approvata
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +21,Standard Selling,Listino di Vendita
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +143,Atleast one warehouse is mandatory,È obbligatorio almeno un deposito
DocType: Serial No,Out of Warranty,Fuori Garanzia
DocType: BOM Update Tool,Replace,Sostituire
apps/erpnext/erpnext/templates/includes/product_list.js +42,No products found.,Nessun prodotto trovato.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +358,{0} against Sales Invoice {1},{0} per fattura di vendita {1}
DocType: Antibiotic,Laboratory User,Utente del laboratorio
DocType: Sales Invoice,SINV-,SINV-
DocType: Request for Quotation Item,Project Name,Nome del progetto
DocType: Customer,Mention if non-standard receivable account,Menzione se conto credito non standard
DocType: Journal Entry Account,If Income or Expense,Se proventi od oneri
DocType: Production Order,Required Items,Articoli richiesti
DocType: Stock Ledger Entry,Stock Value Difference,Differenza Valore Giacenza
apps/erpnext/erpnext/config/learn.py +234,Human Resource,Risorsa Umana
DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,Pagamento Riconciliazione di pagamento
DocType: Disease,Treatment Task,Task di trattamento
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +38,Tax Assets,Attività fiscali
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +630,Production Order has been {0},L&#39;ordine di produzione è stato {0}
DocType: BOM Item,BOM No,BOM n.
DocType: Instructor,INS/,INS /
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +158,Journal Entry {0} does not have account {1} or already matched against other voucher,La Scrittura Contabile {0} non ha conto {1} o già confrontato con un altro buono
DocType: Item,Moving Average,Media Mobile
DocType: BOM Update Tool,The BOM which will be replaced,La distinta base che sarà sostituita
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +46,Electronic Equipments,Apparecchiature elettroniche
DocType: Asset,Maintenance Required,Manutenzione necessaria
DocType: Account,Debit,Dare
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +49,Leaves must be allocated in multiples of 0.5,"Le ferie devono essere assegnati in multipli di 0,5"
DocType: Production Order,Operation Cost,Operazione Costo
apps/erpnext/erpnext/config/hr.py +29,Upload attendance from a .csv file,Carica presenze da un file. Csv
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +45,Outstanding Amt,Importo Dovuto
DocType: Sales Person,Set targets Item Group-wise for this Sales Person.,Fissare obiettivi Item Group-saggio per questo venditore.
DocType: Stock Settings,Freeze Stocks Older Than [Days],Congelare Stocks Older Than [ giorni]
apps/erpnext/erpnext/controllers/accounts_controller.py +579,Row #{0}: Asset is mandatory for fixed asset purchase/sale,Row # {0}: L'indicazione dell'Asset è obbligatorio per acquisto/vendita di Beni Strumentali
DocType: Asset Maintenance Team,Maintenance Team Name,Nome del team di manutenzione
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +42,"If two or more Pricing Rules are found based on the above conditions, Priority is applied. Priority is a number between 0 to 20 while default value is zero (blank). Higher number means it will take precedence if there are multiple Pricing Rules with same conditions.","Se due o più regole sui prezzi sono trovate delle condizioni di cui sopra, viene applicata la priorità. La priorità è un numero compreso tra 0 a 20, mentre il valore di default è pari a zero (vuoto). Numero maggiore significa che avrà la precedenza se ci sono più regole sui prezzi con le stesse condizioni."
apps/erpnext/erpnext/controllers/trends.py +36,Fiscal Year: {0} does not exists,Anno fiscale: {0} non esiste
DocType: Currency Exchange,To Currency,Per valuta
DocType: Leave Block List,Allow the following users to approve Leave Applications for block days.,Consentire i seguenti utenti per approvare le richieste per i giorni di blocco.
apps/erpnext/erpnext/config/hr.py +137,Types of Expense Claim.,Tipi di Nota Spese.
apps/erpnext/erpnext/controllers/selling_controller.py +144,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},Il tasso di vendita per l&#39;elemento {0} è inferiore a quello {1}. Il tasso di vendita dovrebbe essere almeno {2}
DocType: Item,Taxes,Tasse
DocType: Purchase Invoice Item,Weight Per Unit,Peso per unità
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +344,Paid and Not Delivered,Pagato e Non Consegnato
DocType: Project,Default Cost Center,Centro di costo predefinito
DocType: Bank Guarantee,End Date,Data di Fine
apps/erpnext/erpnext/config/stock.py +7,Stock Transactions,Documenti di magazzino
DocType: Budget,Budget Accounts,contabilità di bilancio
DocType: Employee,Internal Work History,Storia di lavoro interni
DocType: Depreciation Schedule,Accumulated Depreciation Amount,Importo fondo ammortamento
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +42,Private Equity,private Equity
DocType: Supplier Scorecard Variable,Supplier Scorecard Variable,Variabile della Scorecard fornitore
DocType: Employee Loan,Fully Disbursed,interamente versato
DocType: Maintenance Visit,Customer Feedback,Opinione Cliente
DocType: Account,Expense,Spesa
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js +36,Score cannot be greater than Maximum Score,Il punteggio non può essere maggiore del punteggio massimo
apps/erpnext/erpnext/utilities/user_progress.py +126,Customers and Suppliers,Clienti e Fornitori
DocType: Item Attribute,From Range,Da Gamma
DocType: BOM,Set rate of sub-assembly item based on BOM,Imposta tasso di elemento di sotto-montaggio basato su BOM
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +98,Syntax error in formula or condition: {0},Errore di sintassi nella formula o una condizione: {0}
DocType: Daily Work Summary Settings Company,Daily Work Summary Settings Company,Quotidiano lavoro riepilogo delle impostazioni azienda
apps/erpnext/erpnext/stock/utils.py +123,Item {0} ignored since it is not a stock item,Articolo {0} ignorato poiché non è in Giacenza
DocType: Appraisal,APRSL,APRSL
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +109,Submit this Production Order for further processing.,Conferma questo ordine di produzione per l'ulteriore elaborazione .
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +23,"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","Per non applicare l'articolo Pricing in una determinata operazione, tutte le norme sui prezzi applicabili devono essere disabilitati."
DocType: Payment Term,Day(s) after the end of the invoice month,Giorno / i dopo la fine del mese della fattura
DocType: Assessment Group,Parent Assessment Group,Capogruppo di valutazione
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +27,Jobs,Posizioni
,Sales Order Trends,Tendenze Sales Order
DocType: Employee,Held On,Tenutasi il
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +36,Production Item,Produzione Voce
,Employee Information,Informazioni Dipendente
DocType: Stock Entry Detail,Additional Cost,Costo aggiuntivo
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +39,"Can not filter based on Voucher No, if grouped by Voucher","Non è possibile filtrare sulla base di Voucher No , se raggruppati per Voucher"
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +916,Make Supplier Quotation,Crea un Preventivo Fornitore
DocType: Quality Inspection,Incoming,In arrivo
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py +47,Assessment Result record {0} already exists.,Record Record di risultato {0} esiste già.
DocType: BOM,Materials Required (Exploded),Materiali necessari (dettagli)
apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py +60,Please set Company filter blank if Group By is 'Company',Impostare il filtro aziendale vuoto se Group By è &#39;Azienda&#39;
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +66,Posting Date cannot be future date,La Data di Registrazione non può essere una data futura
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +101,Row # {0}: Serial No {1} does not match with {2} {3},Fila # {0}: N. di serie {1} non corrisponde con {2} {3}
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10,for generating the recurring,per generare il ricorrente
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +86,Casual Leave,Casual Leave
apps/erpnext/erpnext/config/healthcare.py +138,Lab Test UOM.,Lab Test UOM.
DocType: Agriculture Task,End Day,Fine giornata
DocType: Batch,Batch ID,Lotto ID
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +378,Note: {0},Nota : {0}
,Delivery Note Trends,Tendenze Documenti di Trasporto
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +112,This Week's Summary,Sintesi di questa settimana
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +20,In Stock Qty,Qtà in Stock
DocType: Delivery Trip,Calculate Estimated Arrival Times,Calcola i tempi di arrivo stimati
apps/erpnext/erpnext/accounts/general_ledger.py +111,Account: {0} can only be updated via Stock Transactions,Account: {0} può essere aggiornato solo tramite documenti di magazzino
DocType: Student Group Creation Tool,Get Courses,Ottieni Corsi
DocType: GL Entry,Party,Partner
DocType: Healthcare Settings,Patient Name,Nome paziente
DocType: Variant Field,Variant Field,Campo di variante
DocType: Sales Order,Delivery Date,Data Consegna
DocType: Opportunity,Opportunity Date,Data Opportunità
DocType: Purchase Receipt,Return Against Purchase Receipt,Ricevuta di Ritorno contro Ricevuta di Acquisto
DocType: Water Analysis,Person Responsible,Persona responsabile
DocType: Request for Quotation Item,Request for Quotation Item,Articolo della richiesta di offerta
DocType: Purchase Order,To Bill,Da Fatturare
DocType: Material Request,% Ordered,% Ordinato
DocType: Education Settings,"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.","Per il corso del corso, il Corso sarà convalidato per ogni Studente dai corsi iscritti in iscrizione al programma."
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +103,Piecework,lavoro a cottimo
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +71,Avg. Buying Rate,Avg. Buying Rate
DocType: Task,Actual Time (in Hours),Tempo reale (in ore)
DocType: Employee,History In Company,Storia aziendale
apps/erpnext/erpnext/config/learn.py +107,Newsletters,Newsletters
DocType: Drug Prescription,Description/Strength,Descrizione / Forza
DocType: Stock Ledger Entry,Stock Ledger Entry,Voce Inventario
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +83,Same item has been entered multiple times,Lo stesso articolo è stato inserito più volte
DocType: Department,Leave Block List,Lascia il blocco lista
DocType: Purchase Invoice,Tax ID,P. IVA / Cod. Fis.
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +192,Item {0} is not setup for Serial Nos. Column must be blank,L'articolo {0} non ha Numeri di Serie. La colonna deve essere vuota
DocType: Accounts Settings,Accounts Settings,Impostazioni Conti
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +11,Approve,Approvare
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +51,"Malformatted address for {0}, please fix to continue.","Indirizzo malformattato per {0}, correggere per continuare."
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +28,"Number of new Account, it will be included in the account name as a prefix","Numero del nuovo account, sarà incluso nel nome dell&#39;account come prefisso"
DocType: Maintenance Team Member,Team Member,Membro della squadra
apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +151,No Result to submit,Nessun risultato da presentare
DocType: Customer,Sales Partner and Commission,Partner vendite e Commissione
DocType: Employee Loan,Rate of Interest (%) / Year,Tasso di interesse (%) / anno
,Project Quantity,Progetto Quantità
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +79,"Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'","Totale {0} per tutti gli elementi è pari a zero, può essere che si dovrebbe cambiare &#39;distribuire oneri corrispondenti&#39;"
DocType: Opportunity,To Discuss,Da Discutere
apps/erpnext/erpnext/stock/stock_ledger.py +375,{0} units of {1} needed in {2} to complete this transaction.,{0} unità di {1} necessarie in {2} per completare la transazione.
DocType: Loan Type,Rate of Interest (%) Yearly,Tasso di interesse (%) Performance
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +71,Temporary Accounts,Conti provvisori
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +207,Black,Nero
DocType: BOM Explosion Item,BOM Explosion Item,BOM Articolo Esploso
DocType: Account,Auditor,Uditore
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +132,{0} items produced,{0} articoli prodotti
apps/erpnext/erpnext/utilities/user_progress.py +55,Learn More,Per saperne di più
DocType: Cheque Print Template,Distance from top edge,Distanza dal bordo superiore
apps/erpnext/erpnext/stock/get_item_details.py +360,Price List {0} is disabled or does not exist,Listino {0} è disattivato o non esiste
DocType: Purchase Invoice,Return,Ritorno
DocType: Production Order Operation,Production Order Operation,Ordine di produzione Operation
DocType: Pricing Rule,Disable,Disattiva
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +186,Mode of payment is required to make a payment,Modalità di pagamento è richiesto di effettuare un pagamento
DocType: Project Task,Pending Review,In attesa recensione
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +14,"Edit in full page for more options like assets, serial nos, batches etc.","Modifica in pagina intera per ulteriori opzioni come risorse, numero di serie, lotti ecc."
apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +10,Appointments and Consultations,Appuntamenti e consultazioni
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +41,{0} - {1} is not enrolled in the Batch {2},{0} - {1} non è iscritto nel gruppo {2}
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +113,"Asset {0} cannot be scrapped, as it is already {1}","Asset {0} non può essere gettata, come è già {1}"
DocType: Task,Total Expense Claim (via Expense Claim),Rimborso spese totale (via Expense Claim)
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +177,Mark Absent,Contrassegna come Assente
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +40,Failed to setup company,Impossibile impostare la società
DocType: Asset Repair,Asset Repair,Riparazione delle risorse
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +140,Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2},Riga {0}: Valuta del BOM # {1} deve essere uguale alla valuta selezionata {2}
DocType: Journal Entry Account,Exchange Rate,Tasso di cambio:
DocType: Patient,Additional information regarding the patient,Ulteriori informazioni sul paziente
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +579,Sales Order {0} is not submitted,L'ordine di vendita {0} non è stato presentato
DocType: Homepage,Tag Line,Tag Linea
DocType: Fee Component,Fee Component,Fee Componente
apps/erpnext/erpnext/config/hr.py +204,Fleet Management,Gestione della flotta
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +964,Add items from,Aggiungere articoli da
apps/erpnext/erpnext/config/agriculture.py +7,Crops & Lands,Colture e terre
DocType: Cheque Print Template,Regular,Regolare
DocType: Fertilizer,Density (if liquid),Densità (se liquido)
apps/erpnext/erpnext/education/doctype/course/course.py +20,Total Weightage of all Assessment Criteria must be 100%,Weightage totale di tutti i criteri di valutazione deve essere al 100%
DocType: Purchase Order Item,Last Purchase Rate,Ultima tasso di acquisto
DocType: Account,Asset,attività
DocType: Project Task,Task ID,ID Attività
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +84,Stock cannot exist for Item {0} since has variants,Stock non può esistere per la voce {0} dal ha varianti
DocType: Lab Test,Mobile,Mobile
,Sales Person-wise Transaction Summary,Sales Person-saggio Sintesi dell&#39;Operazione
DocType: Training Event,Contact Number,Numero di contatto
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +74,Warehouse {0} does not exist,Magazzino {0} non esiste
DocType: Monthly Distribution,Monthly Distribution Percentages,Percentuali Distribuzione Mensile
apps/erpnext/erpnext/stock/doctype/batch/batch.py +38,The selected item cannot have Batch,La voce selezionata non può avere Batch
DocType: Delivery Note,% of materials delivered against this Delivery Note,% dei materiali consegnati di questa Bolla di Consegna
DocType: Asset Maintenance Log,Has Certificate,Ha certificato
DocType: Project,Customer Details,Dettagli Cliente
DocType: Asset,Check if Asset requires Preventive Maintenance or Calibration,Controllare se Asset richiede manutenzione preventiva o calibrazione
DocType: Employee,Reports to,Reports a
,Unpaid Expense Claim,Richiesta di spesa non retribuita
DocType: Payment Entry,Paid Amount,Importo pagato
apps/erpnext/erpnext/utilities/user_progress.py +155,Explore Sales Cycle,Esplora Ciclo di vendita
DocType: Assessment Plan,Supervisor,Supervisore
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +70,Online,online
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +867,Retention Stock Entry,Retention stock entry
,Available Stock for Packing Items,Stock Disponibile per Imballaggio Prodotti
DocType: Item Variant,Item Variant,Elemento Variant
DocType: Assessment Result Tool,Assessment Result Tool,Strumento di valutazione dei risultati
DocType: BOM Scrap Item,BOM Scrap Item,BOM Scrap Articolo
apps/erpnext/erpnext/accounts/page/pos/pos.js +886,Submitted orders can not be deleted,gli Ordini Confermati non possono essere eliminati
apps/erpnext/erpnext/accounts/doctype/account/account.py +116,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Saldo a bilancio già nel debito, non è permesso impostare il 'Saldo Futuro' come 'credito'"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +118,Quality Management,Gestione della qualità
apps/erpnext/erpnext/assets/doctype/asset/asset.py +41,Item {0} has been disabled,Voce {0} è stato disabilitato
DocType: Project,Total Billable Amount (via Timesheets),Importo totale fatturabile (tramite Timesheets)
DocType: Agriculture Task,Previous Business Day,Giorno lavorativo precedente
DocType: Employee Loan,Repay Fixed Amount per Period,Rimborsare importo fisso per Periodo
apps/erpnext/erpnext/buying/utils.py +47,Please enter quantity for Item {0},Inserite la quantità per articolo {0}
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +89,Credit Note Amt,Nota di credito Amt
DocType: Employee External Work History,Employee External Work History,Storia lavorativa esterna del Dipendente
DocType: Opening Invoice Creation Tool,Purchase,Acquisto
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Balance Qty,Saldo Quantità
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +20,Goals cannot be empty,Obiettivi non possono essere vuoti
DocType: Item Group,Parent Item Group,Gruppo Padre
DocType: Appointment Type,Appointment Type,Tipo di appuntamento
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +21,{0} for {1},{0} per {1}
DocType: Healthcare Settings,Valid number of days,Valido numero di giorni
apps/erpnext/erpnext/setup/doctype/company/company.js +35,Cost Centers,Centri di costo
DocType: Land Unit,Linked Plant Analysis,Analisi delle piante collegate
DocType: Purchase Receipt,Rate at which supplier's currency is converted to company's base currency,Tasso al quale la valuta del fornitore viene convertita in valuta di base dell'azienda
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +36,Row #{0}: Timings conflicts with row {1},Row # {0}: conflitti Timings con riga {1}
DocType: Purchase Invoice Item,Allow Zero Valuation Rate,Consenti il tasso di valorizzazione Zero
DocType: Training Event Employee,Invited,Invitato
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +177,Multiple active Salary Structures found for employee {0} for the given dates,Molteplici strutture salariali attivi trovati per dipendente {0} per le date indicate
apps/erpnext/erpnext/config/accounts.py +308,Setup Gateway accounts.,Conti Gateway Setup.
DocType: Employee,Employment Type,Tipo Dipendente
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +42,Fixed Assets,immobilizzazioni
DocType: Payment Entry,Set Exchange Gain / Loss,Guadagno impostato Exchange / Perdita
,GST Purchase Register,Registro degli acquisti GST
,Cash Flow,Flusso di cassa
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +92,Application period cannot be across two alocation records,Periodo di applicazione non può essere tra due record alocation
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +25,Combined invoice portion must equal 100%,La parte della fattura combinata deve essere uguale al 100%
DocType: Item Group,Default Expense Account,Conto spese predefinito
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +53,Student Email ID,Student Email ID
DocType: Employee,Notice (days),Avviso ( giorni )
DocType: Tax Rule,Sales Tax Template,Sales Tax Template
apps/erpnext/erpnext/accounts/page/pos/pos.js +2467,Select items to save the invoice,Selezionare gli elementi per salvare la fattura
DocType: Employee,Encashment Date,Data Incasso
DocType: Training Event,Internet,Internet
DocType: Special Test Template,Special Test Template,Modello di prova speciale
DocType: Account,Stock Adjustment,Regolazione della
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +34,Default Activity Cost exists for Activity Type - {0},Esiste di default Attività Costo per il tipo di attività - {0}
DocType: Production Order,Planned Operating Cost,Planned Cost operativo
DocType: Academic Term,Term Start Date,Term Data di inizio
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18,Opp Count,Opp Count
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +242,Please find attached {0} #{1},In allegato {0} # {1}
apps/erpnext/erpnext/controllers/accounts_controller.py +701,Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,L&#39;importo totale del pagamento nel programma di pagamento deve essere uguale al totale totale / arrotondato
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +34,Bank Statement balance as per General Ledger,Estratto conto banca come da Contabilità Generale
DocType: Job Applicant,Applicant Name,Nome del Richiedente
DocType: Authorization Rule,Customer / Item Name,Cliente / Nome Articolo
DocType: Product Bundle,"Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. 

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

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

Note: BOM = Bill of Materials","Gruppo aggregato di elementi ** ** in un&#39;altra Voce ** **. Ciò è utile se in fase di installazione una certa Articoli ** ** in un pacchetto e si mantiene il punto sulle ** ** Elementi imballate e non l&#39;aggregato ** ** Item. Il pacchetto ** ** Voce avrà &quot;è articolo di&quot; come &quot;No&quot; e &quot;Is Item vendite&quot; come &quot;Yes&quot;. Per esempio: Se state vendendo computer portatili e zaini separatamente e hanno un prezzo speciale se il cliente acquista entrambi, poi il computer portatile + zaino sarà un nuovo bundle di prodotto Articolo. Nota: BOM = Bill of Materials"
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +42,Serial No is mandatory for Item {0},Numero d'ordine è obbligatorio per la voce {0}
DocType: Item Variant Attribute,Attribute,Attributo
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +43,Please specify from/to range,Si prega di specificare da / a gamma
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +28,Opening {0} Invoice created,Apertura della {0} fattura creata
DocType: Serial No,Under AMC,Sotto AMC
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +55,Item valuation rate is recalculated considering landed cost voucher amount,Voce tasso di valorizzazione viene ricalcolato considerando atterrato importo buono costo
apps/erpnext/erpnext/config/selling.py +153,Default settings for selling transactions.,Impostazioni predefinite per la vendita di transazioni.
DocType: Guardian,Guardian Of ,guardian of
DocType: Grading Scale Interval,Threshold,Soglia
DocType: BOM Update Tool,Current BOM,Distinta Materiali Corrente
apps/erpnext/erpnext/public/js/utils.js +49,Add Serial No,Aggiungi Numero di Serie
DocType: Production Order Item,Available Qty at Source Warehouse,Qtà disponibile presso Source Warehouse
apps/erpnext/erpnext/config/support.py +22,Warranty,Garanzia
DocType: Purchase Invoice,Debit Note Issued,Nota di Debito Emessa
DocType: Production Order,Warehouses,Magazzini
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +18,{0} asset cannot be transferred,{0} attività non può essere trasferito
apps/erpnext/erpnext/stock/doctype/item/item.js +80,This Item is a Variant of {0} (Template).,Questa voce è una variante di {0} (Template).
DocType: Workstation,per hour,all'ora
apps/erpnext/erpnext/config/buying.py +7,Purchasing,Acquisto
DocType: Announcement,Announcement,Annuncio
DocType: Education Settings,"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.","Per il gruppo studente basato su batch, il gruppo di studenti sarà convalidato per ogni studente dall&#39;iscrizione al programma."
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +51,Warehouse can not be deleted as stock ledger entry exists for this warehouse.,Magazzino non può essere eliminato siccome esiste articolo ad inventario per questo Magazzino .
apps/erpnext/erpnext/public/js/setup_wizard.js +25,Distribution,Distribuzione
DocType: Expense Claim Advance,Expense Claim Advance,Addebito reclamo spese
DocType: Lab Test,Report Preference,Preferenze di rapporto
apps/erpnext/erpnext/config/non_profit.py +43,Volunteer information.,Volontariato
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +133,Project Manager,Project Manager
,Quoted Item Comparison,Articolo Citato Confronto
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +34,Overlap in scoring between {0} and {1},Sovrapposizione nel punteggio tra {0} e {1}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +114,Dispatch,Spedizione
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +73,Max discount allowed for item: {0} is {1}%,Sconto massimo consentito per la voce: {0} {1}%
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +176,Net Asset value as on,valore patrimoniale netto su
DocType: Crop,Produce,Produrre
DocType: Account,Receivable,Ricevibile
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +308,Row #{0}: Not allowed to change Supplier as Purchase Order already exists,Fila # {0}: Non è consentito cambiare il Fornitore quando l'Ordine di Acquisto esiste già
DocType: Accounts Settings,Role that is allowed to submit transactions that exceed credit limits set.,Ruolo che è consentito di presentare le transazioni che superano i limiti di credito stabiliti.
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +978,Select Items to Manufacture,Selezionare gli elementi da Fabbricazione
DocType: Delivery Stop,Delivery Stop,Fermata di consegna
apps/erpnext/erpnext/accounts/page/pos/pos.js +954,"Master data syncing, it might take some time","sincronizzazione dei dati principali, potrebbe richiedere un certo tempo"
DocType: Item,Material Issue,Fornitura materiale
DocType: Employee Education,Qualification,Qualifica
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +40,View Salary Slips,Visualizza Salary Slips
DocType: Item Price,Item Price,Prezzo Articoli
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +48,Soap & Detergent,Soap & Detergente
DocType: BOM,Show Items,Mostra elementi
apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.py +30,From Time cannot be greater than To Time.,Da tempo non può essere superiore al tempo.
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +74,Do you want to notify all the customers by email?,Vuoi avvisare tutti i clienti via email?
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +36,Motion Picture & Video,Motion Picture & Video
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +5,Ordered,Ordinato
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +51,Resume,Curriculum vitae
DocType: Salary Detail,Component,Componente
DocType: Assessment Criteria,Assessment Criteria Group,Criteri di valutazione del Gruppo
DocType: Healthcare Settings,Patient Name By,Nome del paziente
apps/erpnext/erpnext/assets/doctype/asset/asset.py +72,Opening Accumulated Depreciation must be less than equal to {0},L&#39;apertura del deprezzamento accumulato deve essere inferiore uguale a {0}
DocType: Warehouse,Warehouse Name,Nome Deposito
DocType: Naming Series,Select Transaction,Selezionare Transaction
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +30,Please enter Approving Role or Approving User,Inserisci Approvazione ruolo o Approvazione utente
DocType: Journal Entry,Write Off Entry,Entry di Svalutazione
DocType: BOM,Rate Of Materials Based On,Tasso di materiali a base di
apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +21,Support Analtyics,Analtyics supporto
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +102,Uncheck all,Deseleziona tutto
DocType: POS Profile,Terms and Conditions,Termini e Condizioni
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +49,To Date should be within the Fiscal Year. Assuming To Date = {0},'A Data' deve essere entro l'anno fiscale. Assumendo A Data = {0}
DocType: Employee,"Here you can maintain height, weight, allergies, medical concerns etc","Qui è possibile mantenere l'altezza, il peso, le allergie, le preoccupazioni mediche ecc"
DocType: Leave Block List,Applies to Company,Applica ad Azienda
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +222,Cannot cancel because submitted Stock Entry {0} exists,Impossibile annullare perché esiste un movimento di magazzino {0}
DocType: Employee Loan,Disbursement Date,L&#39;erogazione Data
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +80,'Recipients' not specified,&#39;Destinatari&#39; non specificati
DocType: BOM Update Tool,Update latest price in all BOMs,Aggiorna l&#39;ultimo prezzo in tutte le BOM
apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +40,Medical Record,Cartella medica
DocType: Vehicle,Vehicle,Veicolo
DocType: Purchase Invoice,In Words,In Parole
apps/erpnext/erpnext/hr/doctype/training_result/training_result.py +15,{0} must be submitted,{0} deve essere inviato
DocType: POS Profile,Item Groups,Gruppi Articoli
apps/erpnext/erpnext/hr/doctype/employee/employee.py +221,Today is {0}'s birthday!,Oggi è {0} 's compleanno!
DocType: Production Planning Tool,Material Request For Warehouse,Richiesta di materiale per il magazzino
DocType: Sales Order Item,For Production,Per la produzione
DocType: Payment Request,payment_url,payment_url
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +163,Please add a Temporary Opening account in Chart of Accounts,Aggiungi un account di apertura temporanea nel piano dei conti
DocType: Customer,Customer Primary Contact,Contatto principale cliente
DocType: Project Task,View Task,Visualizza Attività
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +22,Opp/Lead %,Opp / Lead%
DocType: Material Request,MREQ-,MREQ-
DocType: Payment Schedule,Invoice Portion,Porzione di fattura
,Asset Depreciations and Balances,Asset Ammortamenti e saldi
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +357,Amount {0} {1} transferred from {2} to {3},Importo {0} {1} trasferito da {2} a {3}
DocType: Sales Invoice,Get Advances Received,ottenere anticipo Ricevuto
DocType: Email Digest,Add/Remove Recipients,Aggiungere/Rimuovere Destinatario
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +486,Transaction not allowed against stopped Production Order {0},Operazione non ammessi contro Production smesso di ordine {0}
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +19,"To set this Fiscal Year as Default, click on 'Set as Default'","Per impostare questo anno fiscale come predefinito , clicca su ' Imposta come predefinito'"
apps/erpnext/erpnext/projects/doctype/project/project.py +216,Join,Aderire
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +20,Shortage Qty,Carenza Quantità
apps/erpnext/erpnext/stock/doctype/item/item.py +645,Cannot change Variant properties after stock transction. You will have to make a new Item to do this.,Non è possibile modificare le proprietà Variant dopo la trascrizione delle azioni. Dovrai creare un nuovo oggetto per farlo.
apps/erpnext/erpnext/stock/doctype/item/item.py +685,Item variant {0} exists with same attributes,Variante item {0} esiste con le stesse caratteristiche
DocType: Employee Loan,Repay from Salary,Rimborsare da Retribuzione
DocType: Leave Application,LAP/,GIRO/
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +347,Requesting payment against {0} {1} for amount {2},Richiesta di Pagamento contro {0} {1} per quantità {2}
DocType: Salary Slip,Salary Slip,Busta paga
DocType: Lead,Lost Quotation,Preventivo Perso
apps/erpnext/erpnext/utilities/user_progress.py +218,Student Batches,Lotti degli studenti
DocType: Pricing Rule,Margin Rate or Amount,Margine  % o Importo
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +48,'To Date' is required,'Alla Data' è obbligatorio
DocType: Packing Slip,"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Generare documenti di trasporto per i pacchetti da consegnare. Utilizzato per comunicare il numero del pacchetto, contenuto della confezione e il suo peso."
DocType: Sales Invoice Item,Sales Order Item,Articolo dell'Ordine di Vendita
DocType: Salary Slip,Payment Days,Giorni di Pagamento
DocType: Stock Settings,Convert Item Description to Clean HTML,Converti la descrizione dell&#39;oggetto in Pulisci HTML
DocType: Patient,Dormant,inattivo
DocType: Salary Slip,Total Interest Amount,Importo totale degli interessi
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +125,Warehouses with child nodes cannot be converted to ledger,Magazzini con nodi figli non possono essere convertiti a Ledger
DocType: BOM,Manage cost of operations,Gestire costi operazioni
DocType: Accounts Settings,Stale Days,Giorni Stalli
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.","Quando una qualsiasi delle operazioni controllate sono &quot;inviati&quot;, una e-mail a comparsa visualizzata automaticamente per inviare una e-mail agli associati &quot;Contatto&quot; in tale operazione, con la transazione come allegato. L&#39;utente può o non può inviare l&#39;e-mail."
apps/erpnext/erpnext/config/setup.py +14,Global Settings,Impostazioni Globali
DocType: Crop,Row Spacing UOM,UOM di spaziatura righe
DocType: Assessment Result Detail,Assessment Result Detail,La valutazione dettagliata dei risultati
DocType: Employee Education,Employee Education,Istruzione Dipendente
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +53,Duplicate item group found in the item group table,gruppo di articoli duplicato trovato nella tabella gruppo articoli
DocType: Land Unit,Parent Land Unit,Unità territoriale genitore
apps/erpnext/erpnext/public/js/controllers/transaction.js +1045,It is needed to fetch Item Details.,E &#39;necessario per recuperare Dettagli elemento.
DocType: Fertilizer,Fertilizer Name,Nome del fertilizzante
DocType: Salary Slip,Net Pay,Retribuzione Netta
DocType: Account,Account,Account
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +217,Serial No {0} has already been received,Serial No {0} è già stato ricevuto
,Requested Items To Be Transferred,Voci si chiede il trasferimento
DocType: Expense Claim,Vehicle Log,Vehicle Log
DocType: Vital Signs,Presence of a fever (temp &gt; 38.5 °C/101.3 °F or sustained temp &gt; 38 °C/100.4 °F),"Presenza di febbre (temp&gt; 38,5 ° C / 101,3 ° F o temp. Durata&gt; 38 ° C / 100,4 ° F)"
DocType: Customer,Sales Team Details,Vendite team Dettagli
apps/erpnext/erpnext/accounts/page/pos/pos.js +1341,Delete permanently?,Eliminare in modo permanente?
DocType: Expense Claim,Total Claimed Amount,Totale importo richiesto
apps/erpnext/erpnext/config/crm.py +17,Potential opportunities for selling.,Potenziali opportunità di vendita.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +228,Invalid {0},Non valido {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +90,Sick Leave,Sick Leave
DocType: Email Digest,Email Digest,Email di Sintesi
DocType: Delivery Note,Billing Address Name,Destinatario
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +22,Department Stores,Grandi magazzini
,Item Delivery Date,Data di consegna dell&#39;articolo
DocType: Warehouse,PIN,PIN
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +125,Error '{0}' occured. Arguments {1}.,Errore &quot;{0}&quot;. Argomenti {1}.
DocType: Sales Invoice,Base Change Amount (Company Currency),Base quantità di modifica (Società di valuta)
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +304,No accounting entries for the following warehouses,Nessuna scritture contabili per le seguenti magazzini
apps/erpnext/erpnext/projects/doctype/project/project.js +111,Save the document first.,Salvare prima il documento.
apps/erpnext/erpnext/shopping_cart/cart.py +71,Only {0} in stock for item {1},Solo {0} in stock per l&#39;articolo {1}
DocType: Account,Chargeable,Addebitabile
DocType: Company,Change Abbreviation,Change Abbreviazione
DocType: Expense Claim Detail,Expense Date,Data Spesa
DocType: Item,Max Discount (%),Sconto Max (%)
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +30,Credit Days cannot be a negative number,I giorni di credito non possono essere un numero negativo
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +70,Last Order Amount,Ultimo ammontare ordine
apps/erpnext/erpnext/stock/doctype/item/item.py +264," {0} Retain Sample is based on batch, please check Has Batch No to retain sample of item","{0} Mantieni campione è basato sul lotto, si prega di verificare il numero di lotto per conservare il campione dell&#39;articolo"
DocType: Task,Is Milestone,È Milestone
DocType: Delivery Stop,Email Sent To,Email inviata a
DocType: Budget,Warn,Avvisa
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +81,Are you sure you want to unregister?,Sei sicuro di voler annullare la registrazione?
DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Eventuali altre osservazioni, sforzo degno di nota che dovrebbe andare nelle registrazioni."
DocType: Asset Maintenance,Manufacturing User,Utente Produzione
DocType: Purchase Invoice,Raw Materials Supplied,Materie prime fornite
DocType: C-Form,Series,serie
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +273,Currency of the price list {0} must be {1} or {2},Valuta dell&#39;elenco dei prezzi {0} deve essere {1} o {2}
DocType: Appraisal,Appraisal Template,Valutazione Modello
DocType: Soil Texture,Ternary Plot,Trama Ternaria
DocType: Item Group,Item Classification,Classificazione Articolo
DocType: Driver,License Number,Numero di licenza
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +131,Business Development Manager,Business Development Manager
DocType: Maintenance Visit Purpose,Maintenance Visit Purpose,Scopo visita manutenzione
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +19,Invoice Patient Registration,Registrazione pazienti fattura
DocType: Crop,Period,periodo
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js +18,General Ledger,Contabilità Generale
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +33,Employee {0} on Leave on {1},Employee {0} in aspettativa per {1}
apps/erpnext/erpnext/selling/doctype/campaign/campaign.js +10,View Leads,Visualizza i Leads
DocType: Program Enrollment Tool,New Program,Nuovo programma
DocType: Item Attribute Value,Attribute Value,Valore Attributo
,Itemwise Recommended Reorder Level,Itemwise consigliata riordino Livello
DocType: Salary Detail,Salary Detail,stipendio Dettaglio
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1043,Please select {0} first,Si prega di selezionare {0} prima
DocType: Appointment Type,Physician,Medico
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +833,Batch {0} of Item {1} has expired.,Il lotto {0} di {1} scaduto.
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py +11,Consultations,consultazioni
DocType: Sales Invoice,Commission,Commissione
apps/erpnext/erpnext/config/manufacturing.py +27,Time Sheet for manufacturing.,Scheda attività per la produzione.
apps/erpnext/erpnext/templates/pages/cart.html +37,Subtotal,Sub Totale
DocType: Physician,Charges,oneri
DocType: Salary Detail,Default Amount,Importo Predefinito
DocType: Lab Test Template,Descriptive,Descrittivo
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +93,Warehouse not found in the system,Magazzino non trovato nel sistema
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +115,This Month's Summary,Sommario di questo mese
DocType: Quality Inspection Reading,Quality Inspection Reading,Lettura Controllo Qualità
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +25,`Freeze Stocks Older Than` should be smaller than %d days.,`Blocca Scorte più vecchie di` dovrebbero essere inferiori %d giorni .
DocType: Tax Rule,Purchase Tax Template,Acquisto fiscale Template
apps/erpnext/erpnext/utilities/user_progress.py +45,Set a sales goal you'd like to achieve for your company.,Imposta un obiettivo di vendita che desideri conseguire per la tua azienda.
,Project wise Stock Tracking,Progetto saggio Archivio monitoraggio
DocType: GST HSN Code,Regional,Regionale
apps/erpnext/erpnext/config/healthcare.py +40,Laboratory,Laboratorio
DocType: Stock Entry Detail,Actual Qty (at source/target),Q.tà reale (in origine/obiettivo)
DocType: Item Customer Detail,Ref Code,Codice Rif
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +71,Customer Group is Required in POS Profile,Il gruppo di clienti è richiesto nel profilo POS
apps/erpnext/erpnext/config/hr.py +12,Employee records.,Informazioni Dipendente.
apps/erpnext/erpnext/assets/doctype/asset/asset.py +92,Please set Next Depreciation Date,Si prega di impostare Successivo Ammortamenti Data
DocType: HR Settings,Payroll Settings,Impostazioni Payroll
apps/erpnext/erpnext/config/accounts.py +146,Match non-linked Invoices and Payments.,Partita Fatture non collegati e pagamenti.
DocType: POS Settings,POS Settings,Impostazioni POS
apps/erpnext/erpnext/templates/pages/cart.html +16,Place Order,Invia ordine
DocType: Email Digest,New Purchase Orders,Nuovi Ordini di acquisto
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +24,Root cannot have a parent cost center,Root non può avere un centro di costo genitore
apps/erpnext/erpnext/public/js/stock_analytics.js +57,Select Brand...,Seleziona Marchio ...
apps/erpnext/erpnext/public/js/setup_wizard.js +32,Non Profit (beta),Non profitto (beta)
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +18,Training Events/Results,Eventi di formazione / risultati
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +152,Accumulated Depreciation as on,Fondo ammortamento come su
DocType: Sales Invoice,C-Form Applicable,C-Form Applicable
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +419,Operation Time must be greater than 0 for Operation {0},Tempo di funzionamento deve essere maggiore di 0 per Operation {0}
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +106,Warehouse is mandatory,Magazzino è obbligatorio
DocType: Supplier,Address and Contacts,Indirizzo e contatti
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +67,Failed to create website,Impossibile creare il sito Web
DocType: Soil Analysis,Mg/K,Mg / K
DocType: UOM Conversion Detail,UOM Conversion Detail,Dettaglio di conversione Unità di Misura
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +922,Retention Stock Entry already created or Sample Quantity not provided,Memorizzazione stock già creata o Quantità campione non fornita
DocType: Program,Program Abbreviation,Abbreviazione programma
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +407,Production Order cannot be raised against a Item Template,Ordine di produzione non può essere sollevata nei confronti di un modello di elemento
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +52,Charges are updated in Purchase Receipt against each item,Le tariffe sono aggiornati in acquisto ricevuta contro ogni voce
DocType: Warranty Claim,Resolved By,Deliberato dall&#39;Assemblea
DocType: Bank Guarantee,Start Date,Data di inizio
apps/erpnext/erpnext/config/hr.py +75,Allocate leaves for a period.,Allocare le foglie per un periodo .
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42,Cheques and Deposits incorrectly cleared,Assegni e depositi cancellati in modo non corretto
apps/erpnext/erpnext/accounts/doctype/account/account.py +46,Account {0}: You can not assign itself as parent account,Account {0}: non è possibile assegnare se stesso come conto principale
DocType: Purchase Invoice Item,Price List Rate,Prezzo di Listino
apps/erpnext/erpnext/utilities/activation.py +72,Create customer quotes,Creare le citazioni dei clienti
DocType: Item,"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.",Mostra &quot;Disponibile&quot; o &quot;Non disponibile&quot; sulla base di scorte disponibili in questo magazzino.
apps/erpnext/erpnext/config/manufacturing.py +38,Bill of Materials (BOM),Distinte materiali (BOM)
DocType: Item,Average time taken by the supplier to deliver,Tempo medio impiegato dal fornitore di consegnare
DocType: Sample Collection,Collected By,Raccolto da
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js +22,Assessment Result,valutazione dei risultati
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +13,Hours,Ore
DocType: Project,Expected Start Date,Data di inizio prevista
apps/erpnext/erpnext/stock/doctype/item/item.js +60,Variant Details Report,Rapporto dettagli varianti
DocType: Setup Progress Action,Setup Progress Action,Azione di progettazione di installazione
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +18,Buying Price List,Comprare il listino prezzi
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +49,Remove item if charges is not applicable to that item,Rimuovere articolo se le spese non è applicabile a tale elemento
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +21,Please select Maintenance Status as Completed or remove Completion Date,Selezionare Stato di manutenzione come completato o rimuovere Data di completamento
DocType: Supplier,Default Payment Terms Template,Modello di termini di pagamento predefinito
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +34,Transaction currency must be same as Payment Gateway currency,Valuta di transazione deve essere uguale a pagamento moneta Gateway
DocType: Payment Entry,Receive,Ricevere
apps/erpnext/erpnext/templates/pages/rfq.html +75,Quotations: ,Preventivi:
DocType: Maintenance Visit,Fully Completed,Debitamente compilato
apps/erpnext/erpnext/projects/doctype/project/project_list.js +6,{0}% Complete,{0}% Completato
DocType: Employee,Educational Qualification,Titolo di Studio
DocType: Workstation,Operating Costs,Costi operativi
DocType: Budget,Action if Accumulated Monthly Budget Exceeded,Azione da effettuarsi se si eccede il budget mensile
DocType: Subscription,Submit on creation,Conferma su creazione
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +470,Currency for {0} must be {1},Valuta per {0} deve essere {1}
DocType: Asset,Disposal Date,Smaltimento Data
DocType: Daily Work Summary Settings,"Emails will be sent to all Active Employees of the company at the given hour, if they do not have holiday. Summary of responses will be sent at midnight.","Messaggi di posta elettronica verranno inviati a tutti i dipendenti attivi della società nell&#39;ora dato, se non hanno le vacanze. Sintesi delle risposte verrà inviata a mezzanotte."
DocType: Employee Leave Approver,Employee Leave Approver,Responsabile / Approvatore Ferie
apps/erpnext/erpnext/stock/doctype/item/item.py +485,Row {0}: An Reorder entry already exists for this warehouse {1},Riga {0}: Una voce di riordino esiste già per questo magazzino {1}
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +99,"Cannot declare as lost, because Quotation has been made.",Non può essere dichiarato come perso perché è stato fatto un Preventivo.
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +16,Training Feedback,Formazione Commenti
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +483,Production Order {0} must be submitted,L'ordine di produzione {0} deve essere presentato
DocType: Supplier Scorecard Criteria,Supplier Scorecard Criteria,Criteri di valutazione dei fornitori
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +149,Please select Start Date and End Date for Item {0},Scegliere una data di inizio e di fine per la voce {0}
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +55,Course is mandatory in row {0},Corso è obbligatoria in riga {0}
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.js +16,To date cannot be before from date,'A Data' deve essere successiva a 'Da Data'
DocType: Supplier Quotation Item,Prevdoc DocType,Prevdoc DocType
apps/erpnext/erpnext/stock/doctype/item/item.js +268,Add / Edit Prices,Aggiungi / Modifica prezzi
DocType: Batch,Parent Batch,Parte Batch
DocType: Cheque Print Template,Cheque Print Template,Modello di stampa dell'Assegno
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +36,Chart of Cost Centers,Grafico Centro di Costo
DocType: Lab Test Template,Sample Collection,Raccolta di campioni
,Requested Items To Be Ordered,Elementi richiesti da ordinare
apps/erpnext/erpnext/hub_node/page/hub/hub.js +655,My Orders,I Miei Ordini
DocType: Price List,Price List Name,Prezzo di listino Nome
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +32,Daily Work Summary for {0},Riepilogo giornaliero lavori  per {0}
DocType: BOM,Manufacturing,Produzione
,Ordered Items To Be Delivered,Articoli ordinati da consegnare
DocType: Account,Income,Proventi
DocType: Industry Type,Industry Type,Tipo Industria
apps/erpnext/erpnext/templates/includes/cart.js +150,Something went wrong!,Qualcosa è andato storto!
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +124,Warning: Leave application contains following block dates,Attenzione: Lascia applicazione contiene seguenti date di blocco
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +266,Sales Invoice {0} has already been submitted,La fattura di vendita {0} è già stata presentata
DocType: Supplier Scorecard Scoring Criteria,Score,Punto
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +25,Fiscal Year {0} does not exist,Anno fiscale {0} non esiste
DocType: Asset Maintenance Log,Completion Date,Data Completamento
DocType: Purchase Invoice Item,Amount (Company Currency),Importo (Valuta Azienda)
DocType: Crop,Agriculture User,Utente dell&#39;agricoltura
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +38,Valid till date cannot be before transaction date,Valida fino alla data non può essere prima della data della transazione
apps/erpnext/erpnext/stock/stock_ledger.py +379,{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,{0} unità di {1} necessarie in {2} su {3} {4} di {5} per completare la transazione.
DocType: Fee Schedule,Student Category,Student Categoria
DocType: Announcement,Student,Alunno
apps/erpnext/erpnext/config/hr.py +238,Organization unit (department) master.,Unità organizzativa ( dipartimento) master.
DocType: Shipping Rule,Shipping Rule Type,Tipo di regola di spedizione
apps/erpnext/erpnext/utilities/user_progress.py +236,Go to Rooms,Vai alle Camere
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +75,Please enter message before sending,Inserisci il messaggio prima di inviarlo
DocType: Purchase Invoice,DUPLICATE FOR SUPPLIER,DUPLICARE PER IL FORNITORE
DocType: Email Digest,Pending Quotations,Preventivi Aperti
apps/erpnext/erpnext/config/accounts.py +318,Point-of-Sale Profile,Point-of-Sale Profilo
apps/erpnext/erpnext/config/healthcare.py +153,Lab Test Configurations.,Configurazioni di test di laboratorio.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +156,Unsecured Loans,Prestiti non garantiti
DocType: Cost Center,Cost Center Name,Nome Centro di Costo
DocType: Student,B+,B +
DocType: HR Settings,Max working hours against Timesheet,Max ore di lavoro contro Timesheet
DocType: Maintenance Schedule Detail,Scheduled Date,Data prevista
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +88,Total Paid Amt,Totale versato Amt
DocType: SMS Center,Messages greater than 160 characters will be split into multiple messages,Messaggio maggiore di 160 caratteri verrà divisa in mesage multipla
DocType: Purchase Receipt Item,Received and Accepted,Ricevuti e accettati
DocType: Hub Settings,Company and Seller Profile,Profilo dell&#39;azienda e del venditore
,GST Itemised Sales Register,GST Registro delle vendite specificato
DocType: Soil Texture,Silt Loam,Limoso
,Serial No Service Contract Expiry,Serial No Contratto di Servizio di scadenza
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +297,You cannot credit and debit same account at the same time,"Non si può di credito e debito stesso conto , allo stesso tempo"
DocType: Vital Signs,Adults' pulse rate is anywhere between 50 and 80 beats per minute.,L&#39;impulso degli adulti è tra 50 e 80 battiti al minuto.
DocType: Naming Series,Help HTML,Aiuto HTML
DocType: Student Group Creation Tool,Student Group Creation Tool,Student Gruppo strumento di creazione
DocType: Item,Variant Based On,Variante calcolate in base a
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +53,Total weightage assigned should be 100%. It is {0},Weightage totale assegnato dovrebbe essere al 100% . E ' {0}
apps/erpnext/erpnext/utilities/user_progress.py +106,Your Suppliers,I Vostri Fornitori
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,Please correct the,Correggi
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +80,Cannot set as Lost as Sales Order is made.,Impossibile impostare come persa come è fatto Sales Order .
DocType: Request for Quotation Item,Supplier Part No,Articolo Fornitore No
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +382,Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',Non può dedurre quando categoria è per &#39;valutazione&#39; o &#39;Vaulation e Total&#39;
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +364,Received From,Ricevuto da
DocType: Lead,Converted,Convertito
DocType: Item,Has Serial No,Ha numero di serie
DocType: Employee,Date of Issue,Data Pubblicazione
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +24,{0}: From {0} for {1},{0}: Da {0} per {1}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +222,"As per the Buying Settings if Purchase Reciept Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Receipt first for item {0}","Come per le Impostazioni di Acquisto se l&#39;acquisto di Reciept Required == &#39;YES&#39;, quindi per la creazione della fattura di acquisto, l&#39;utente deve creare prima la ricevuta di acquisto per l&#39;elemento {0}"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +167,Row #{0}: Set Supplier for item {1},Fila # {0}: Impostare Fornitore per Articolo {1}
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +121,Row {0}: Hours value must be greater than zero.,Riga {0}: valore Ore deve essere maggiore di zero.
apps/erpnext/erpnext/stock/doctype/item/item.py +185,Website Image {0} attached to Item {1} cannot be found,Website Immagine {0} collegata alla voce {1} non può essere trovato
DocType: Issue,Content Type,Tipo Contenuto
DocType: Asset,Assets,Risorse
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +17,Computer,computer
DocType: Item,List this Item in multiple groups on the website.,Elenco questo articolo a più gruppi sul sito.
DocType: Payment Term,Due Date Based On,Scadenza basata su
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +85,Please set default customer group and territory in Selling Settings,Imposta il gruppo e il territorio del cliente di default nelle Impostazioni di vendita
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +203,{0} {1} does not exist,{0} {1} non esiste
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +321,Please check Multi Currency option to allow accounts with other currency,Si prega di verificare l&#39;opzione multi valuta per consentire agli account con altra valuta
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +85,Item: {0} does not exist in the system,Voce: {0} non esiste nel sistema
apps/erpnext/erpnext/accounts/doctype/account/account.py +108,You are not authorized to set Frozen value,Non sei autorizzato a impostare il valore bloccato
DocType: Payment Reconciliation,Get Unreconciled Entries,Ottieni entrate non riconciliate
DocType: Payment Reconciliation,From Invoice Date,Da Data fattura
DocType: Healthcare Settings,Laboratory Settings,Impostazioni di laboratorio
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +75,Leave Encashment,lasciare Incasso
apps/erpnext/erpnext/public/js/setup_wizard.js +114,What does it do?,Che cosa fa ?
DocType: Crop,Byproducts,sottoprodotti
apps/erpnext/erpnext/stock/doctype/batch/batch.js +76,To Warehouse,Al Magazzino
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +26,All Student Admissions,Tutte le ammissioni degli studenti
,Average Commission Rate,Tasso medio di commissione
apps/erpnext/erpnext/stock/doctype/item/item.py +434,'Has Serial No' can not be 'Yes' for non-stock item,'Ha un numero di serie' non può essere 'Sì' per gli articoli non in scorta
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +62,Select Status,Seleziona Stato
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +41,Attendance can not be marked for future dates,La Presenza non può essere inserita nel futuro
DocType: Pricing Rule,Pricing Rule Help,Regola Prezzi Aiuto
DocType: School House,House Name,Nome della casa
DocType: Fee Schedule,Total Amount per Student,Importo totale per studente
DocType: Purchase Taxes and Charges,Account Head,Riferimento del conto
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +153,Electrical,elettrico
apps/erpnext/erpnext/utilities/activation.py +100,Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts,Aggiungere il resto della vostra organizzazione come gli utenti. È inoltre possibile aggiungere invitare i clienti a proprio portale con l&#39;aggiunta di loro di contatti
DocType: Stock Entry,Total Value Difference (Out - In),Totale Valore Differenza (Out - In)
DocType: Grant Application,Requested Amount,Importo richiesto
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +346,Row {0}: Exchange Rate is mandatory,Riga {0}: Tasso di cambio è obbligatorio
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +27,User ID not set for Employee {0},ID utente non impostato per Dipedente {0}
DocType: Vehicle,Vehicle Value,Valore veicolo
DocType: Crop Cycle,Detected Diseases,Malattie rilevate
DocType: Stock Entry,Default Source Warehouse,Magazzino di provenienza predefinito
DocType: Item,Customer Code,Codice Cliente
apps/erpnext/erpnext/hr/doctype/employee/employee.py +220,Birthday Reminder for {0},Promemoria Compleanno per {0}
DocType: Asset Maintenance Task,Last Completion Date,Ultima data di completamento
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +72,Days Since Last Order,Giorni dall'ultimo ordine
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +359,Debit To account must be a Balance Sheet account,Debito Per account deve essere un account di Stato Patrimoniale
DocType: Buying Settings,Naming Series,Denominazione Serie
DocType: Leave Block List,Leave Block List Name,Lascia Block List Nome
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py +14,Insurance Start date should be less than Insurance End date,Assicurazione Data di inizio deve essere inferiore a Assicurazione Data Fine
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +32,Stock Assets,Attivo Immagini
DocType: Timesheet,Production Detail,Particolare di produzione
DocType: Restaurant,Active Menu,Menu attivo
DocType: Target Detail,Target Qty,Obiettivo Qtà
DocType: Shopping Cart Settings,Checkout Settings,Impostazioni Acquista
DocType: Student Attendance,Present,Presente
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +37,Delivery Note {0} must not be submitted,Il Documento di Trasporto {0} non deve essere presentato
DocType: Notification Control,Sales Invoice Message,Messaggio Fattura di Vendita
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +27,Closing Account {0} must be of type Liability / Equity,Chiusura account {0} deve essere di tipo Responsabilità / Patrimonio netto
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +325,Salary Slip of employee {0} already created for time sheet {1},Salario Slip of dipendente {0} già creato per foglio di tempo {1}
DocType: Vehicle Log,Odometer,Odometro
DocType: Sales Order Item,Ordered Qty,Quantità ordinato
apps/erpnext/erpnext/stock/doctype/item/item.py +713,Item {0} is disabled,Articolo {0} è disattivato
DocType: Stock Settings,Stock Frozen Upto,Giacenza Bloccate Fino
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +929,BOM does not contain any stock item,BOM non contiene alcun elemento magazzino
DocType: Chapter,Chapter Head,Capo capitolo
DocType: Payment Term,Month(s) after the end of the invoice month,Mese / i dopo la fine del mese della fattura
apps/erpnext/erpnext/config/projects.py +19,Project activity / task.,Attività / Attività del progetto.
DocType: Vehicle Log,Refuelling Details,Dettagli di rifornimento
apps/erpnext/erpnext/config/hr.py +104,Generate Salary Slips,Generare buste paga
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +44,"Buying must be checked, if Applicable For is selected as {0}","L'acquisto deve essere controllato, se ""applicabile per"" bisogna selezionarlo come {0}"
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +40,Discount must be less than 100,Sconto deve essere inferiore a 100
DocType: Shipping Rule,Restrict to Countries,Limitare ai Paesi
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +171,Select Delivery Notes,Seleziona le note di consegna
DocType: Purchase Invoice,Write Off Amount (Company Currency),Importo Svalutazione (Valuta società)
DocType: Sales Invoice Timesheet,Billing Hours,Ore di fatturazione
DocType: Project,Total Sales Amount (via Sales Order),Importo totale vendite (tramite ordine cliente)
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +528,Default BOM for {0} not found,Distinta Materiali predefinita per {0} non trovato
apps/erpnext/erpnext/stock/doctype/item/item.py +489,Row #{0}: Please set reorder quantity,Fila # {0}: Si prega di impostare la quantità di riordino
apps/erpnext/erpnext/public/js/pos/pos.html +20,Tap items to add them here,Tocca gli elementi da aggiungere qui
DocType: Fees,Program Enrollment,programma Iscrizione
DocType: Landed Cost Voucher,Landed Cost Voucher,Landed Voucher Cost
apps/erpnext/erpnext/public/js/queries.js +39,Please set {0},Impostare {0}
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37,{0} - {1} is inactive student,{0} - {1} è uno studente inattivo
DocType: Employee,Health Details,Dettagli Salute
DocType: Offer Letter,Offer Letter Terms,Termini di Offerta
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24,To create a Payment Request reference document is required,Per creare un Riferimento di Richiesta di Pagamento è necessario un Documento
DocType: Soil Texture,Sandy Clay,Sandy Clay
DocType: Grant Application,Assessment  Manager,Responsabile della valutazione
DocType: Payment Entry,Allocate Payment Amount,Allocare Importo di Pagamento
DocType: Employee External Work History,Salary,Stipendio
DocType: Serial No,Delivery Document Type,Tipo Documento Consegna
DocType: Sales Order,Partly Delivered,Parzialmente Consegnato
DocType: Item Variant Settings,Do not update variants on save,Non aggiornare le varianti al salvataggio
DocType: Email Digest,Receivables,Crediti
DocType: Lead Source,Lead Source,Fonte del Lead
DocType: Customer,Additional information regarding the customer.,Ulteriori informazioni relative al cliente.
DocType: Quality Inspection Reading,Reading 5,Lettura 5
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +225,"{0} {1} is associated with {2}, but Party Account is {3}","{0} {1} è associato a {2}, ma il conto partito è {3}"
apps/erpnext/erpnext/healthcare/doctype/sample_collection/sample_collection.js +7,View Lab Tests,Visualizza test di laboratorio
DocType: Purchase Invoice,Y,Y
DocType: Maintenance Visit,Maintenance Date,Data di manutenzione
DocType: Purchase Invoice Item,Rejected Serial No,Rifiutato Serial No
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +82,Year start date or end date is overlapping with {0}. To avoid please set company,La data di inizio o di fine Anno si sovrappone con {0}. Per risolvere questo problema impostare l'Azienda
apps/erpnext/erpnext/selling/doctype/customer/customer.py +108,Please mention the Lead Name in Lead {0},Si prega di citare il Lead Name in Lead {0}
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +156,Start date should be less than end date for Item {0},Data di inizio dovrebbe essere inferiore a quella di fine per la voce {0}
DocType: Item,"Example: ABCD.#####
If series is set and Serial No is not mentioned in transactions, then automatic serial number will be created based on this series. If you always want to explicitly mention Serial Nos for this item. leave this blank.","Esempio:. ABCD. ##### Se è impostato 'serie' ma il Numero di Serie non è specificato nelle transazioni, verrà creato il numero di serie automatico in base a questa serie. Se si vuole sempre specificare il Numero di Serie per questo articolo. Lasciare vuoto."
DocType: Upload Attendance,Upload Attendance,Carica presenze
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +535,BOM and Manufacturing Quantity are required,BOM e Quantità  Produzione richiesti
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +44,Ageing Range 2,Gamma Ageing 2
DocType: SG Creation Tool Course,Max Strength,Forza Max
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +28,Installing presets,Installare i preset
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +67,No Delivery Note selected for Customer {},Nessuna nota di consegna selezionata per il cliente {}
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +22,BOM replaced,BOM sostituita
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1041,Select Items based on Delivery Date,Selezionare gli elementi in base alla data di consegna
DocType: Grant Application,Has any past Grant Record,Ha un record di sovvenzione passato
,Sales Analytics,Analisi dei dati di vendita
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +119,Available {0},Disponibile {0}
,Prospects Engaged But Not Converted,Prospettive impegnate ma non convertite
DocType: Manufacturing Settings,Manufacturing Settings,Impostazioni di Produzione
apps/erpnext/erpnext/config/setup.py +56,Setting up Email,Configurazione della posta elettronica
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +57,Guardian1 Mobile No,Guardian1 mobile No
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +106,Please enter default currency in Company Master,Inserisci valuta predefinita in Azienda Maestro
DocType: Stock Entry Detail,Stock Entry Detail,Dettaglio del Movimento di Magazzino
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +109,Daily Reminders,Promemoria quotidiani
DocType: Products Settings,Home Page is Products,La Home Page è Prodotti
,Asset Depreciation Ledger,Libro Mastro Ammortamento Asset
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +88,Tax Rule Conflicts with {0},Conflitti norma fiscale con {0}
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +25,New Account Name,Nuovo Nome Account
DocType: Purchase Invoice Item,Raw Materials Supplied Cost,Costo Fornitura Materie Prime
DocType: Selling Settings,Settings for Selling Module,Impostazioni per il Modulo Vendite
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +115,Customer Service,Servizio clienti
DocType: BOM,Thumbnail,Thumbnail
DocType: Item Customer Detail,Item Customer Detail,Dettaglio articolo cliente
apps/erpnext/erpnext/config/hr.py +50,Offer candidate a Job.,Offerta candidato un lavoro.
DocType: Notification Control,Prompt for Email on Submission of,Richiedi Email su presentazione di
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +88,Total allocated leaves are more than days in the period,Totale foglie assegnati sono più di giorni nel periodo
DocType: Land Unit,Linked Soil Analysis,Analisi del suolo collegata
DocType: Pricing Rule,Percentage,Percentuale
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +70,Item {0} must be a stock Item,L'Articolo {0} deve essere in Giacenza
DocType: Manufacturing Settings,Default Work In Progress Warehouse,Deposito di default per Work In Progress
apps/erpnext/erpnext/config/accounts.py +288,Default settings for accounting transactions.,Impostazioni predefinite per le operazioni contabili.
DocType: Maintenance Visit,MV,MV
DocType: Restaurant,Default Tax Template,Modello fiscale predefinito
DocType: Fees,Student Details,Dettagli dello studente
DocType: Purchase Invoice Item,Stock Qty,Quantità di magazzino
DocType: Employee Loan,Repayment Period in Months,Il rimborso Periodo in mese
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +26,Error: Not a valid id?,Errore: Non è un documento di identità valido?
DocType: Naming Series,Update Series Number,Aggiornamento Numero di Serie
DocType: Account,Equity,equità
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +78,{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry,{0} {1}: Conto economico {2} non ammesso nelle registrazioni di apertura
DocType: Sales Order,Printing Details,Dettagli stampa
DocType: Task,Closing Date,Data Chiusura
DocType: Sales Order Item,Produced Quantity,Prodotto Quantità
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +126,Engineer,Ingegnere
DocType: Journal Entry,Total Amount Currency,Importo Totale Valuta
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +38,Search Sub Assemblies,Cerca Sub Assemblies
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +171,Item Code required at Row No {0},Codice Articolo richiesto alla Riga N. {0}
apps/erpnext/erpnext/utilities/user_progress.py +151,Go to Items,Vai a Elementi
DocType: Sales Partner,Partner Type,Tipo di partner
DocType: Purchase Taxes and Charges,Actual,Attuale
DocType: Restaurant Menu,Restaurant Manager,Gestore del ristorante
DocType: Authorization Rule,Customerwise Discount,Sconto Cliente saggio
apps/erpnext/erpnext/config/projects.py +41,Timesheet for tasks.,Scheda attività
DocType: Purchase Invoice,Against Expense Account,Per Spesa Conto
DocType: Production Order,Production Order,Ordine di produzione
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +273,Installation Note {0} has already been submitted,Nota Installazione {0} già inserita
DocType: Bank Reconciliation,Get Payment Entries,Ottenere le voci di pagamento
DocType: Quotation Item,Against Docname,Per Nome Doc
DocType: SMS Center,All Employee (Active),Tutti Dipendenti (Attivi)
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +9,View Now,Guarda ora
DocType: BOM,Raw Material Cost,Costo Materie Prime
DocType: Item Reorder,Re-Order Level,Livello Ri-ordino
DocType: Production Planning Tool,Enter items and planned qty for which you want to raise production orders or download raw materials for analysis.,Inserisci articoli e q.tà programmate per i quali si desidera raccogliere gli ordini di produzione o scaricare materie prime per l'analisi.
apps/erpnext/erpnext/projects/doctype/project/project.js +64,Gantt Chart,Diagramma di Gantt
DocType: Crop Cycle,Cycle Type,Tipo di ciclo
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +99,Part-time,A tempo parziale
DocType: Employee,Applicable Holiday List,Lista Vacanze Applicabile
DocType: Employee,Cheque,Assegno
DocType: Training Event,Employee Emails,E-mail dei dipendenti
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +59,Series Updated,serie Aggiornato
apps/erpnext/erpnext/accounts/doctype/account/account.py +161,Report Type is mandatory,Tipo di Report è obbligatorio
DocType: Item,Serial Number Series,Serial Number Series
apps/erpnext/erpnext/buying/utils.py +68,Warehouse is mandatory for stock Item {0} in row {1},Magazzino è obbligatorio per l'Articolo in Giacenza {0} alla Riga {1}
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +45,Retail & Wholesale,Retail & Wholesale
DocType: Issue,First Responded On,Ha risposto prima su
DocType: Website Item Group,Cross Listing of Item in multiple groups,Croce Listing dell'oggetto in più gruppi
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +90,Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},Anno fiscale Data di inizio e Data Fine dell'anno fiscale sono già impostati nel Fiscal Year {0}
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +97,Clearance Date updated,Liquidazione Data di aggiornamento
apps/erpnext/erpnext/stock/doctype/batch/batch.js +138,Split Batch,Split Batch
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +131,Successfully Reconciled,Riconciliati correttamente
DocType: Request for Quotation Supplier,Download PDF,Scarica il pdf
DocType: Production Order,Planned End Date,Data di fine pianificata
apps/erpnext/erpnext/controllers/buying_controller.py +424,Please enter Schedule Date,Inserisci la data di programma
apps/erpnext/erpnext/config/non_profit.py +63,Donor Type information.,Informazioni sul tipo di donatore.
DocType: Request for Quotation,Supplier Detail,Dettaglio del Fornitore
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +100,Error in formula or condition: {0},Errore nella formula o una condizione: {0}
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +16,Invoiced Amount,Importo Fatturato
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +47,Criteria weights must add up to 100%,I pesi dei criteri devono aggiungere fino al 100%
apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js +7,Attendance,Presenze
apps/erpnext/erpnext/public/js/pos/pos.html +104,Stock Items,Articoli di magazzino
DocType: BOM,Materials,Materiali
DocType: Leave Block List,"If not checked, the list will have to be added to each Department where it has to be applied.","Se non controllati, la lista dovrà essere aggiunto a ciascun Dipartimento dove deve essere applicato."
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +103,Creating {0},Creazione di {0}
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +28,Source and Target Warehouse cannot be same,Magazzino di Origine e di Destinazione non possono essere uguali
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +561,Posting date and posting time is mandatory,Data e ora di registrazione sono obbligatori
apps/erpnext/erpnext/config/buying.py +76,Tax template for buying transactions.,Modelli fiscali per le transazioni di acquisto.
,Item Prices,Prezzi Articolo
DocType: Purchase Order,In Words will be visible once you save the Purchase Order.,In parole saranno visibili una volta che si salva di Acquisto.
DocType: Period Closing Voucher,Period Closing Voucher,Periodo di chiusura Voucher
DocType: Consultation,Review Details,Dettagli di revisione
DocType: Dosage Form,Dosage Form,Forma di dosaggio
apps/erpnext/erpnext/config/selling.py +67,Price List master.,Maestro listino prezzi.
DocType: Task,Review Date,Data di revisione
DocType: Company,Series for Asset Depreciation Entry (Journal Entry),Serie per l&#39;ammortamento dell&#39;attivo (registrazione giornaliera)
DocType: Membership,Member Since,Membro da
DocType: Purchase Invoice,Advance Payments,Pagamenti anticipati
DocType: Purchase Taxes and Charges,On Net Total,Sul Totale Netto
apps/erpnext/erpnext/controllers/item_variant.py +90,Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4},Valore per l&#39;attributo {0} deve essere all&#39;interno della gamma di {1} a {2} nei incrementi di {3} per la voce {4}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +166,Target warehouse in row {0} must be same as Production Order,Magazzino di Destinazione sul rigo {0} deve essere uguale a quello dell'ordine di produzione
DocType: Restaurant Reservation,Waitlisted,lista d&#39;attesa
apps/erpnext/erpnext/accounts/doctype/account/account.py +126,Currency can not be changed after making entries using some other currency,Valuta non può essere modificata dopo aver fatto le voci utilizzando qualche altra valuta
DocType: Shipping Rule,Fixed,Fisso
DocType: Vehicle Service,Clutch Plate,Frizione
DocType: Company,Round Off Account,Arrotondamento Account
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +93,Administrative Expenses,Spese Amministrative
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +18,Consulting,Consulting
DocType: Customer Group,Parent Customer Group,Parent Gruppo clienti
DocType: Journal Entry,Subscription,Sottoscrizione
DocType: Purchase Invoice,Contact Email,Email Contatto
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +11,Fee Creation Pending,Fee Creation In attesa
DocType: Appraisal Goal,Score Earned,Punteggio Guadagnato
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +239,Notice Period,Periodo Di Preavviso
DocType: Asset Category,Asset Category Name,Asset Nome Categoria
apps/erpnext/erpnext/setup/doctype/territory/territory.js +13,This is a root territory and cannot be edited.,Questo è un territorio root e non può essere modificato .
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +5,New Sales Person Name,Nome nuova persona vendite
DocType: Packing Slip,Gross Weight UOM,Peso lordo U.M.
DocType: Asset Maintenance Task,Preventive Maintenance,Manutenzione preventiva
DocType: Delivery Note Item,Against Sales Invoice,Per Fattura Vendita
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +151,Please enter serial numbers for serialized item ,Inserisci i numeri di serie per l&#39;articolo serializzato
DocType: Bin,Reserved Qty for Production,Riservato Quantità per Produzione
DocType: Student Group Creation Tool,Leave unchecked if you don't want to consider batch while making course based groups. ,Lasciate non selezionate se non si desidera considerare il gruppo durante la creazione di gruppi basati sul corso.
DocType: Asset,Frequency of Depreciation (Months),Frequenza di ammortamento (Mesi)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +501,Credit Account,Conto di credito
DocType: Landed Cost Item,Landed Cost Item,Landed Cost articolo
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js +57,Show zero values,Mostra valori zero
DocType: BOM,Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Quantità di prodotto ottenuto dopo la produzione / reimballaggio da determinati quantitativi di materie prime
DocType: Lab Test,Test Group,Gruppo di prova
DocType: Payment Reconciliation,Receivable / Payable Account,Contabilità Clienti /Fornitori
DocType: Delivery Note Item,Against Sales Order Item,Dall'Articolo dell'Ordine di Vendita
apps/erpnext/erpnext/stock/doctype/item/item.py +680,Please specify Attribute Value for attribute {0},Si prega di specificare Attributo Valore per l&#39;attributo {0}
DocType: Item,Default Warehouse,Magazzino Predefinito
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +45,Budget cannot be assigned against Group Account {0},Bilancio non può essere assegnato contro account gruppo {0}
DocType: Healthcare Settings,Patient Registration,Registrazione del paziente
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +22,Please enter parent cost center,Inserisci il centro di costo genitore
DocType: Delivery Note,Print Without Amount,Stampare senza Importo
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +57,Depreciation Date,Ammortamenti Data
DocType: Issue,Support Team,Support Team
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +36,Expiry (In Days),Scadenza (in giorni)
DocType: Appraisal,Total Score (Out of 5),Punteggio totale (i 5)
DocType: Fee Structure,FS.,FS.
DocType: Student Attendance Tool,Batch,Lotto
DocType: Donor,Donor Type,Tipo di donatore
apps/erpnext/erpnext/stock/doctype/item/item.js +27,Balance,Saldo
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +66,Please select the Company,Si prega di selezionare la società
DocType: Room,Seating Capacity,posti a sedere
DocType: Issue,ISS-,ISS-
DocType: Lab Test Groups,Lab Test Groups,Gruppi di test del laboratorio
DocType: Project,Total Expense Claim (via Expense Claims),Total Expense Claim (via rimborsi spese)
DocType: GST Settings,GST Summary,Riepilogo GST
DocType: Assessment Result,Total Score,Punteggio totale
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +116,Please set the Default Cost Center in {0} company,Impostare il centro di costo predefinito in {0} società
DocType: Journal Entry,Debit Note,Nota di Debito
DocType: Stock Entry,As per Stock UOM,Come per scorte UOM
apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +7,Not Expired,Non Scaduto
DocType: Student Log,Achievement,Realizzazione
DocType: Batch,Source Document Type,Tipo di documento di origine
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +24,Following course schedules were created,Sono stati creati i seguenti programmi del corso
DocType: Journal Entry,Total Debit,Debito totale
DocType: Manufacturing Settings,Default Finished Goods Warehouse,Deposito beni ultimati
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +77,Sales Person,Addetto alle vendite
apps/erpnext/erpnext/config/accounts.py +233,Budget and Cost Center,Bilancio e Centro di costo
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +65,Multiple default mode of payment is not allowed,Non è consentito il modo di pagamento multiplo predefinito
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5,for the,per il
,Appointment Analytics,Appuntamento Analytics
DocType: Vehicle Service,Half Yearly,Semestrale
DocType: Lead,Blog Subscriber,Abbonati Blog
DocType: Guardian,Alternate Number,Numero alternativo
DocType: Healthcare Settings,Consultations in valid days,Consultazioni in giorni validi
DocType: Assessment Plan Criteria,Maximum Score,punteggio massimo
apps/erpnext/erpnext/config/setup.py +83,Create rules to restrict transactions based on values.,Creare regole per limitare le transazioni in base ai valori .
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +49, Group Roll No,Gruppo rotolo N.
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +9,Fee Creation Failed,Creazione dei diritti non riuscita
DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Lasciare vuoto se fai gruppi di studenti all&#39;anno
DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Se selezionato, non totale. di giorni lavorativi includerà vacanze, e questo ridurrà il valore di salario per ogni giorno"
DocType: Purchase Invoice,Total Advance,Totale Anticipo
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +27,Change Template Code,Modifica del codice modello
apps/erpnext/erpnext/education/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.,Il Data Terminologia fine non può essere anteriore alla data di inizio Term. Si prega di correggere le date e riprovare.
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19,Quot Count,Quot Count
,BOM Stock Report,BOM Stock Report
DocType: Stock Reconciliation Item,Quantity Difference,Quantità Differenza
DocType: Employee Advance,EA-,EA-
apps/erpnext/erpnext/config/hr.py +320,Processing Payroll,Elaborazione paghe
DocType: Opportunity Item,Basic Rate,Tasso Base
DocType: GL Entry,Credit Amount,Ammontare del credito
DocType: Cheque Print Template,Signatory Position,Posizione firmatario
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +175,Set as Lost,Imposta come persa
DocType: Timesheet,Total Billable Hours,Totale Ore Fatturabili
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +4,Payment Receipt Note,Nota Ricevuta di pagamento
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +6,This is based on transactions against this Customer. See timeline below for details,Questo si basa su operazioni contro questo cliente. Vedere cronologia sotto per i dettagli
DocType: Company,Credit Days Based On,Giorni di credito in funzione
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +161,Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2},Riga {0}: l'importo assegnato {1} deve essere inferiore o uguale alImporto della registrazione di pagamento {2}
,Course wise Assessment Report,Rapporto di valutazione saggio
DocType: Tax Rule,Tax Rule,Regola fiscale
DocType: Selling Settings,Maintain Same Rate Throughout Sales Cycle,Mantenere lo stesso prezzo per tutto il ciclo di vendita
DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,Pianificare i registri di tempo al di fuori dell&#39;orario di lavoro Workstation.
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +92,Dr {0} does not have a Physician Schedule. Add it in Physician master,Dr {0} non dispone di un programma medico. Aggiungilo nel master del medico
apps/erpnext/erpnext/public/js/pos/pos.html +87,Customers in Queue,I clienti in coda
DocType: Driver,Issuing Date,Data di rilascio
DocType: Student,Nationality,Nazionalità
,Items To Be Requested,Articoli da richiedere
DocType: Company,Company Info,Info Azienda
apps/erpnext/erpnext/accounts/page/pos/pos.js +1374,Select or add new customer,Selezionare o aggiungere nuovo cliente
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +179,Cost center is required to book an expense claim,Centro di costo è necessario per prenotare un rimborso spese
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +9,Application of Funds (Assets),Applicazione dei fondi ( Assets )
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +6,This is based on the attendance of this Employee,Questo si basa sulla presenza di questo dipendente
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +112,Mark Attendance,Segna la presenza
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +495,Debit Account,Conto di addebito
DocType: Fiscal Year,Year Start Date,Data di inizio anno
DocType: Attendance,Employee Name,Nome Dipendente
DocType: Restaurant Order Entry Item,Restaurant Order Entry Item,Ristorante Articolo di ordinazione voce
DocType: Purchase Invoice,Rounded Total (Company Currency),Totale arrotondato (Azienda valuta)
apps/erpnext/erpnext/accounts/doctype/account/account.py +98,Cannot covert to Group because Account Type is selected.,Non può convertirsi gruppo perché è stato selezionato Tipo di account.
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +260,{0} {1} has been modified. Please refresh.,{0} {1} è stato modificato. Aggiornare prego.
DocType: Leave Block List,Stop users from making Leave Applications on following days.,Impedire agli utenti di effettuare Lascia le applicazioni in giorni successivi.
DocType: Asset Maintenance Team,Maintenance Team Members,Membri del team di manutenzione
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +63,Purchase Amount,Ammontare dell&#39;acquisto
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +259,Supplier Quotation {0} created,Preventivo Fornitore {0} creato
apps/erpnext/erpnext/accounts/report/financial_statements.py +97,End Year cannot be before Start Year,Fine anno non può essere prima di inizio anno
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +232,Employee Benefits,Benefici per i dipendenti
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +255,Packed quantity must equal quantity for Item {0} in row {1},La quantità imballata deve essere uguale per l'articolo {0} sulla riga {1}
DocType: Production Order,Manufactured Qty,Q.tà Prodotte
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +64,Invoice Created,Fattura creata
DocType: Asset,Out of Order,Guasto
DocType: Purchase Receipt Item,Accepted Quantity,Quantità accettata
apps/erpnext/erpnext/hr/doctype/employee/employee.py +242,Please set a default Holiday List for Employee {0} or Company {1},Si prega di impostare un valore predefinito lista per le vacanze per i dipendenti {0} o {1} società
apps/erpnext/erpnext/accounts/party.py +31,{0}: {1} does not exists,{0}: {1} non esiste
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +76,Select Batch Numbers,Selezionare i numeri di batch
apps/erpnext/erpnext/config/accounts.py +12,Bills raised to Customers.,Fatture sollevate dai Clienti.
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Project Id,Progetto Id
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +532,Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},Fila No {0}: Importo non può essere maggiore di attesa Importo contro Rimborso Spese {1}. In attesa importo è {2}
DocType: Assessment Plan,Schedule,Pianificare
DocType: Account,Parent Account,Account genitore
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +266,Available,Disponibile
DocType: Quality Inspection Reading,Reading 3,Lettura 3
,Hub,Hub
DocType: GL Entry,Voucher Type,Voucher Tipo
apps/erpnext/erpnext/accounts/page/pos/pos.js +1706,Price List not found or disabled,Listino Prezzi non trovato o disattivato
DocType: Student Applicant,Approved,Approvato
DocType: Pricing Rule,Price,Prezzo
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +266,Employee relieved on {0} must be set as 'Left',Dipendente esonerato da {0} deve essere impostato come 'Congedato'
DocType: Hub Settings,Last Sync On,Ultima sincronizzazione attivata
DocType: Guardian,Guardian,Custode
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +42,Appraisal {0} created for Employee {1} in the given date range,Valutazione {0} creato per Employee {1} nel determinato intervallo di date
DocType: Academic Term,Education,Educazione
apps/erpnext/erpnext/public/js/pos/pos.html +78,Del,del
DocType: Selling Settings,Campaign Naming By,Creare il nome Campagna da
DocType: Employee,Current Address Is,Indirizzo attuale è
apps/erpnext/erpnext/utilities/user_progress.py +48,Monthly Sales Target (,Target di vendita mensile (
apps/erpnext/erpnext/templates/includes/projects/project_tasks.html +9,modified,modificata
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +43,"Optional. Sets company's default currency, if not specified.","Opzionale. Imposta valuta predefinita dell&#39;azienda, se non specificato."
DocType: Sales Invoice,Customer GSTIN,Cliente GSTIN
DocType: Crop Cycle,List of diseases detected on the field. When selected it'll automatically add a list of tasks to deal with the disease ,"Elenco delle malattie rilevate sul campo. Quando selezionato, aggiungerà automaticamente un elenco di compiti per affrontare la malattia"
DocType: Asset Repair,Repair Status,Stato di riparazione
apps/erpnext/erpnext/config/accounts.py +67,Accounting journal entries.,Diario scritture contabili.
DocType: Delivery Note Item,Available Qty at From Warehouse,Disponibile Quantità a partire Warehouse
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +295,Please select Employee Record first.,Si prega di selezionare i dipendenti Record prima.
DocType: POS Profile,Account for Change Amount,Conto per quantità di modifica
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +215,Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Riga {0}: Partner / Account non corrisponde con {1} / {2} {3} {4}
DocType: Maintenance Team Member,Maintenance Team Member,Membro del team di manutenzione
DocType: Agriculture Analysis Criteria,Soil Analysis,Analisi del suolo
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +9,Course Code: ,Codice del corso:
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +238,Please enter Expense Account,Inserisci il Conto uscite
DocType: Account,Stock,Magazzino
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1068,"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Row # {0}: Riferimento Tipo di documento deve essere uno di Ordine di Acquisto, fatture di acquisto o diario"
DocType: Employee,Current Address,Indirizzo Corrente
DocType: Item,"If item is a variant of another item then description, image, pricing, taxes etc will be set from the template unless explicitly specified","Se l'articolo è una variante di un altro elemento poi descrizione, immagini, prezzi, tasse ecc verrà impostata dal modello se non espressamente specificato"
DocType: Serial No,Purchase / Manufacture Details,Acquisto / Produzione Dettagli
DocType: Assessment Group,Assessment Group,Gruppo di valutazione
apps/erpnext/erpnext/config/stock.py +325,Batch Inventory,Inventario Batch
DocType: Employee,Contract End Date,Data fine Contratto
DocType: Sales Order,Track this Sales Order against any Project,Traccia questo ordine di vendita nei confronti di qualsiasi progetto
DocType: Sales Invoice Item,Discount and Margin,Sconto e margine
DocType: Lab Test,Prescription,Prescrizione
DocType: Production Planning Tool,Pull sales orders (pending to deliver) based on the above criteria,Tirare ordini di vendita (in attesa di consegnare) sulla base dei criteri di cui sopra
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +98,Not Available,Non disponibile
DocType: Pricing Rule,Min Qty,Qtà Min
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +36,Disable Template,Disattiva il modello
DocType: GL Entry,Transaction Date,Transaction Data
DocType: Production Plan Item,Planned Qty,Quantità prevista
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +121,Total Tax,Totale IVA
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +182,For Quantity (Manufactured Qty) is mandatory,Per quantità (Quantità Prodotte) è obbligatorio
DocType: Stock Entry,Default Target Warehouse,Magazzino di Destinazione Predefinito
DocType: Purchase Invoice,Net Total (Company Currency),Totale Netto (Valuta Azienda)
apps/erpnext/erpnext/education/doctype/academic_year/academic_year.py +14,The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,La Data di fine anno non può essere anteriore alla data di inizio anno. Si prega di correggere le date e riprovare.
DocType: Notification Control,Purchase Receipt Message,Messaggio di Ricevuta di Acquisto
DocType: BOM,Scrap Items,Scrap Articoli
DocType: Production Order,Actual Start Date,Data inizio effettiva
DocType: Sales Order,% of materials delivered against this Sales Order,% dei materiali consegnati su questo Ordine di Vendita
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +62,Set default mode of payment,Imposta il modo di pagamento predefinito
DocType: Grant Application,Withdrawn,Ritirato
DocType: Hub Settings,Hub Settings,Impostazioni Hub
DocType: Project,Gross Margin %,Margine lordo %
DocType: BOM,With Operations,Con operazioni
apps/erpnext/erpnext/accounts/party.py +262,Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.,Scritture contabili sono già stati fatti in valuta {0} per azienda {1}. Si prega di selezionare un account di credito o da pagare con moneta {0}.
DocType: Asset,Is Existing Asset,È esistente Asset
DocType: Salary Detail,Statistical Component,Componente statistico
DocType: Warranty Claim,If different than customer address,Se diverso da indirizzo del cliente
DocType: Purchase Invoice,Without Payment of Tax,Senza pagamento di imposta
DocType: BOM Operation,BOM Operation,Operazione BOM
apps/erpnext/erpnext/config/stock.py +141,Fulfilment,Compimento
DocType: Purchase Taxes and Charges,On Previous Row Amount,Sul valore della riga precedente
DocType: Item,Has Expiry Date,Ha la data di scadenza
apps/erpnext/erpnext/assets/doctype/asset/asset.js +269,Transfer Asset,Trasferimento Asset
DocType: POS Profile,POS Profile,POS Profilo
DocType: Training Event,Event Name,Nome dell&#39;evento
DocType: Physician,Phone (Office),Telefono (Ufficio)
apps/erpnext/erpnext/hooks.py +151,Admission,Ammissione
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +29,Admissions for {0},Ammissioni per {0}
apps/erpnext/erpnext/config/accounts.py +257,"Seasonality for setting budgets, targets etc.","Stagionalità per impostare i budget, obiettivi ecc"
DocType: Supplier Scorecard Scoring Variable,Variable Name,Nome variabile
apps/erpnext/erpnext/stock/get_item_details.py +142,"Item {0} is a template, please select one of its variants","L'articolo {0} è un modello, si prega di selezionare una delle sue varianti"
DocType: Asset,Asset Category,Asset Categoria
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +31,Net pay cannot be negative,Retribuzione netta non può essere negativa
DocType: Assessment Plan,Room,Camera
DocType: Purchase Order,Advance Paid,Anticipo versato
DocType: Item,Item Tax,Tasse dell'Articolo
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +868,Material to Supplier,Materiale al Fornitore
DocType: Soil Texture,Loamy Sand,Sabbia argillosa
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +594,Excise Invoice,Accise Fattura
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +16,Treshold {0}% appears more than once,Soglia {0}% appare più di una volta
DocType: Expense Claim,Employees Email Id,Email Dipendenti
DocType: Employee Attendance Tool,Marked Attendance,Marca Presenza
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +138,Current Liabilities,Passività correnti
apps/erpnext/erpnext/config/selling.py +292,Send mass SMS to your contacts,Invia SMS di massa ai tuoi contatti
DocType: Patient,A Positive,Un positivo
DocType: Program,Program Name,Nome programma
DocType: Purchase Taxes and Charges,Consider Tax or Charge for,Considera Tasse o Costo per
DocType: Driver,Driving License Category,Categoria di patente di guida
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +57,Actual Qty is mandatory,La q.tà reale è obbligatoria
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +81,"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.",{0} ha attualmente una posizione di valutazione del fornitore {1} e gli ordini di acquisto a questo fornitore dovrebbero essere rilasciati con cautela.
DocType: Asset Maintenance Team,Asset Maintenance Team,Asset Maintenance Team
DocType: Employee Loan,Loan Type,Tipo di prestito
DocType: Scheduling Tool,Scheduling Tool,Strumento di pianificazione
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +180,Credit Card,carta di credito
DocType: BOM,Item to be manufactured or repacked,Voce da fabbricati o nuovamente imballati
DocType: Employee Education,Major/Optional Subjects,Principali / Opzionale Soggetti
DocType: Sales Invoice Item,Drop Ship,Drop Ship
DocType: Driver,Suspended,Sospeso
DocType: Training Event,Attendees,I partecipanti
DocType: Employee,"Here you can maintain family details like name and occupation of parent, spouse and children","Qui è possibile mantenere i dettagli della famiglia come il nome e l'occupazione del genitore, coniuge e figli"
DocType: Academic Term,Term End Date,Data Terminologia fine
DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Tasse e oneri dedotti (Azienda valuta)
DocType: Item Group,General Settings,Impostazioni Generali
apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +23,From Currency and To Currency cannot be same,Da Valuta e A Valuta non possono essere gli stessi
DocType: Stock Entry,Repack,Repack
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +6,You must Save the form before proceeding,È necessario salvare il modulo prima di procedere
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +113,Please select the Company first,Si prega di selezionare la società per primo
DocType: Item Attribute,Numeric Values,Valori numerici
apps/erpnext/erpnext/public/js/setup_wizard.js +56,Attach Logo,Allega Logo
apps/erpnext/erpnext/stock/doctype/batch/batch.js +43,Stock Levels,I livelli delle scorte
DocType: Customer,Commission Rate,Tasso Commissione
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +187,Created {0} scorecards for {1} between: ,Creato {0} scorecard per {1} tra:
apps/erpnext/erpnext/stock/doctype/item/item.js +472,Make Variant,Crea variante
apps/erpnext/erpnext/config/hr.py +87,Block leave applications by department.,Blocco domande uscita da ufficio.
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +144,"Payment Type must be one of Receive, Pay and Internal Transfer","Tipo di pagamento deve essere uno dei Ricevere, Pay e di trasferimento interno"
apps/erpnext/erpnext/config/selling.py +179,Analytics,analitica
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +21,Cart is Empty,Carrello è Vuoto
DocType: Vehicle,Model,Modello
DocType: Production Order,Actual Operating Cost,Costo operativo effettivo
DocType: Payment Entry,Cheque/Reference No,N. di riferimento
DocType: Soil Texture,Clay Loam,Clay Loam
apps/erpnext/erpnext/accounts/doctype/account/account.py +83,Root cannot be edited.,Root non può essere modificato .
DocType: Item,Units of Measure,Unità di misura
DocType: Manufacturing Settings,Allow Production on Holidays,Consentire una produzione su Holidays
DocType: Sales Order,Customer's Purchase Order Date,Data ordine acquisto Cliente
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +163,Capital Stock,Capitale Sociale
DocType: Shopping Cart Settings,Show Public Attachments,Mostra gli allegati pubblici
DocType: Packing Slip,Package Weight Details,Pacchetto peso
DocType: Restaurant Reservation,Reservation Time,Tempo di prenotazione
DocType: Payment Gateway Account,Payment Gateway Account,Pagamento Conto Gateway
DocType: Shopping Cart Settings,After payment completion redirect user to selected page.,Dopo il completamento pagamento reindirizzare utente a pagina selezionata.
DocType: Company,Existing Company,società esistente
DocType: Healthcare Settings,Result Emailed,Risultato inviato via email
apps/erpnext/erpnext/controllers/buying_controller.py +84,"Tax Category has been changed to ""Total"" because all the Items are non-stock items",La categoria fiscale è stata modificata in &quot;Totale&quot; perché tutti gli articoli sono oggetti non in magazzino
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +103,Please select a csv file,Seleziona un file csv
DocType: Student Leave Application,Mark as Present,Segna come Presente
DocType: Supplier Scorecard,Indicator Color,Colore dell&#39;indicatore
DocType: Purchase Order,To Receive and Bill,Per ricevere e Bill
apps/erpnext/erpnext/templates/pages/home.html +14,Featured Products,prodotti sponsorizzati
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +136,Designer,Designer
apps/erpnext/erpnext/config/selling.py +163,Terms and Conditions Template,Termini e condizioni Template
DocType: Serial No,Delivery Details,Dettagli Consegna
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +491,Cost Center is required in row {0} in Taxes table for type {1},Centro di costo è richiesto in riga {0} nella tabella Tasse per il tipo {1}
DocType: Program,Program Code,Codice di programma
DocType: Terms and Conditions,Terms and Conditions Help,Termini e condizioni Aiuto
,Item-wise Purchase Register,Articolo-saggio Acquisto Registrati
DocType: Driver,Expiry Date,Data Scadenza
DocType: Healthcare Settings,Employee name and designation in print,Nome e designazione del dipendente in stampa
,accounts-browser,schema contabile
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +368,Please select Category first,Si prega di selezionare Categoria prima
apps/erpnext/erpnext/config/projects.py +13,Project master.,Progetto Master.
apps/erpnext/erpnext/controllers/status_updater.py +209,"To allow over-billing or over-ordering, update ""Allowance"" in Stock Settings or the Item.","Per consentire un eccesso di fatturazione o sopra-ordinazione, aggiornare &quot;Allowance&quot; in Impostazioni archivio o la voce."
DocType: Global Defaults,Do not show any symbol like $ etc next to currencies.,Non visualizzare nessun simbolo tipo € dopo le Valute.
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +459, (Half Day),(Mezza giornata)
DocType: Payment Term,Credit Days,Giorni Credito
apps/erpnext/erpnext/utilities/activation.py +128,Make Student Batch,Crea un Insieme di Studenti
DocType: Fee Schedule,FRQ.,FRQ.
DocType: Leave Type,Is Carry Forward,È Portare Avanti
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +840,Get Items from BOM,Recupera elementi da Distinta Base
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Lead Time Days,Giorni per la Consegna
apps/erpnext/erpnext/controllers/accounts_controller.py +600,Row #{0}: Posting Date must be same as purchase date {1} of asset {2},Row # {0}: Data di registrazione deve essere uguale alla data di acquisto {1} per l'asset {2}
DocType: Program Enrollment,Check this if the Student is residing at the Institute's Hostel.,Controllare questo se lo studente è residente presso l&#39;Ostello dell&#39;Istituto.
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +125,Please enter Sales Orders in the above table,Si prega di inserire gli ordini di vendita nella tabella precedente
,Stock Summary,Sintesi della
apps/erpnext/erpnext/config/assets.py +50,Transfer an asset from one warehouse to another,Trasferire un bene da un magazzino all&#39;altro
DocType: Vehicle,Petrol,Benzina
apps/erpnext/erpnext/config/learn.py +217,Bill of Materials,Distinte materiali
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +103,Row {0}: Party Type and Party is required for Receivable / Payable account {1},Riga {0}: Tipo Partner e Partner sono necessari per conto Crediti / Debiti  {1}
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +94,Ref Date,Data Rif
DocType: Employee,Reason for Leaving,Motivo per Lasciare
DocType: BOM Operation,Operating Cost(Company Currency),Costi di funzionamento (Società di valuta)
DocType: Employee Loan Application,Rate of Interest,Tasso di interesse
DocType: Expense Claim Detail,Sanctioned Amount,Importo sanzionato
DocType: GL Entry,Is Opening,Sta aprendo
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +194,Row {0}: Debit entry can not be linked with a {1},Riga {0}: addebito iscrizione non può essere collegato con un {1}
DocType: Journal Entry,Subscription Section,Sezione di sottoscrizione
apps/erpnext/erpnext/accounts/doctype/account/account.py +179,Account {0} does not exist,Il Conto {0} non esiste
DocType: Training Event,Training Program,Programma di allenamento
DocType: Account,Cash,Contante
DocType: Employee,Short biography for website and other publications.,Breve biografia per il sito web e altre pubblicazioni.
