public void Reload(CondominioDTO condominio, EsercizioDTO esercizio)
{
_registrazioneSpese.ClearAll();
_registrazioneSpese.Reload(condominio, esercizio);
_spesa = null;
if(_spese != null)
_spese.Clear();
spesaDTOBindingSource.Clear();
}
public GestioneSpesa(SpesaDTO spesa, CondominioDTO condominio, EsercizioDTO esercizio, List<SpesaDTO> spese)
{
IsConfirmed = false;
InitializeComponent();
_spese = spese;
_condominio = condominio;
_esercizio = esercizio;
LoadSpesa(spesa);
}
public RegistrazioneSpeseAccorpateUI(SpesaDTO spesa, CondominioDTO condominio, EsercizioDTO esercizio, Gipasoft.Windows.Forms.Templates.UpdatableStandardForm formGestione, List<SpesaDTO> spese)
{
InitializeComponent();
_spese = spese;
_formGestione = formGestione;
_condominio = condominio;
_esercizio = esercizio;
_spesa = spesa;
}
public SpesaDetrazioneDTO(SpesaDTO dto)
{
ID = dto.ID;
DescrizioneCondominio = dto.DescrizioneCondominio;
IdentificativoArchiviazioneOttica = dto.IdentificativoArchiviazioneOttica;
TipoDocumento = dto.TipoDocumento;
NumeroDocumento = dto.NumeroDocumento;
DataDocumento = dto.DataDocumento;
DataInizioCompetenza = dto.DataInizioCompetenza;
DataFineCompetenza = dto.DataFineCompetenza;
IsAbilitataArchiviazioneOttica = dto.IsAbilitataArchiviazioneOttica;
IsPrestazioneQualita = dto.IsPrestazioneQualita;
IsRipartoPersonalizzato = dto.IsRipartoPersonalizzato;
ImportoLordo = dto.ImportoLordo;
ImportoNettoAPagare = dto.ImportoNettoAPagare;
ImportoPagato = dto.ImportoPagato;
ImportoIva = dto.ImportoIva;
Imponibile = dto.Imponibile;
AliquotaCassaProfessionisti = dto.AliquotaCassaProfessionisti;
CassaProfessionisti = dto.CassaProfessionisti;
AliquotaRitenuta = dto.AliquotaRitenuta;
IsRitenutaCalcoloImponibile = dto.IsRitenutaCalcoloImponibile;
ImportoRitenuta = dto.ImportoRitenuta;
AltreSpese = dto.AltreSpese;
AltreSpeseEsenti = dto.AltreSpeseEsenti;
SpeseEsentiRitenuta = dto.SpeseEsentiRitenuta;
Detrazione = dto.Detrazione;
IsMultiIva = dto.IsMultiIva;
Contestata = dto.Contestata;
Sinistro = dto.Sinistro;
EsclusaRendiconto = dto.EsclusaRendiconto;
Autorizzata = dto.Autorizzata;
Note = dto.Note;
IdFornitore = dto.IdFornitore;
DisplayFornitore = dto.DisplayFornitore;
IdEsercizio = dto.IdEsercizio;
DescrizioneEsercizio = dto.DescrizioneEsercizio;
StatoSpesa = dto.StatoSpesa;
IdSpesaRiferimento = dto.IdSpesaRiferimento;
DescrizioneSpesaRiferimento = dto.DescrizioneSpesaRiferimento;
Utenza = dto.Utenza;
DescrizioneBilancio = dto.DescrizioneBilancio;
DescrizioneSottoconto = dto.DescrizioneSottoconto;
Dettaglio = dto.Dettaglio;
NominativoSpesaPersonale = dto.NominativoSpesaPersonale;
ScaleAddebito = dto.ScaleAddebito;
DataRegistrazione = dto.DataRegistrazione;
IdTestata = dto.IdTestata;
IdAddebitoCompetenze = dto.IdAddebitoCompetenze;
IdDocumenti = dto.IdDocumenti;
Dettagli = dto.Dettagli;
Scadenze = dto.Scadenze;
RipartizioneDetrazione = new List<RipartizioneSpesaDTO>();
}
public void LoadSpesa(SpesaDTO spesa)
{
BusinessClass = new[] { (BaseDTOOfint)spesa };
_spesa = spesa;
//ReadOnly = !_fatturaService.IsAllowUpdate(_spesa);
ultraToolbarsManagerStandard.Tools["Cancella"].SharedProps.Enabled = !ReadOnly;
_registrazioneSpese = new RegistrazioneSpeseFiscaleUC(spesa.ID, _condominio, _esercizio);
((RegistrazioneSpeseFiscaleUC)_registrazioneSpese).Confirm += registrazioneSpeseConfirm;
MainStandardForm_Fill_Panel.Controls.Add(_registrazioneSpese);
_registrazioneSpese.Dock = DockStyle.Fill;
}
public void LoadSpesa(SpesaDTO spesa)
{
_esercizio = getEsercizioService().GetById(spesa.IdEsercizio.GetValueOrDefault());
_condominio = getCondominioCacheService().GetById(_esercizio.IdCondominio, true);
ultraToolbarsManagerStandard.Tools["Cancella"].SharedProps.Enabled = !ReadOnly;
if (spesa.IdSpesaRiferimento > 0)
{
_registrazioneSpese = new RegistrazioneSpeseAccorpateUI(spesa, _condominio, _esercizio, this, _spese);
((RegistrazioneSpeseAccorpateUI)_registrazioneSpese).Confirm += registrazioneSpeseConfirm;
}
else
{
_registrazioneSpese = new RegistrazioneSpeseUI(spesa, _condominio, _esercizio, this);
((RegistrazioneSpeseUI)_registrazioneSpese).SetLayout();
if (((RegistrazioneSpeseUI)_registrazioneSpese).GetSpesa() != null)
((RegistrazioneSpeseUI)_registrazioneSpese).Confirm += registrazioneSpeseConfirm;
else
{
Close();
CommonMessages.DisplayWarning("La fattura non è più presente");
Dispose();
}
spesa = ((RegistrazioneSpeseUI) _registrazioneSpese).GetSpesa();
BusinessClass = new[] { (BaseDTOOfint)spesa };
_spesa = spesa;
}
MainStandardForm_Fill_Panel.Controls.Add(_registrazioneSpese);
_registrazioneSpese.Dock = DockStyle.Fill;
base.EnableSaveLayout = false;
if (!string.IsNullOrEmpty(spesa.IdentificativoArchiviazioneOttica))
{
var identificativo = spesa.IdentificativoArchiviazioneOttica.Split('-');
Text = spesa.TipoDocumento + @" " + identificativo[3] + @"-" + identificativo[2];
}
}
private void apriSpesa(SpesaDTO spesa)
{
try
{
if (spesa != null && spesa.ID > 0)
{
var esercizio = getEsercizioService().GetById(spesa.IdEsercizio.GetValueOrDefault());
var condominio = getCondominioService().GetById(esercizio.IdCondominio, true);
if (spesa.StatoSpesa == StatoSpesaEnum.PagataAltroAmministratore)
{
var form = getDettaglioSpesaUIService().GetFormDettaglioFiscale(spesa.ID);
if (ParentForm != null) form.MdiParent = ParentForm.MdiParent;
form.Show();
}
else switch (spesa.TipoDocumento)
{
case "Bolletta":
{
var form = getDettaglioBollettaUIService().GetFormDettaglio(spesa.ID, condominio, esercizio);
if (ParentForm != null) form.MdiParent = ParentForm.MdiParent;
form.Show();
}
break;
case "Fatt.Quadr.":
{
var form = getBilancioAperturaUIService().GetFormDettaglio(condominio, esercizio);
if (ParentForm != null) form.MdiParent = ParentForm.MdiParent;
form.Show();
}
break;
default:
if (spesa.TipoDocumento == "Nota di accredito" && spesa.StatoSpesa == StatoSpesaEnum.Stornata)
{
var form = getDettaglioSpesaUIService().GetFormNotaAccredito(spesa.ID, condominio, esercizio);
if (ParentForm != null) form.MdiParent = ParentForm.MdiParent;
form.Show();
}
else
{
var form = getDettaglioSpesaUIService().GetFormDettaglio(spesa.ID);
if (!form.IsDisposed)
{
if (ParentForm != null) form.MdiParent = ParentForm.MdiParent;
form.Show();
}
}
break;
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nell'apertura di una spesa - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), Security.Login.Instance.CurrentLogin().Azienda);
throw;
}
}
public bool IsAllowCambioEsercizio(SpesaDTO spesa)
{
return true;
}
public AuthorizationMessages IsAllowDelete(SpesaDTO spesa)
{
var result = GetServiceClient().IsAllowDeleteSpesa(spesa.ID, GetUserInfo());
CloseService();
return result;
}
private void executeNew()
{
btnConferma.Enabled = false;
btnPagamento.Visible = true;
btnAnnullaPagamento.Visible = false;
if (_esercizio != null)
{
_spesa = _fatturaService.GetNew(_spesaRiferimento, _condominio);
_spesa.IdEsercizio = _esercizio.ID;
bindScadenze();
}
if (!_speseAccorpate)
{
sceltaFornitore.Reset();
clearDettaglioFields();
}
else
{
imponibileDettaglio.ValueObject = null;
importoDettaglioIva.ValueObject = null;
importoDettaglioSpesa.ValueObject = null;
clearDescrizioneMovimenti();
}
scadenzaBindingSource.Clear();
scadenze.PerformAction(UltraGridAction.FirstRowInBand);
}
public RegistrazioneSpeseUI(SpesaDTO spesa, CondominioDTO condominio, EsercizioDTO esercizio, UpdatableStandardForm formGestione)
{
try
{
Dirty = false;
InitializeComponent();
_isInserimento = false;
inizializza();
_formGestione = formGestione;
_condominio = condominio;
_esercizio = esercizio;
_spesa = _fatturaService.GetSingleInstance(spesa);
if (_spesa != null)
{
var prop = new CustomControlProperties { AlwaysEnable = true };
btnDocumento.Tag = prop;
// Imposto layout pagamento
_pagamentoImmediato = false;
btnPagamento.Text = @"Pagamento";
if (_spesa.StatoSpesa != StatoSpesaEnum.Inserita)
{
btnPagamento.Visible = false;
if (_spesa.StatoSpesa == StatoSpesaEnum.Pagata || _spesa.StatoSpesa == StatoSpesaEnum.ParzialmentePagata)
btnAnnullaPagamento.Visible = true;
}
if (_spesa.IdSpesaRiferimento != null && _spesa.IdSpesaRiferimento > 0)
{
_speseAccorpate = true;
_spesaRiferimento = _fatturaService.GetById(_spesa.IdSpesaRiferimento.Value);
}
if (_spesa.Dettagli.Count > 1)
{
altreSpeseDettaglio.Visible = false;
altreSpeseEsenti.Visible = false;
speseEsentiRitenuta.Visible = false;
lblAltreSpeseDettaglio.Visible = false;
lblAltreSpese.Visible = false;
lblAltreSpeseEsenti.Visible = false;
getMovimentoContabileService().IsMultiSpesa = true;
}
}
}
catch (Exception ex)
{
var idCondominio = "<NULL>";
if (condominio != null)
idCondominio = condominio.ID.ToString();
var idEsercizio = "<NULL>";
if (esercizio != null)
idEsercizio = esercizio.ID.ToString();
_log.Error("Errore nel costruttore - " + Utility.GetMethodDescription() + " - spesa:" + getIdSpesa().GetValueOrDefault() + " - condominio:" + idCondominio + " - esercizio:" + idEsercizio + " - azienda:" + Security.Login.Instance.CurrentLogin().Azienda, ex);
throw;
}
}
public bool IsAllowUpdate(SpesaDTO spesa, EsercizioDTO esercizio)
{
if (esercizio.StatoEsercizio == StatoEsercizioEnum.Aperto)
return true;
return false;
}
private DocumentoDTO setDocumento(SpesaDTO spesa, DocumentoDTO documento)
{
documento.IdSpesa = spesa.ID;
documento.Tipo = "Fattura";
documento.IdFornitore = spesa.IdFornitore;
return documento;
}
public ResultSpesa ManageDomainEntity(SpesaDTO spesaDto, bool isMultiIva)
{
try
{
return manageSpesa(spesaDto, isMultiIva);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella gestione delle Fatture/Spese - {0} - id:{1}", ex, Utility.GetMethodDescription(), spesaDto.ID);
throw;
}
}
public SpesaInfoDTO Salva(SpesaDTO spesaDto, IDictionary<DettaglioSpesaDTO, RipartizioneSpeseDTO> listaRipartizione, bool isMultiIva)
{
try
{
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
var movimentoContabileService = _windsorRepository.GetContainer(_info.Azienda).Resolve<IMovimentiContabiliService>();
var ripartizioneSpeseService = _windsorRepository.GetContainer(_info.Azienda).Resolve<IRipartizioneSpeseService>();
var protocolloService = _windsorRepository.GetContainer(_info.Azienda).Resolve<IProtocolloService>();
var ripartizioneSpesa = new RipartizioneSpeseRepository(_info, _windsorRepository);
// ------------------------------------------------------------
// Verifico se il fornitore è presente
// ------------------------------------------------------------
var fornitore = daoFactory.GetFornitoreDao().Find(spesaDto.IdFornitore.GetValueOrDefault(), false);
if (fornitore == null)
{
return new SpesaInfoDTO { Id = 0, IdentificativoArchiviazione = null, NumeroProtocollo = 0, StampaEtichettaArchiviazione = false, Message = "Il fornitore non è più presente in archivio." };
}
// ------------------------------------------------------------
// Prima di ogni modifica recupero i movimenti secondari
// ------------------------------------------------------------
IList<MovimentoContabile> movimentiSecondari = null;
if (spesaDto.ID > 0)
{
var spesa = daoFactory.GetSpesaDao().Find(spesaDto.ID, false);
if(spesa != null)
movimentiSecondari = ripartizioneSpeseService.GetMovimentiSecondari(spesa);
}
// ------------------------------------------------------------
// Creo la ripartizione per ogni movimento
// ------------------------------------------------------------
foreach (var dettaglioDto in spesaDto.Dettagli)
{
RipartizioneSpeseDTO ripartizione = null;
var dettaglio = ripartizioneSpesa.GetDettaglioDto(listaRipartizione, dettaglioDto.NumeroRiga.GetValueOrDefault());
if (dettaglio != null)
{
if (listaRipartizione.ContainsKey(dettaglio))
ripartizione = listaRipartizione[dettaglio];
}
if (ripartizione == null || ripartizione.UnitaImmobiliari == null)
{
var oldRipartizione = ripartizione;
ripartizione = new RipartizioneSpeseDTO();
if(oldRipartizione != null)
{
ripartizione.Descrizione = oldRipartizione.Descrizione;
ripartizione.DescrizioneVoceSpesa = oldRipartizione.DescrizioneVoceSpesa;
ripartizione.NomeModello = oldRipartizione.NomeModello;
}
}
foreach (var movimentoDto in dettaglioDto.Movimenti)
{
if (movimentoDto.ID > 0)
{
var movimento = daoFactory.GetMovimentoContabileDao().Find(movimentoDto.ID, false);
if (movimento?.MovimentoStorno != null)
{
try
{
movimentoDto.IdMovimentoStorno = movimento.MovimentoStorno.ID;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella lettura dell'id del movimento di storno - {0} - spesa:{1} - movimento:{2}", ex, Utility.GetMethodDescription(), spesaDto.ID, movimento.ID);
}
finally
{
movimento.MovimentoStorno = null;
}
}
}
movimentoDto.ID = 0;
if(dettaglioDto.IdModelloRipartizione == null)
ripartizioneSpesa.GetRipartizioneByMovimento(movimentoDto, spesaDto.IdEsercizio.GetValueOrDefault(), ripartizione);
}
}
// --------------------------------
// Aggiungo le ripartizioni tra le diverse unità immobiliari
// --------------------------------
ripartizioneSpesa.AddMovimentiRipartizione(listaRipartizione, spesaDto);
// --------------------------------
// Salvataggio della spesa
// --------------------------------
if(spesaDto.StatoSpesa == StatoSpesaEnum.Undefined)
spesaDto.StatoSpesa = StatoSpesaEnum.Inserita;
var resultSpesa = ManageDomainEntity(spesaDto, isMultiIva);
if (resultSpesa.Spesa != null)
{
var spesa = resultSpesa.Spesa;
// ripartizione di default
// TODO: Dato che la ripartizione ora viene ricalcolata quando serve (stampa riparto bilancio ecc....)
// probabilmente NON è più necessaria la chiamata a questo metodo
//ripartizioneSpesa.AddDefaultRipartizione(listaRipartizione, spesa);
// --------------------------------
// Movimenti contabili secondari
// --------------------------------
// Eliminazione della vecchia testata
if (spesaDto.IdTestata > 0)
{
var testata = daoFactory.GetTestataMovimentoContabileDao().Find(spesaDto.IdTestata, false);
// bugid#4168
if(testata != null)
deleteTestata(testata, daoFactory);
}
// Creazione dei nuovi movimenti contabili
movimentoContabileService.SetMovimentiInserimentoSpesa(spesa, null, spesaDto.DataRegistrazione);
// --------------------------------
// Modello registrazione contabile
// --------------------------------
if (listaRipartizione.Count > 0)
{
foreach (var dettaglio in spesa.Dettagli)
{
var kvpRipartizione = getDettaglioDto(listaRipartizione, dettaglio.NumeroRiga.GetValueOrDefault());
if (kvpRipartizione != null)
{
var listaMovimenti = new List<MovimentoContabileDTO>(kvpRipartizione.GetValueOrDefault().Key.Movimenti.Length);
listaMovimenti.AddRange(kvpRipartizione.GetValueOrDefault().Key.Movimenti);
var modello = ripartizioneSpesa.SalvaModelloRipartizioneContabile(kvpRipartizione.GetValueOrDefault().Value, dettaglio, listaMovimenti, dettaglio.ImportoLordo.GetValueOrDefault());
if (modello != null)
{
if (kvpRipartizione.GetValueOrDefault().Value.AssociatoFornitore)
{
var modelloContabileFornitore = new ModelloContabileFornitore(spesa.FornitoreRiferimento, modello, null);
daoFactory.GetModelloContabileFornitoreDao().SaveOrUpdate(modelloContabileFornitore);
}
dettaglio.ModelloRipartizione = modello;
}
}
}
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Aggiorno eventuali movimenti secondari collegati.
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
if (movimentiSecondari != null)
ripartizioneSpeseService.UpdateMovimentiSecondari(spesa, movimentiSecondari);
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Aggiorno i documenti
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
if (spesaDto.IdDocumenti.Count > 0)
{
foreach (var idDoc in spesaDto.IdDocumenti)
{
var documento = daoFactory.GetDocumentoDao().Find(idDoc, false);
if(documento != null)
documento.SpesaRiferimento = spesa;
}
}
// ======================================================================================
// Registro gli eventuali pagamenti immediati
// ======================================================================================
var pagamentoService = _windsorRepository.GetContainer(_info.Azienda).Resolve<IPagamentoService>();
pagamentoService.CreatePagamentiImmediati(spesa.ID, spesaDto.Scadenze, null);
// ======================================================================================
// Recupero il numero di protocollo e l'identificativo di archiviazione
// ======================================================================================
if (spesa.NumeroProtocollo == null)
{
var progressivo = protocolloService.GetProgressivo(TipoProtocollo.Fattura, spesa.EsercizioRiferimento.DataApertura.GetValueOrDefault().Year, spesa.EsercizioRiferimento.CondominioRiferimento);
if (progressivo.Progressivo != null)
{
spesa.NumeroProtocollo = progressivo.Progressivo;
spesa.AnnoArchiviazioneOttica = spesa.EsercizioRiferimento.DataApertura.GetValueOrDefault().Year;
}
else
return new SpesaInfoDTO { Id = 0, IdentificativoArchiviazione = null, NumeroProtocollo = 0, StampaEtichettaArchiviazione = false, Message = progressivo.Message };
}
var identificativoArchiviazione = getArchiviazioneOtticaService().GetIdentificativoArchiviazione(spesa);
var impostazioni = daoFactory.GetImpostazioniAziendaDao().GetByAzienda(spesa.EsercizioRiferimento.CondominioRiferimento.Azienda.ID);
if (impostazioni == null)
{
impostazioni = new ImpostazioniAzienda(daoFactory.GetAziendaDao().GetById(spesa.EsercizioRiferimento.CondominioRiferimento.Azienda.ID, false));
daoFactory.GetImpostazioniAziendaDao().SaveOrUpdate(impostazioni);
}
var stampaEtichetta = impostazioni.UtilizzoEtichettatriceArchiviazioneOtticaFatture && spesa.IsAbilitataArchiviazioneOttica && spesaDto.ID == 0;
var etichettatrice = impostazioni.EtichettatriceArchiviazioneOttica;
var tipoEtichetta = impostazioni.TipoEtichettaArchiviazioneOttica;
var trayEtichettatriceAttivazioneOttica = impostazioni.TrayEtichettatriceAttivazioneOttica;
// ======================================================================================
// Aggiorno eventuali movimenti per interessi e sanzioni pagati in ritardo
// ======================================================================================
movimentoContabileService.SetMovimentiInteressiSanzioni(spesa);
return new SpesaInfoDTO { Id = spesa.ID, NumeroProtocollo = spesa.NumeroProtocollo.GetValueOrDefault(), IdentificativoArchiviazione = identificativoArchiviazione, StampaEtichettaArchiviazione = stampaEtichetta, EtichettatriceArchiviazione = etichettatrice, TipoEtichettaArchiviazione = tipoEtichetta, TrayEtichettatriceAttivazioneOttica = trayEtichettatriceAttivazioneOttica };
}
return new SpesaInfoDTO { Id = 0, NumeroProtocollo = 0, IdentificativoArchiviazione = null, StampaEtichettaArchiviazione = false, EtichettatriceArchiviazione = string.Empty, TipoEtichettaArchiviazione = "Testo", Message = resultSpesa.Message };
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel salvataggio della spesa - {0} - numeroDocumento:{1} - dataDocumento:{2} - dataRegistrazione:{3}", ex, Utility.GetMethodDescription(), spesaDto.NumeroDocumento, spesaDto.DataDocumento, spesaDto.DataRegistrazione);
throw;
}
}
private string update(SpesaDTO dto, bool isMultiIva, out Spesa item)
{
var result = string.Empty;
item = null;
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
try
{
item = daoFactory.GetSpesaDao().Find(dto.ID, false);
if(item != null)
{
// Condizione necessaria per il controllo del fatto che sul DB ho una versione uguale o più vecchia
if (dto.Version == item.Version)
{
item.AliquotaRitenuta = dto.AliquotaRitenuta;
item.IsRitenutaCalcoloImponibile = dto.IsRitenutaCalcoloImponibile;
item.AltreSpese = dto.AltreSpese;
item.AltreSpeseEsenti = dto.AltreSpeseEsenti;
item.SpeseEsentiRitenuta = dto.SpeseEsentiRitenuta;
item.AliquotaCassaProfessionisti = dto.AliquotaCassaProfessionisti;
item.CassaProfessionisti = dto.CassaProfessionisti;
item.DataDocumento = dto.DataDocumento;
item.DataInizioCompetenza = dto.DataInizioCompetenza;
item.DataFineCompetenza = dto.DataFineCompetenza;
item.Detrazione = dto.Detrazione;
item.ImportoRitenuta = dto.ImportoRitenuta;
item.Note = dto.Note;
item.NumeroDocumento = dto.NumeroDocumento;
item.IsAbilitataArchiviazioneOttica = dto.IsAbilitataArchiviazioneOttica;
item.IsPrestazioneQualita = dto.IsPrestazioneQualita;
item.Stato = dto.StatoSpesa;
item.TipoDocumento = dto.TipoDocumento;
item.IsMultiIva = dto.IsMultiIva;
item.Contestata = dto.Contestata;
item.EsclusaRendiconto = dto.EsclusaRendiconto;
item.IsRipartoPersonalizzato = dto.IsRipartoPersonalizzato;
item.Autorizzata = dto.Autorizzata;
item.EsenteRegimeMinimo = dto.EsenteRegimeMinimo;
if (dto.Sinistro)
item.Sinistro = 1;
item.EsercizioRiferimento = daoFactory.GetEsercizioDao().GetById(dto.IdEsercizio.GetValueOrDefault(), false);
item.FornitoreRiferimento = daoFactory.GetFornitoreDao().GetById(dto.IdFornitore.GetValueOrDefault(), false);
// ------------------------------------------
// Dettagli
// ------------------------------------------
item.Dettagli.Clear();
DettaglioSpesa dettaglioMultiIva = null;
for (var i = 0; i < dto.Dettagli.Length; i++)
{
dto.Dettagli[i].IdSpesaRiferimento = item.ID;
if (dto.IdSpesaRiferimento != null && dto.IdSpesaRiferimento > 0)
{
var spesaRiferimento = daoFactory.GetSpesaDao().GetById(dto.IdSpesaRiferimento.Value, false);
dettaglioMultiIva = IesiGenericCollections<DettaglioSpesa>.GetByIndex(spesaRiferimento.Dettagli, i);
}
int? id = dto.Dettagli[i].ID;
if ((dto.Dettagli[i].Stato == "U") || (dto.Dettagli[i].Stato == "I"))
{
var resultDettaglio = ManageDettaglioDomainEntity(dto.Dettagli[i], dettaglioMultiIva);
if (resultDettaglio.Dettaglio != null)
id = resultDettaglio.Dettaglio.ID;
else
return resultDettaglio.Message;
}
var dett = daoFactory.GetDettaglioSpesaDao().GetById(id.Value, false);
item.Dettagli.Add(dett);
dett.SpesaRiferimento = item;
if (i == 0 && isMultiIva)
dettaglioMultiIva = dett;
}
// ------------------------------------------
// Scadenze
// ------------------------------------------
item.Scadenze.Clear();
foreach (var t in dto.Scadenze)
{
t.IdSpesa = item.ID;
int? id = t.ID;
if ((t.Stato == "U") || (t.Stato == "I"))
id = getScadenzaRepository().ManageDomainEntity(t);
var scad = daoFactory.GetScadenzaFatturaDao().GetById(id.GetValueOrDefault(), false);
item.Scadenze.Add(scad);
scad.SpesaRiferimento = item;
}
}
else
{
// Eccezione: Sul db c'è qualche cosa di più nuovo.
_log.ErrorFormat("Errore nel salvataggio dei dettagli delle Fatture/Spese id:{0} - il dato sul db è più recente di quello che si vuole salvare", dto.ID);
result = "Errore nel salvataggio dei dettagli delle Fatture/Spese id:" + dto.ID + " - il dato sul db è più recente di quello che si vuole salvare";
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel salvataggio della gestione dei dettagli delle Fatture/Spese - {0} - id:{1}", ex, Utility.GetMethodDescription(), dto.ID);
throw;
}
return result;
}
private ResultSpesa manageSpesa(SpesaDTO spesaDto, bool isMultiIva)
{
Spesa spesa = null;
var message = string.Empty;
// Controllo sullo stato U, D, I
switch (spesaDto.Stato.ToUpper())
{
case "U":
message = update(spesaDto, isMultiIva, out spesa);
break;
case "I":
message = insert(spesaDto, isMultiIva, out spesa);
break;
}
if (!string.IsNullOrEmpty(message))
spesa = null;
return new ResultSpesa(spesa, message);
}
public SpesaDTO GetNew(SpesaDTO spesaOriginale, CondominioDTO condominio)
{
try
{
var aziendaDTO = _aziendaService.GetAzienda();
var spesa = new SpesaDTO
{
Autorizzata = !aziendaDTO.AutorizzazioneScadenze,
IsAbilitataArchiviazioneOttica = _condominioService.GetById(condominio.ID, true).IsAbilitataArchiviazioneOtticaPassivi,
Dettagli = new List<DettaglioSpesaDTO>()
};
if (spesaOriginale != null)
{
spesa.AliquotaRitenuta = spesaOriginale.AliquotaRitenuta;
spesa.Detrazione = spesaOriginale.Detrazione;
spesa.DisplayFornitore = spesaOriginale.DisplayFornitore;
spesa.DisplayName = spesaOriginale.DisplayName;
spesa.IdEsercizio = spesaOriginale.IdEsercizio;
spesa.IdFornitore = spesaOriginale.IdFornitore;
spesa.TipoDocumento = spesaOriginale.TipoDocumento;
spesa.Contestata = spesaOriginale.Contestata;
spesa.Sinistro = spesaOriginale.Sinistro;
foreach (var dettaglio in spesaOriginale.Dettagli)
{
var dettaglioNew = new DettaglioSpesaDTO
{
AliquotaIva = dettaglio.AliquotaIva,
Descrizione = dettaglio.Descrizione,
DisplayName = dettaglio.DisplayName,
ID = 0,
IdModelloRipartizione = dettaglio.IdModelloRipartizione,
Note = dettaglio.Note,
NumeroRiga = dettaglio.NumeroRiga,
SoggettoRitenutaAcconto = dettaglio.SoggettoRitenutaAcconto,
Movimenti = new List<MovimentoContabileDTO>()
};
foreach (var movimento in dettaglio.Movimenti)
{
var movimentoNew = new MovimentoContabileDTO
{
Causale = movimento.Causale,
Descrizione = movimento.Descrizione,
DisplayName = movimento.DisplayName,
ID = 0,
IdCondomino = movimento.IdCondomino,
IdConto = movimento.IdConto,
IdFornitore = movimento.IdFornitore,
NumeroRiga = movimento.NumeroRiga,
IdNumeroRigaMovimentoMultiIvaPrincipale = movimento.NumeroRiga,
IdSottoConto = movimento.IdSottoConto
};
dettaglioNew.Movimenti.Add(movimentoNew);
}
spesa.Dettagli.Add(dettaglioNew);
}
}
else
spesa.TipoDocumento = "FATTURA";
spesa.Scadenze = new List<ScadenzaFatturaDTO>();
spesa.StatoSpesa = StatoSpesaEnum.Inserita;
return spesa;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella lettura della nuova spesa - {0} - spesa:{1} - condominio:{2}", ex, Gipasoft.Library.Utility.GetMethodDescription(), spesaOriginale != null ? spesaOriginale.ID.ToString() : "<NULL>", condominio != null ? condominio.ID.ToString() : "<NULL>");
throw;
}
}
public decimal? GetImportoRitenuta(SpesaDTO spesa, decimal? importo, decimal importoCorrenteRitenuta)
{
decimal? importoReturn = null;
if (spesa.StatoSpesa == StatoSpesaEnum.Inserita || spesa.StatoSpesa == StatoSpesaEnum.Autorizzata)
{
var divisore = spesa.ImportoLordo - spesa.ImportoRitenuta;
if (importo != null && divisore > 0)
importoReturn = ((importo - spesa.AltreSpeseEsenti.GetValueOrDefault()) / divisore) * spesa.ImportoRitenuta.GetValueOrDefault();
}
else if(spesa.ImportoRitenuta != null && spesa.ImportoRitenuta != 0)
importoReturn = spesa.ImportoRitenuta.GetValueOrDefault() - spesa.Scadenze.Sum(item => item.ImportoRitenuta) + importoCorrenteRitenuta;
return importoReturn;
}
public SpesaDTO GetSingleInstance(SpesaDTO fattura)
{
if (fattura != null && fattura.ID > 0)
return GetById(fattura.ID);
return fattura;
}
public string ShowDocumento(SpesaDTO spesa)
{
var esercizio = _esercizioService.GetById(spesa.IdEsercizio.GetValueOrDefault());
return _archiviazioneService.ShowDocumento(null, TipoDocumento.FatturaPassiva, esercizio.DataApertura.GetValueOrDefault().Year, spesa.IdentificativoArchiviazioneOttica);
}
public List<DocumentoDTO> GetDocumenti(SpesaDTO spesa)
{
return spesa != null ? _documentoService.GetBySpesa(spesa) : new List<DocumentoDTO>();
}
private string insert(SpesaDTO dto, bool isMultiIva, out Spesa item)
{
string result = string.Empty;
item = null;
try
{
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
item = new Spesa(daoFactory.GetFornitoreDao().GetById(dto.IdFornitore.GetValueOrDefault(), false), daoFactory.GetEsercizioDao().GetById(dto.IdEsercizio.GetValueOrDefault(), false), null)
{
AliquotaRitenuta = dto.AliquotaRitenuta,
IsRitenutaCalcoloImponibile = dto.IsRitenutaCalcoloImponibile,
AltreSpese = dto.AltreSpese,
AltreSpeseEsenti = dto.AltreSpeseEsenti,
SpeseEsentiRitenuta = dto.SpeseEsentiRitenuta,
AliquotaCassaProfessionisti = dto.AliquotaCassaProfessionisti,
CassaProfessionisti = dto.CassaProfessionisti,
DataDocumento = dto.DataDocumento,
DataInizioCompetenza = dto.DataInizioCompetenza,
DataFineCompetenza = dto.DataFineCompetenza,
Detrazione = dto.Detrazione,
ImportoRitenuta = dto.ImportoRitenuta,
Note = dto.Note,
NumeroDocumento = dto.NumeroDocumento,
IsAbilitataArchiviazioneOttica = dto.IsAbilitataArchiviazioneOttica,
IsPrestazioneQualita = dto.IsPrestazioneQualita,
Stato = dto.StatoSpesa,
TipoDocumento = dto.TipoDocumento,
IsMultiIva = dto.IsMultiIva,
Contestata = dto.Contestata,
EsclusaRendiconto = dto.EsclusaRendiconto,
IsRipartoPersonalizzato = dto.IsRipartoPersonalizzato,
Autorizzata = dto.Autorizzata,
EsenteRegimeMinimo = dto.EsenteRegimeMinimo
};
if (dto.Sinistro)
item.Sinistro = 1;
if (dto.IdSpesaRiferimento != null && dto.IdSpesaRiferimento > 0)
item.SpesaRiferimento = daoFactory.GetSpesaDao().GetById(dto.IdSpesaRiferimento.Value, false);
daoFactory.GetSpesaDao().SaveOrUpdate(item);
// ------------------------------------------
// Dettagli
// ------------------------------------------
item.Dettagli.Clear();
DettaglioSpesa dettaglioMultiIva = null;
for (var i = 0; i < dto.Dettagli.Length; i++)
{
dto.Dettagli[i].IdSpesaRiferimento = item.ID;
if (dto.IdSpesaRiferimento != null && dto.IdSpesaRiferimento > 0)
{
var spesaRiferimento = daoFactory.GetSpesaDao().GetById(dto.IdSpesaRiferimento.Value, false);
dettaglioMultiIva = IesiGenericCollections<DettaglioSpesa>.GetByIndex(spesaRiferimento.Dettagli, i);
}
int? id = dto.Dettagli[i].ID;
if ((dto.Dettagli[i].Stato == "U") || (dto.Dettagli[i].Stato == "I"))
{
var resultDettaglio = ManageDettaglioDomainEntity(dto.Dettagli[i], dettaglioMultiIva);
if (resultDettaglio.Dettaglio != null)
id = resultDettaglio.Dettaglio.ID;
else
return resultDettaglio.Message;
}
var dett = daoFactory.GetDettaglioSpesaDao().GetById(id.Value, false);
item.Dettagli.Add(dett);
dett.SpesaRiferimento = item;
if (i == 0 && isMultiIva && dettaglioMultiIva == null)
dettaglioMultiIva = dett;
}
// ------------------------------------------
// Scadenze
// ------------------------------------------
item.Scadenze.Clear();
foreach (var t in dto.Scadenze)
{
if (t.Importo > 0)
{
t.IdSpesa = item.ID;
t.StatoScadenza = item.Stato;
int? id = t.ID;
if ((t.Stato == "U") || (t.Stato == "I"))
id = getScadenzaRepository().ManageDomainEntity(t);
if (id != null)
t.ID = id.Value;
var scad = daoFactory.GetScadenzaFatturaDao().GetById(id.GetValueOrDefault(), false);
item.Scadenze.Add(scad);
scad.SpesaRiferimento = item;
}
}
}
catch (Exception ex)
{
_log.Error("Errore nell'inserimento del riparto delle unità: " + Utility.GetMethodDescription(), ex);
result = "Errore nell'inserimento del riparto delle unità: " + Utility.GetMethodDescription();
}
return result;
}
public List<DocumentoDTO> GetBySpesa(SpesaDTO spesa)
{
try
{
if (spesa != null)
{
var result = GetServiceClient().GetDocumentiBySpesa(spesa.ID, GetUserInfo());
CloseService();
return result;
}
}
catch (CommunicationObjectAbortedException ex)
{
_log.DebugFormat("Errore nella chiamata al servizio - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), Login.Instance.CurrentLogin().Azienda);
}
catch (CommunicationObjectFaultedException ex)
{
_log.DebugFormat("Errore nella chiamata al servizio - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), Login.Instance.CurrentLogin().Azienda);
}
catch (CommunicationException ex)
{
_log.DebugFormat("Errore nella chiamata al servizio - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), Login.Instance.CurrentLogin().Azienda);
}
catch (IOException ex)
{
_log.DebugFormat("Errore nella chiamata al servizio - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), Login.Instance.CurrentLogin().Azienda);
}
catch (ObjectDisposedException ex)
{
_log.DebugFormat("Errore nella chiamata al servizio - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), Login.Instance.CurrentLogin().Azienda);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella chiamata al servizio - {0} - spesa:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), spesa?.ID.ToString() ?? "<NULL>", Login.Instance.CurrentLogin().Azienda);
return new List<DocumentoDTO>();
}
return new List<DocumentoDTO>();
}
private SpesaDTO convertTestataToDto(TestataMovimentoContabile item)
{
try
{
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
var movimentiNumeroUno = item.Movimenti.Where(mov => mov.NumeroRiga == 1).ToList();
if(movimentiNumeroUno.Count > 1)
_log.WarnFormat("Trovato più di un movimento con numero riga 1 per una testata di movimento contabile - {0} - id:{1} - azienda:{2}", Utility.GetMethodDescription(), item.ID, _info.Azienda);
var primoMovimento = movimentiNumeroUno.FirstOrDefault();
var importo = item.GetImportoSpesa();
var dto = new SpesaDTO
{
IdEsercizio = item.EsercizioRiferimento.ID,
DescrizioneEsercizio = item.EsercizioRiferimento.DisplayName,
DescrizioneCondominio = item.EsercizioRiferimento.CondominioRiferimento.DisplayName,
IsAbilitataArchiviazioneOttica = item.IsAbilitataArchiviazioneOttica
};
if (item.SpesaRiferimento == null)
{
if (primoMovimento != null && primoMovimento.FornitoreRiferimento != null)
{
dto.IdFornitore = primoMovimento.FornitoreRiferimento.ID;
dto.DisplayFornitore = primoMovimento.FornitoreRiferimento.DisplayName;
}
}
else
{
dto.IdFornitore = item.SpesaRiferimento.FornitoreRiferimento.ID;
dto.DisplayFornitore = item.SpesaRiferimento.FornitoreRiferimento.DisplayName;
dto.NumeroDocumento = item.SpesaRiferimento.NumeroDocumento;
dto.DataDocumento = item.SpesaRiferimento.DataDocumento;
}
dto.IdTestata = item.ID;
if (importo != null)
{
dto.Imponibile = importo.Value;
dto.ImportoLordo = importo.Value;
}
dto.TipoDocumento = "Movimento";
dto.StatoSpesa = StatoSpesaEnum.Pagata;
if (item.Movimenti.Any(mov => mov.Stato == StatoMovimentoContabileEnum.Evaso))
dto.StatoSpesa = StatoSpesaEnum.Evasa;
dto.DisplayName = item.Descrizione;
dto.IdentificativoArchiviazioneOttica = getArchiviazioneOtticaService().GetIdentificativoArchiviazione(item);
dto.DataRegistrazione = item.DataRegistrazione.GetValueOrDefault();
dto.IsRipartoPersonalizzato = item.Movimenti.Any(mov => mov.IsRipartoPersonalizzato);
if (item.AddebitoCompetenze.Count > 0)
{
var firstOrDefault = item.AddebitoCompetenze.FirstOrDefault();
if (firstOrDefault != null)
dto.IdAddebitoCompetenze = firstOrDefault.ID;
}
// ------------------------------------------
// Nominativo Spesa Personale
// ------------------------------------------
var nominativoSpesaPersonale = string.Empty;
var movimentiPersonali = from mov in item.Movimenti
where mov.ContoRiferimento.IsSpesePersonali
select mov;
foreach (var mov in movimentiPersonali)
{
foreach (var spesaUnita in mov.DettaglioRipartizione)
{
if (spesaUnita.Importo.GetValueOrDefault() != 0)
{
if (!string.IsNullOrEmpty(nominativoSpesaPersonale))
{
if (!nominativoSpesaPersonale.Contains("<br/>"))
nominativoSpesaPersonale = "<b>" + nominativoSpesaPersonale + "</b><br/>";
else
nominativoSpesaPersonale += "<br/>";
}
if (spesaUnita.UnitaRiferimento != null)
{
if (mov.ContoRiferimento.PercentualeProprieta == 1)
{
var proprietario = spesaUnita.UnitaRiferimento.GetProprietarioPrincipale(item.EsercizioRiferimento.DataChiusura);
if(proprietario != null)
nominativoSpesaPersonale += proprietario.DisplayName;
}
else
{
var conduttore = spesaUnita.UnitaRiferimento.GetConduttorePrincipale(item.EsercizioRiferimento.DataChiusura);
if (conduttore != null)
nominativoSpesaPersonale += conduttore.DisplayName;
else
{
var proprietario = spesaUnita.UnitaRiferimento.GetProprietarioPrincipale(item.EsercizioRiferimento.DataChiusura);
if(proprietario != null)
nominativoSpesaPersonale += proprietario.DisplayName;
}
}
}
else
nominativoSpesaPersonale += spesaUnita.SoggettoCondominio.DisplayName;
}
}
}
dto.NominativoSpesaPersonale = nominativoSpesaPersonale;
// ------------------------------------------
// Scale Addebito
// ------------------------------------------
var scaleElaborate = new List<int>();
var movimenti = from itemScala in item.Movimenti
where !string.IsNullOrEmpty(itemScala.GruppiAddebito)
select itemScala;
dto.ScaleAddebito = getScaleAddebito(movimenti, scaleElaborate, daoFactory);
// ------------------------------------------
// Conti - Sottoconti Addebito
// ------------------------------------------
var descrizioniConti = new List<string>();
var descrizioniSottoConti = new List<string>();
var movimentiConti = from itemConto in item.Movimenti
select itemConto;
var descrizioni = getContiSottocontiDettagliAddebito(movimentiConti, descrizioniConti, descrizioniSottoConti, null, true, false, item.EsercizioRiferimento);
dto.DescrizioneBilancio = descrizioni[0];
dto.DescrizioneSottoconto = descrizioni[1];
return dto;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella creazione dell'istanza DTO per una testata di movimento contabile - {0} - id:{1}", ex, Utility.GetMethodDescription(), item.ID);
throw;
}
}
public bool Conferma()
{
var result = true;
btnConferma.Focus();
setValidators(true);
spesaValidationSummary.Validate();
if (spesaValidationSummary.IsValid)
{
// --------------------------------------------
// Controllo Data Registrazione
// --------------------------------------------
var messageDataList = getMovimentoContabileService().IsAllowDataRegistrazione(new List<int>(1) {_condominio.ID}, _esercizio.ID, dataRegistrazione.DateTime);
if(messageDataList.Count > 0)
{
var messageData = "La data di registrazione " + dataRegistrazione.DateTime + " non è ammessa:" + Environment.NewLine;
messageData = messageDataList.Aggregate(messageData, (current, mess) => current + (mess + Environment.NewLine));
CommonMessages.DisplayWarning(messageData);
return false;
}
// --------------------------------------------
// Controllo Data Scadenza se pagamento immediato
// --------------------------------------------
if (_pagamentoImmediato)
{
var messaggiDataPagamento = new List<string>();
foreach (var scadenzaFatturaDTO in _spesa.Scadenze)
{
if (scadenzaFatturaDTO != null)
{
var messageData = getMovimentoContabileService().IsAllowDataPagamento(_condominio.ID, scadenzaFatturaDTO.Scadenza.GetValueOrDefault());
if (!string.IsNullOrEmpty(messageData))
messaggiDataPagamento.Add(messageData);
}
}
if (messaggiDataPagamento.Count > 0)
{
var messageDataStr = messaggiDataPagamento.Aggregate(string.Empty, (current, mess) => current + (mess + Environment.NewLine));
CommonMessages.DisplayWarning(messageDataStr);
return false;
}
}
// --------------------------------------------
// Controllo sul numero fattura
// --------------------------------------------
var messageAuth = _fatturaService.IsAllowNumeroFattura(_spesa);
if (string.IsNullOrEmpty(messageAuth.FatalMessage))
{
var resultNumeroFattura = DialogResult.Yes;
if (!string.IsNullOrEmpty(messageAuth.WarnMessage))
resultNumeroFattura = CommonMessages.DisplayConfirm("ATTENZIONE il controllo sul numero fattura ha dato i seguenti risultati:" + Environment.NewLine + Environment.NewLine + messageAuth.WarnMessage + Environment.NewLine + Environment.NewLine + "Vuoi confermare l'inserimento della spesa?");
if (resultNumeroFattura == DialogResult.Yes)
{
RipartizioneSpeseDTO ripartizione;
if (importoDettaglioSpesa.Value != 0)
{
_spesa.AltreSpese = altreSpeseDettaglio.Value;
_spesa.AltreSpeseEsenti = altreSpeseEsenti.Value;
_spesa.SpeseEsentiRitenuta = speseEsentiRitenuta.Value;
_spesa.AliquotaRitenuta = (decimal?)aliquotaRitenuta.Value;
_spesa.AliquotaCassaProfessionisti = (decimal?)cassaProfessionistiDettaglio.Value;
_spesa.IsRitenutaCalcoloImponibile = ritenutaCalcolataImponibile.Checked;
ripartizione = getCurrentRipartizione();
if (_isInserimento && modelloRipartizione.Value == null && ripartizioneDettaglio.Rows.Count > 1 && (ripartizione == null || string.IsNullOrEmpty(getCurrentRipartizione().NomeModello)))
{
var form = new SalvataggioModelloRegistrazioneContabile((List<ModelloRegistrazioneContabileDTO>)modelliContabiliBindingSource.DataSource, modelloRipartizione.Text, descrizioneDettaglio.Text);
if (form.ShowDialog() != DialogResult.Cancel)
{
if (ripartizione == null)
{
ripartizione = new RipartizioneSpeseDTO
{
Testata = new TestataMovimentoContabileDTO {IdEsercizio = _esercizio.ID}
};
setCurrentRipartizione(ripartizione);
}
ripartizione.NomeModello = form.Nome;
ripartizione.DescrizioneVoceSpesa = form.DescrizioneVoceSpesa;
ripartizione.AssociatoFornitore = form.AssociatoFornitore;
}
form.Dispose();
}
// Se non sono ancora state caricate creo le scadenze
if (scadenze.Rows.Count == 0)
loadScadenzeTab();
}
// Salvo i valori a video nell'oggetto DTO
setDettaglioDataSource((DettaglioSpesaDTO)dettagliSpesa.ActiveTab.Tag, null);
_spesa.IdFornitore = sceltaFornitore.SelectedFornitore.ID;
_spesa.TipoDocumento = tipoDocumento.SelectedItem.DataValue.ToString();
_spesa.DataRegistrazione = dataRegistrazione.DateTime;
if (_spesaRiferimento != null)
_spesa.IdSpesaRiferimento = _spesaRiferimento.ID;
SpesaInfoDTO spesaInfo =null;
try
{
if (_spesa != null)
{
//spesaInfo = _fatturaService.Salva(_spesa, _ripartizione, getMovimentoContabileService().IsMultiSpesa);
var form = new ExecuteLoadDataObjectAsync<SpesaInfoDTO>("Salvataggio della fattura in corso ....." + Environment.NewLine + "Si prega di attendere.");
Func<SpesaInfoDTO> loadDati = () => _fatturaService.Salva(_spesa, _ripartizione, getMovimentoContabileService().IsMultiSpesa);
form.LoadData(loadDati);
form.ShowDialog();
spesaInfo = form.DataSourceObject;
form.Dispose();
}
}
catch (Exception ex)
{
_log.Error("Errore non previsto nell'inserimento della spesa - " + Utility.GetMethodDescription() + " - spesa:" + getIdSpesa().GetValueOrDefault(), ex);
spesaInfo = new SpesaInfoDTO { Message = "Errore imprevisto nell'inserimento della spesa" };
}
if (spesaInfo != null && string.IsNullOrEmpty(spesaInfo.Message))
{
_spesa.ID = spesaInfo.Id;
_spesa.DisplayName = _spesa.Dettagli[0].Descrizione;
if (_speseAccorpate && _isFirstSpesa && _spesaRiferimento == null)
{
_spesaRiferimento = _spesa;
_isFirstSpesa = false;
_fatturaService.SetSpesaRiferimento(_spesaRiferimento.ID, _spesaRiferimento.ID);
}
if (modelloFornitore.Checked)
getModelloContabileService().AssociaFornitore((ModelloRegistrazioneContabileDTO)modelloRipartizione.SelectedItem.ListObject, sceltaFornitore.SelectedFornitore);
// Se è stato richiesto il salvataggio del modello devo ricaricare la cache dei modelli
if (importoDettaglioSpesa.Value != 0)
{
ripartizione = getCurrentRipartizione();
if (!string.IsNullOrEmpty(ripartizione?.NomeModello))
getModelloContabileService().Reload(_esercizio);
}
if (_isInserimento)
CommonMessages.DisplayComplete("La spesa è stata correttamente inserita." + Environment.NewLine + "Sul documento deve essere riportato: " + spesaInfo.IdentificativoArchiviazione);
else
CommonMessages.DisplayComplete("La spesa è stata correttamente aggiornata." + Environment.NewLine + "Sul documento deve essere riportato: " + spesaInfo.IdentificativoArchiviazione);
Dirty = false;
OnConfirm(new ConfirmArgs(_spesa));
if (_formGestione == null || !_formGestione.IsDisposed)
{
if (_isInserimento)
Reload(_condominio, _esercizio);
Dirty = false;
}
}
else
{
if (spesaInfo != null)
CommonMessages.DisplayWarning("Si sono verificati dei problemi nell'aggiornamento della spesa:" + Environment.NewLine + spesaInfo.Message + Environment.NewLine + "Si prega di riprovare.");
result = false;
}
}
}
else
{
CommonMessages.DisplayWarning("Si sono verificati i seguenti errori nel controllo del numero di fattura:" + Environment.NewLine + messageAuth.FatalMessage + Environment.NewLine + "Si prega di riprovare.");
return false;
}
}
else
{
spesaValidationSummary.ShowErrorSummary();
result = false;
}
setValidators(false);
return result;
}
public SpesaDTO[] GetAllAperteByEsercizio(int idEsercizio)
{
try
{
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
var lista = daoFactory.GetSpesaDao().GetAperteByEsercizio(daoFactory.GetEsercizioDao().GetById(idEsercizio, false));
var listaDto = new SpesaDTO[lista.Count];
int index = 0;
foreach (var item in lista)
{
listaDto[index] = setDto(item, false, false, null, null);
index++;
}
return listaDto;
}
catch (Exception ex)
{
_log.Error("Errore nel caricamento delle scadenze delle fatture: " + Utility.GetMethodDescription() + " - id:" + idEsercizio.ToString(), ex);
throw;
}
}
public void ClearAll()
{
_spesaRiferimento = null;
clearAllFields();
sceltaFornitore.Reset();
clearDettaglioFields();
_isFirstSpesa = true;
}
private SpesaDTO setDto(Spesa spesa, bool includeDettagli, bool includeDettaglioMovimenti, int? anno, int? detrazione)
{
try
{
SpesaDTO dto = null;
if (spesa != null)
{
spesa.SetStato();
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
dto = new SpesaDTO
{
ID = spesa.ID,
AliquotaRitenuta = spesa.AliquotaRitenuta,
IsRitenutaCalcoloImponibile = spesa.IsRitenutaCalcoloImponibile,
AltreSpese = spesa.AltreSpese,
AltreSpeseEsenti = spesa.AltreSpeseEsenti,
SpeseEsentiRitenuta = spesa.SpeseEsentiRitenuta,
AliquotaCassaProfessionisti = spesa.AliquotaCassaProfessionisti,
CassaProfessionisti = spesa.CassaProfessionisti,
DataDocumento = spesa.DataDocumento,
DataInizioCompetenza = spesa.DataInizioCompetenza,
DataFineCompetenza = spesa.DataFineCompetenza,
IsAbilitataArchiviazioneOttica = spesa.IsAbilitataArchiviazioneOttica,
IsPrestazioneQualita = spesa.IsPrestazioneQualita,
Detrazione = spesa.Detrazione,
Contestata = spesa.Contestata,
EsclusaRendiconto = spesa.EsclusaRendiconto,
IdEsercizio = spesa.EsercizioRiferimento.ID,
DescrizioneEsercizio = spesa.EsercizioRiferimento.DisplayName,
DescrizioneCondominio = spesa.EsercizioRiferimento.CondominioRiferimento.DisplayName,
Sinistro = spesa.Sinistro > 0,
Autorizzata = spesa.Autorizzata,
EsenteRegimeMinimo = spesa.EsenteRegimeMinimo
};
if (spesa.Imponibile != 0)
dto.Imponibile = spesa.Imponibile;
dto.ImportoIva = spesa.ImportoIva;
dto.ImportoLordo = spesa.ImportoBolletta ?? spesa.ImportoLordo + spesa.AltreSpeseEsenti.GetValueOrDefault();
dto.ImportoRitenuta = spesa.ImportoRitenuta;
//if (spesa.TipoDocumento == "NOTACC")
//{
// dto.ImportoLordo = dto.ImportoLordo*-1;
// dto.ImportoRitenuta = dto.ImportoRitenuta*-1;
//}
if (spesa.FornitoreRiferimento != null)
{
dto.IdFornitore = spesa.FornitoreRiferimento.ID;
dto.DisplayFornitore = spesa.FornitoreRiferimento.DisplayName;
}
dto.ImportoNettoAPagare = dto.ImportoLordo.GetValueOrDefault() - dto.ImportoRitenuta.GetValueOrDefault();
dto.Note = spesa.Note;
dto.NumeroDocumento = spesa.NumeroDocumento;
if (!string.IsNullOrEmpty(spesa.NumeroDocumento) && spesa.DataDocumento != null && spesa.NumeroProtocollo != null)
dto.IdentificativoArchiviazioneOttica = getArchiviazioneOtticaService().GetIdentificativoArchiviazione(spesa);
dto.TipoDocumento = Decodifica.Instance.GetElement("TipoDocumentoContabile", spesa.TipoDocumento).Descrizione;
dto.IsMultiIva = spesa.IsMultiIva;
dto.StatoSpesa = spesa.Stato;
if (spesa.SpesaRiferimento != null)
{
dto.IdSpesaRiferimento = spesa.SpesaRiferimento.ID;
dto.DescrizioneSpesaRiferimento = spesa.SpesaRiferimento.ID.ToString();
if (!string.IsNullOrEmpty(spesa.SpesaRiferimento.NumeroDocumento))
dto.DescrizioneSpesaRiferimento += " - N. " + spesa.SpesaRiferimento.NumeroDocumento;
if (spesa.SpesaRiferimento.DataDocumento != null)
dto.DescrizioneSpesaRiferimento += " del " + spesa.SpesaRiferimento.DataDocumento.GetValueOrDefault().ToShortDateString();
foreach (var dettaglio in spesa.SpesaRiferimento.Dettagli)
{
dto.DescrizioneSpesaRiferimento += " - " + dettaglio.GetDescrizione();
break;
}
}
if (spesa.Utenza != null)
{
var rep = new UtenzaRepository(_info, _windsorRepository);
dto.Utenza = rep.GetDisplayName(spesa.Utenza);
}
dto.Version = spesa.Version;
DettaglioSpesa dettaglioPrincipale = null;
if (spesa.Dettagli.Count > 0)
dettaglioPrincipale = spesa.Dettagli.FirstOrDefault();
if (spesa.TipoDocumento == "BOLLETTA")
{
if (spesa.TestateMovimenti.Count > 0)
{
var testata = spesa.TestateMovimenti.FirstOrDefault();
if (testata != null)
{
dto.DisplayName = testata.GetDescrizione();
dto.IdTestata = testata.ID;
}
}
}
else
{
if (dettaglioPrincipale != null)
dto.DisplayName = dettaglioPrincipale.GetDescrizione();
}
// ------------------------------------------
// Nominativo Spesa Personale
// ------------------------------------------
// Solo per la lista (includeDettagli == false)
if (!includeDettagli)
{
var nominativoSpesaPersonale = string.Empty;
var movimentiPersonali = spesa.Dettagli.Where(item => item.Movimenti.Any(mov => mov.ContoRiferimento.IsSpesePersonali)).Select(item => item.Movimenti.ToList());
var personeElaborate = new List<string>();
foreach (var lista in movimentiPersonali)
{
foreach (var item in lista)
{
foreach (var spesaUnita in item.DettaglioRipartizione)
{
if (spesaUnita.Importo.GetValueOrDefault() != 0)
{
if (!string.IsNullOrEmpty(nominativoSpesaPersonale))
{
if (!nominativoSpesaPersonale.Contains("<br/>"))
nominativoSpesaPersonale = "<b>" + nominativoSpesaPersonale.Replace('&', 'e') + "</b><br/>";
else if (!nominativoSpesaPersonale.EndsWith("<br/>"))
nominativoSpesaPersonale += "<br/>";
}
// -------------------------------------------------
// Dettaglio riferito ad una unità immobiliare
// -------------------------------------------------
if (spesaUnita.UnitaRiferimento != null)
{
if (item.ContoRiferimento.PercentualeProprieta == 1)
{
var nominativo = spesaUnita.UnitaRiferimento.GetProprietarioPrincipale(spesa.EsercizioRiferimento.DataChiusura).DisplayName;
if (!personeElaborate.Contains(nominativo))
{
nominativoSpesaPersonale += nominativo;
personeElaborate.Add(nominativo);
}
}
else
{
var conduttore = spesaUnita.UnitaRiferimento.GetConduttorePrincipale(spesa.EsercizioRiferimento.DataChiusura);
var nominativo = conduttore != null ? conduttore.DisplayName : spesaUnita.UnitaRiferimento.GetProprietarioPrincipale(spesa.EsercizioRiferimento.DataChiusura).DisplayName;
if (!string.IsNullOrEmpty(nominativo) && !personeElaborate.Contains(nominativo))
{
nominativoSpesaPersonale += nominativo;
personeElaborate.Add(nominativo);
}
}
}
// -------------------------------------------------
// Dettaglio riferito direttamente ad un condomino
// -------------------------------------------------
if (spesaUnita.SoggettoCondominio != null)
{
var nominativo = spesaUnita.SoggettoCondominio.DisplayName;
if (!personeElaborate.Contains(nominativo))
{
nominativoSpesaPersonale += nominativo;
personeElaborate.Add(nominativo);
}
}
}
}
}
}
dto.NominativoSpesaPersonale = nominativoSpesaPersonale;
// ------------------------------------------
// Scale Addebito
// ------------------------------------------
var scaleElaborate = new List<int>();
if (spesa.TipoDocumento != "BOLLETTA")
{
var scaleAddebito = string.Empty;
var movimenti = (from item in spesa.Dettagli
where item.Movimenti.Any(mov => !string.IsNullOrEmpty(mov.GruppiAddebito))
select item.Movimenti.ToList()).ToList();
scaleAddebito = movimenti.Cast<IList<MovimentoContabile>>().Aggregate(scaleAddebito, (current, lista) => current + getScaleAddebito(lista, scaleElaborate, daoFactory));
dto.ScaleAddebito = scaleAddebito;
}
else
{
var movimenti = from item in spesa.MovimentiBollette
where !string.IsNullOrEmpty(item.GruppiAddebito)
select item;
dto.ScaleAddebito = getScaleAddebito(movimenti, scaleElaborate, daoFactory);
}
// ------------------------------------------
// Conti - Sottoconti - Dettaglio Addebito
// ------------------------------------------
var descrizioniConti = new List<string>();
var descrizioniSottoConti = new List<string>();
var dettagli = new List<string>();
if (spesa.TipoDocumento != "BOLLETTA")
{
var contiAddebito = string.Empty;
var sottoContiAddebito = string.Empty;
var dettagliAddebito = string.Empty;
var movimenti = (spesa.Dettagli.Select(item => item.Movimenti.ToList())).ToList();
foreach (IList<MovimentoContabile> lista in movimenti)
{
var descrizioni = getContiSottocontiDettagliAddebito(lista, descrizioniConti, descrizioniSottoConti, dettagli, false, detrazione != null, spesa.EsercizioRiferimento);
contiAddebito += descrizioni[0];
sottoContiAddebito += descrizioni[1];
dettagliAddebito += descrizioni[2];
}
dto.DescrizioneBilancio = contiAddebito;
dto.DescrizioneSottoconto = sottoContiAddebito;
dto.Dettaglio = dettagliAddebito;
}
else
{
var movimenti = spesa.MovimentiBollette.Select(item => item);
var descrizioni = getContiSottocontiDettagliAddebito(movimenti, descrizioniConti, descrizioniSottoConti, dettagli, false, detrazione != null, spesa.EsercizioRiferimento);
dto.DescrizioneBilancio = descrizioni[0];
dto.DescrizioneSottoconto = descrizioni[1];
dto.Dettaglio = descrizioni[2];
}
// ------------------------------------------
// Riparto personalizzato
// ------------------------------------------
dto.IsRipartoPersonalizzato = spesa.TipoDocumento == "BOLLETTA" ? spesa.IsRipartoPersonalizzato : spesa.Dettagli.Any(item => item.Movimenti.Any(item2 => item2.IsRipartoPersonalizzato));
}
// ------------------------------------------
// Dettagli
// ------------------------------------------
if (includeDettagli || includeDettaglioMovimenti)
{
var indexDettaglio = 0;
dto.Dettagli = new DettaglioSpesaDTO[spesa.Dettagli.Count];
foreach (var dettaglio in spesa.Dettagli)
{
var dettDto = setDettaglioDto(dettaglio, includeDettaglioMovimenti, detrazione != null);
dto.Dettagli[indexDettaglio] = dettDto;
indexDettaglio++;
}
// ------------------------------------------
// Scadenze
// ------------------------------------------
if (includeDettagli)
{
var indexScadenze = 0;
dto.Scadenze = new ScadenzaFatturaDTO[spesa.Scadenze.Count];
foreach (var scadenza in spesa.Scadenze)
{
var scadDto = getScadenzaRepository().GetByDomainEntity(scadenza);
dto.Scadenze[indexScadenze] = scadDto;
indexScadenze++;
}
var statoSpesa = spesa.Stato;
if (spesa.Scadenze.Any(item => item.Stato == StatoSpesaEnum.Stornata))
statoSpesa = StatoSpesaEnum.Stornata;
dto.StatoSpesa = statoSpesa;
}
}
// ------------------------------------------
// Testata Contabile
// ------------------------------------------
if (dettaglioPrincipale != null && dettaglioPrincipale.Movimenti.Count > 0)
{
var movimentoEconomico = IesiGenericCollections<MovimentoContabile>.GetByIndex(dettaglioPrincipale.Movimenti, 0);
if (movimentoEconomico != null)
{
if (movimentoEconomico.Testata != null)
dto.IdTestata = movimentoEconomico.Testata.ID;
else
{
_log.ErrorFormat("Trovato movimento economico senza testata - {0} - movimento:{1} - spesa:{2}", Utility.GetMethodDescription(), movimentoEconomico.ID, spesa.ID);
}
}
else
{
_log.WarnFormat("Trovato dettagli spesa senza movimenti associati - {0} - id:{1}", Utility.GetMethodDescription(), spesa.ID);
}
}
// ------------------------------------------
// Data Registrazione
// ------------------------------------------
if (spesa.Dettagli.Count > 0 && IesiGenericCollections<DettaglioSpesa>.GetByIndex(spesa.Dettagli, 0).Movimenti.Count > 0)
{
var dettaglio = IesiGenericCollections<DettaglioSpesa>.GetByIndex(spesa.Dettagli, 0);
var movimento = IesiGenericCollections<MovimentoContabile>.GetByIndex(dettaglio.Movimenti, 0);
if (movimento.Testata != null)
dto.DataRegistrazione = movimento.Testata.DataRegistrazione.GetValueOrDefault();
}
else if (spesa.TestateMovimenti != null)
{
var testata = spesa.TestateMovimenti.FirstOrDefault();
if(testata != null)
dto.DataRegistrazione = testata.DataRegistrazione.GetValueOrDefault();
}
// ------------------------------------------
// Importo Pagato (PER REPORT DETRAZIONI)
// ------------------------------------------
if (anno != null && detrazione != null)
{
if (spesa.Pagamenti.Any())
dto.ImportoPagato = spesa.GetImportoPagato(anno.GetValueOrDefault(), detrazione.GetValueOrDefault());
// Se non sono presenti pagamenti ma solo riscossioni (nota accredito) deve essere considerato l'intero importo bugid#6618
else if (spesa.Riscossioni.Count > 0)
{
dto.ImportoPagato = spesa.ImportoLordo;
}
}
}
return dto;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella creazione dell'istanza DTO per una spesa - {0} - id:{1}", ex, Utility.GetMethodDescription(), spesa.ID);
throw;
}
}
public string Delete(SpesaDTO spesa)
{
var result = GetServiceClient().DeleteSpesa(spesa.ID, GetUserInfo());
CloseService();
return result;
}
