/// <summary>
/// Crea una Scadenza valida
/// </summary>
public ScadenzaFattura(Spesa spesa, DateTime? scadenza, decimal? importo)
{
_spesaRiferimento = spesa;
_scadenza = scadenza;
_importo = importo;
Stato = StatoSpesaEnum.Inserita;
if (spesa != null && spesa.ImportoRitenuta != 0 && spesa.ImportoLordo != 0)
{
var denominatore = spesa.ImportoLordo - spesa.ImportoRitenuta.GetValueOrDefault();
if(denominatore != 0)
ImportoRitenuta = (importo / denominatore) * spesa.ImportoRitenuta;
else
ImportoRitenuta = spesa.ImportoRitenuta;
}
if (spesa != null)
{
var autorizzata = spesa.Autorizzata;
if (autorizzata)
{
Stato = StatoSpesaEnum.Autorizzata;
_importoAutorizzato = _importo;
}
spesa.Scadenze.Add(this);
}
}
/// <summary>
/// Crea un Pagamento valido
/// </summary>
public Riscossione(Spesa spesa, decimal importo)
{
SpesaRiferimento = spesa;
Importo = importo;
if (SpesaRiferimento != null)
SpesaRiferimento.Riscossioni.Add(this);
}
/// <summary>
/// Crea un dettaglio di Spedizione per Archiviazione Ottica valido
/// </summary>
public SpedizioneArchiviazioneOtticaDettaglio(SpedizioneArchiviazioneOttica testata, Spesa spesaRiferimento)
{
Testata = testata;
SpesaRiferimento = spesaRiferimento;
if (Testata != null)
Testata.Dettaglio.Add(this);
}
/// <summary>
/// Crea un movimento contabile valido.
/// E' relativo al conto economico connesso alla registrazione di una spesa
/// </summary>
public RipartizioneSpesa(Spesa spesa, Conto conto, SottoConto sottoConto, decimal? importo, string segno, string descrizione)
{
Spesa = spesa;
ContoRiferimento = conto;
SottoContoRiferimento = sottoConto;
Importo = importo;
Segno = segno;
Descrizione = descrizione;
}
/// <summary>
/// Crea una Dettaglio di spesa valido
/// </summary>
public DettaglioSpesa(Spesa spesa, int? numeroRiga)
{
_spesaRiferimento = spesa;
_numeroRiga = numeroRiga;
if (spesa != null)
{
spesa.Dettagli.Add(this);
if (spesa.FornitoreRiferimento != null)
SoggettoRitenutaAcconto = spesa.FornitoreRiferimento.AliquotaRitenutaAcconto > 0;
}
}
public static decimal? GetImportoRitenuta(Spesa spesa, decimal? importo)
{
try
{
decimal? importoReturn = null;
if (importo != null && spesa.ImportoRitenuta != null)
{
//// TODO: Aggiungere if per fattura da bilancio di apertura, deve tornare direttamente l'importo della ritenuta inserito in bilancio
//if (spesa.TipoDocumento == "FATBILAPP")
// importoReturn = spesa.ImportoRitenuta;
//else
if (spesa.TipoDocumento != "NOTACC")
{
if (spesa.ImportoLordo - spesa.ImportoRitenuta.Value + spesa.AltreSpeseEsenti.GetValueOrDefault() != 0)
importoReturn = (importo / (spesa.ImportoLordo - spesa.ImportoRitenuta.Value + spesa.AltreSpeseEsenti.GetValueOrDefault())) * spesa.ImportoRitenuta.Value;
else
importoReturn = spesa.ImportoRitenuta.GetValueOrDefault();
}
else
{
if (spesa.ImportoLordo != 0)
importoReturn = ((importo - spesa.AltreSpeseEsenti.GetValueOrDefault()) / spesa.ImportoLordo) * spesa.ImportoRitenuta.Value;
else
importoReturn = spesa.ImportoRitenuta.GetValueOrDefault();
}
}
return importoReturn;
}
catch (Exception ex)
{
var log = LogManager.GetLogger("Sfera");
log.ErrorFormat("Errore inaspettato nel calcolo dell'importo della ritenuta - {0} - spesa:{1}", ex, Library.Utility.GetMethodDescription(), spesa?.ID.ToString() ?? "<NULL>");
throw;
}
}
public IList<MovimentoContabile> SetMovimentoBolletta(BollettaDTO bolletta, Spesa spesa, TestataMovimentoContabile testata, LogTransazione logTransazione, bool controlloDataRegistrazione)
{
try
{
IList<MovimentoContabile> movimentiEconomici = new List<MovimentoContabile>();
CausaleContabile causale;
if (spesa.Utenza != null && spesa.Utenza.RipartoLetture)
causale = _daoFactory.GetCausaleContabileDao().GetByCodice("IA");
else
causale = _daoFactory.GetCausaleContabileDao().GetByCodice("IF");
if (testata == null && spesa.TestateMovimenti.Count > 0)
{
testata = spesa.TestateMovimenti.FirstOrDefault();
if (testata != null)
{
testata.EsercizioRiferimento = spesa.EsercizioRiferimento;
testata.DataRegistrazione = bolletta.DataRegistrazione;
}
}
var dataRegistrazione = DateTime.Today;
if (bolletta.DataRegistrazione != null)
dataRegistrazione = bolletta.DataRegistrazione.GetValueOrDefault();
if (testata == null)
{
testata = new TestataMovimentoContabile(spesa.EsercizioRiferimento, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null) { SpesaRiferimento = spesa };
spesa.TestateMovimenti.Add(testata);
testata.IsAllowUpdate = false;
if(logTransazione == null)
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
else
testata.LogTransazione = logTransazione;
}
// controllo data registrazione
IList<string> message = new List<string>();
if(controlloDataRegistrazione)
message = IsAllowDataRegistrazione(new List<int> { spesa.EsercizioRiferimento.CondominioRiferimento.ID }, spesa.EsercizioRiferimento, testata.DataRegistrazione.GetValueOrDefault());
if (message.Count > 0)
{
var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", testata.DataRegistrazione.GetValueOrDefault()));
_log.ErrorFormat("Data di registrazione non valida - {0} - data:{1} - spesa:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), testata.DataRegistrazione.GetValueOrDefault(), spesa.ID, spesa.EsercizioRiferimento.ID);
throw ex;
}
testata.Descrizione = bolletta.Descrizione;
testata.DataRegistrazione = dataRegistrazione;
// -------------------------------------------
// Elimino movimenti cancellati
// -------------------------------------------
foreach (var mov in testata.Movimenti.Where(item => item.NumeroRiga > 1).ToList())
DeleteSingoloMovimento(mov);
// -------------------------------------------
// Movimenti Economici
// -------------------------------------------
var numeroRiga = 1;
var importoEconomico = 0m;
foreach (var movimentoDto in bolletta.Movimenti)
{
if (movimentoDto.IdConto != null)
{
var importo = Math.Round(movimentoDto.Importo.GetValueOrDefault(), 2);
importoEconomico += importo;
var segno = "D";
if (importo < 0)
{
segno = "A";
importo = importo * -1;
}
var movimento = _daoFactory.GetMovimentoContabileDao().Find(movimentoDto.ID, false);
numeroRiga++;
if (movimento != null)
{
movimento.ContoRiferimento = _daoFactory.GetContoDao().GetById(movimentoDto.IdConto.Value, false);
movimento.Segno = segno;
movimento.Importo = importo;
movimento.Causale = causale;
}
else
{
movimento = new MovimentoContabile(testata, spesa, causale, testata.Movimenti.Count + 1, _daoFactory.GetContoDao().GetById(movimentoDto.IdConto.Value, false), importo, segno);
if(logTransazione == null)
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimento);
}
movimento.IsMovimentoEconomico = true;
movimento.NumeroRiga = numeroRiga;
movimento.Descrizione = movimentoDto.Descrizione;
if (movimentoDto.IdSottoConto != null && movimentoDto.IdSottoConto > 0)
movimento.SottoContoRiferimento = _daoFactory.GetSottoContoDao().GetById(movimentoDto.IdSottoConto.Value, false);
movimentoDto.ID = movimento.ID;
movimentiEconomici.Add(movimento);
}
else
{
_log.ErrorFormat("Movimento senza conto associato - {0} - bolletta:{1}", Utility.GetMethodDescription(), bolletta.ID);
throw (new Exception("Movimento senza conto associato - " + Utility.GetMethodDescription() + " - idBolletta:" + bolletta.ID));
}
}
// ------------------------------------------------
// Debiti VS Fornitori
// ------------------------------------------------
var causalePatrimoniale = _daoFactory.GetCausaleContabileDao().GetByCodice("IF");
var importoTotale = spesa.ImportoBolletta.GetValueOrDefault();
var importoPatrimoniale = importoTotale;
var segnoPatrimoniale = "A";
if (importoTotale < 0)
{
segnoPatrimoniale = "D";
importoTotale = importoTotale * -1;
}
var movimentoPatrimoniale = (testata.Movimenti.Where(item => !item.IsMovimentoEconomico && !item.ContoRiferimento.IsArrotondamento)).FirstOrDefault();
if (movimentoPatrimoniale == null)
{
movimentoPatrimoniale = new MovimentoContabile(testata, spesa.FornitoreRiferimento, causalePatrimoniale, 1, _daoFactory.GetContoDao().GetByCodice(spesa.EsercizioRiferimento.ID, spesa.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoFornitori()), importoTotale, segnoPatrimoniale);
if(logTransazione == null)
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);
}
else
{
movimentoPatrimoniale.NumeroRiga = 1;
movimentoPatrimoniale.Importo = importoTotale;
movimentoPatrimoniale.Segno = segnoPatrimoniale;
}
movimentoPatrimoniale.Descrizione = $"Fatt. n. {spesa.NumeroDocumento} del {spesa.DataDocumento.GetValueOrDefault():d}";
// ------------------------------------------------
// Eventuale arrotondamento
// ------------------------------------------------
setMovimentoArrotondamento(importoPatrimoniale, importoEconomico, numeroRiga, spesa, testata, causale, logTransazione);
return movimentiEconomici;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella creazione del movimento di registrazione delle bollette - {0} - bolletta:{1}", ex, Utility.GetMethodDescription(), bolletta.ID);
throw;
}
}
public void SetMovimentiRitenutaPagataAltroAmministratore(Spesa spesa, DateTime dataRegistrazione)
{
try
{
if (spesa.EsercizioRiferimento == null)
{
_log.ErrorFormat("Errore inaspettato nella creazione del movimento di ritenuta pagata da altro amministratore - TESTATA - {0} - spesa:{1}", Utility.GetMethodDescription(), spesa.ID);
throw (new Exception("Non è definito l'esercizio di competenza per la spesa"));
}
var numeroRiga = 0;
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("VR");
// ------------------------------------------------
// Testata
// ------------------------------------------------
TestataMovimentoContabile testata;
try
{
testata = new TestataMovimentoContabile(spesa.EsercizioRiferimento, DateTime.Today, TipoTestataMovimentoContabileEnum.Automatica, null)
{
DataRegistrazione = dataRegistrazione,
SpesaRiferimento = spesa
};
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
}
catch (Exception ex)
{
var countScadenze = string.Empty;
if (spesa.Scadenze != null)
countScadenze = spesa.Scadenze.Count.ToString();
_log.ErrorFormat("Errore inaspettato nella creazione del movimento di ritenuta pagata da altro amministratore - TESTATA - {0} - spesa:{1} - scadenze:{2}", ex, Utility.GetMethodDescription(), spesa.ID, countScadenze);
throw;
}
// ------------------------------------------------
// Ritenuta
// ------------------------------------------------
numeroRiga++;
MovimentoContabile movimentoPatrimoniale;
var segnoRitenuta = "A";
try
{
var importoRitenuta = spesa.ImportoRitenuta.GetValueOrDefault();
if (spesa.ImportoRitenuta < 0)
{
segnoRitenuta = "D";
importoRitenuta = importoRitenuta*-1;
}
var contoRitenuta = _daoFactory.GetContoDao().GetByCodice(spesa.EsercizioRiferimento.ID, spesa.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoRitenuta());
if (contoRitenuta != null)
{
try
{
movimentoPatrimoniale = new MovimentoContabile(testata, causale, numeroRiga, contoRitenuta, importoRitenuta, segnoRitenuta)
{
FornitoreRiferimento = spesa.FornitoreRiferimento,
Descrizione = "Ritenuta Fatt. n." + spesa.NumeroDocumento + " del " + spesa.DataDocumento.GetValueOrDefault().ToShortDateString()
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella creazione del movimento di ritenuta pagata da altro amministratore - RITENUTA INT - {0} - spesa:{1}", ex, Utility.GetMethodDescription(), spesa.ID);
throw;
}
}
else
{
_log.FatalFormat("Errore inaspettato nella creazione del movimento di ritenuta pagata da altro amministratore - RITENUTA - {0} - spesa:{1}", Utility.GetMethodDescription(), spesa.ID);
throw (new InvalidDataException("Non trovato il conto per la registrazione delle Ritenute di Acconto"));
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella creazione del movimento di ritenuta pagata da altro amministratore - RITENUTA EXT - {0} - spesa:{1}", ex, Utility.GetMethodDescription(), spesa.ID);
throw;
}
// ------------------------------------------------
// Conto Patrimoniale
// ------------------------------------------------
numeroRiga++;
var segno = "D";
if (segnoRitenuta == "D")
segno = "A";
var contoPatrimonialeAltreSpese = _daoFactory.GetContoDao().GetByCodice(spesa.EsercizioRiferimento.ID, spesa.EsercizioRiferimento.CondominioRiferimento.ID, "909");
if (contoPatrimonialeAltreSpese != null)
{
try
{
var movimentoSpeseNonCompetenza = new MovimentoContabile(testata, causale, numeroRiga, contoPatrimonialeAltreSpese, movimentoPatrimoniale.Importo, segno)
{
FornitoreRiferimento = movimentoPatrimoniale.FornitoreRiferimento,
Descrizione = movimentoPatrimoniale.Descrizione
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoSpeseNonCompetenza);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella creazione del movimento di ritenuta pagata da altro amministratore - PATRIMONIALE - {0} - spesa:{1}", ex, Utility.GetMethodDescription(), spesa.ID);
throw;
}
}
else
{
_log.ErrorFormat("Errore inaspettato nella creazione del movimento di ritenuta pagata da altro amministratore - PATRIMONIALE - {0} - spesa:{1}", Utility.GetMethodDescription(), spesa.ID);
throw (new InvalidDataException("Non trovato il conto (909) patrimoniale per la registrazione delle Ritenute di Acconto"));
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella creazione del movimento di ritenuta pagata da altro amministratore - {0} - spesa:{1}", ex, Utility.GetMethodDescription(), spesa.ID);
throw;
}
}
public void SetMovimentiInteressiSanzioni(Spesa spesa)
{
try
{
foreach (var pag in spesa.Pagamenti)
{
try
{
var movimentiDaEliminare = _daoFactory.GetMovimentoContabileDao().GetInteressiSanzioniByPagamento(pag.ID);
if (movimentiDaEliminare.Count > 0)
{
var testata = movimentiDaEliminare[0].Testata;
var causale = movimentiDaEliminare[0].Causale;
var numeroRiga = testata.Movimenti.Max(item => item.NumeroRiga.GetValueOrDefault()) + 1;
// ------------------------------------------------
// Interessi per Ravvedimento Operoso
// ------------------------------------------------
try
{
if (pag.RitenutaAcconto.ImportoInteressi > 0)
{
var descrizioneAddebitoInteressi = string.Empty;
var movimentoInteresseOld = movimentiDaEliminare.FirstOrDefault(item => item.TipoInteresseSanzione == TipoInteresseSanzioneEnum.Interesse);
if (movimentoInteresseOld != null)
descrizioneAddebitoInteressi = movimentoInteresseOld.Descrizione;
foreach (var dettaglio in spesa.Dettagli)
{
foreach (var movimento in dettaglio.Movimenti)
{
var importoMovimento = movimento.GetImportoConSegno().GetValueOrDefault();
if (movimento.ContoRiferimento.Tipo == TipoContoEconomicoEnum.Patrimoniale)
importoMovimento = importoMovimento * -1;
var interesseCompetenza = (pag.RitenutaAcconto.ImportoInteressi.GetValueOrDefault() * importoMovimento) / spesa.ImportoLordo;
var movimentoInteresse = new MovimentoContabile(testata, causale, numeroRiga, movimento.ContoRiferimento, interesseCompetenza, "D")
{
SottoContoRiferimento = movimento.SottoContoRiferimento,
FornitoreRiferimento = movimento.FornitoreRiferimento,
Descrizione = descrizioneAddebitoInteressi.Replace("<DescrizioneSpesa>", movimento.GetDescrizione()),
TipoInteresseSanzione = TipoInteresseSanzioneEnum.Interesse,
PagamentoInteresseSanzione = pag
};
// "Interessi ravv. operoso - " + movimento.GetDescrizione();
_ripartizioneService.CloneRipartizioneByMovimento(movimentoInteresse, movimento);
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoInteresse);
}
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la scrittura dei movimenti per interessi e sanzioni (SINGOLO PAGAMENTO - INTERESSI) - {0} - pagamento:{1} - spesa:{2}", ex, Utility.GetMethodDescription(), pag.ID, spesa.ID);
throw;
}
// ------------------------------------------------
// Sanzione per Ravvedimento Operoso
// ------------------------------------------------
try
{
if (pag.RitenutaAcconto.ImportoSanzione > 0)
{
var movimentoSanzioneOld = movimentiDaEliminare.FirstOrDefault(item => item.TipoInteresseSanzione == TipoInteresseSanzioneEnum.Sanzione);
if (movimentoSanzioneOld != null)
{
var descrizioneAddebitoSanzioni = movimentoSanzioneOld.Descrizione;
foreach (var dettaglio in spesa.Dettagli)
{
foreach (var movimento in dettaglio.Movimenti)
{
var importoMovimento = movimento.GetImportoConSegno().GetValueOrDefault();
if (movimento.ContoRiferimento.Tipo == TipoContoEconomicoEnum.Patrimoniale)
importoMovimento = importoMovimento * -1;
var sanzioneCompetenza = (pag.RitenutaAcconto.ImportoSanzione.GetValueOrDefault() * importoMovimento) / spesa.ImportoLordo;
var movimentoSanzione = new MovimentoContabile(testata, causale, numeroRiga, movimento.ContoRiferimento, sanzioneCompetenza, "D")
{
SottoContoRiferimento = movimento.SottoContoRiferimento,
FornitoreRiferimento = movimento.FornitoreRiferimento,
Descrizione = descrizioneAddebitoSanzioni.Replace("<DescrizioneSpesa>", movimento.GetDescrizione()),
TipoInteresseSanzione = TipoInteresseSanzioneEnum.Sanzione,
PagamentoInteresseSanzione = pag
};
//"Sanzione ravv. operoso - " + movimento.GetDescrizione();
_ripartizioneService.CloneRipartizioneByMovimento(movimentoSanzione, movimento);
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoSanzione);
}
}
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la scrittura dei movimenti per interessi e sanzioni (SINGOLO PAGAMENTO - SANZIONE) - {0} - pagamento:{1} - spesa:{2}", ex, Utility.GetMethodDescription(), pag.ID, spesa.ID);
throw;
}
// ------------------------------------------------
// Cancello i vecchi movimenti
// ------------------------------------------------
try
{
foreach (var mov in movimentiDaEliminare)
{
try
{
DeleteSingoloMovimento(mov);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la scrittura dei movimenti per interessi e sanzioni (SINGOLO PAGAMENTO - CANCELLAZIONE VECCHI MOVIMENTI - SINGOLO MOVIMENTO) - {0} - pagamento:{1} - spesa:{2} - movimento:{3}", ex, Utility.GetMethodDescription(), pag.ID, spesa.ID, mov.ID);
throw;
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la scrittura dei movimenti per interessi e sanzioni (SINGOLO PAGAMENTO - CANCELLAZIONE VECCHI MOVIMENTI) - {0} - pagamento:{1} - spesa:{2}", ex, Utility.GetMethodDescription(), pag.ID, spesa.ID);
throw;
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la scrittura dei movimenti per interessi e sanzioni (SINGOLO PAGAMENTO) - {0} - pagamento:{1} - spesa:{2}", ex, Utility.GetMethodDescription(), pag.ID, spesa.ID);
throw;
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la scrittura dei movimenti per interessi e sanzioni - {0} - spesa:{1}", ex, Utility.GetMethodDescription(), spesa.ID);
throw;
}
}
public string CreatePagamentiImmediati(Spesa spesa, IList<ScadenzaFatturaDTO> scadenze, LogTransazione logTransazione)
{
try
{
var anomalie = string.Empty;
var scadenzePagate = (scadenze.Where(scad => scad.IdContoPagamentoScadenza != null && !string.IsNullOrEmpty(scad.Stato))).ToList();
// ============================================================
// Controllo Pagamenti
// ============================================================
anomalie = (from dto in scadenzePagate let scadenza = _daoFactory.GetScadenzaFatturaDao().Find(dto.ID, false) where scadenza != null where dto.Importo > scadenza.Importo.GetValueOrDefault() - scadenza.ImportoPagato select scadenza).Aggregate(anomalie, (current, scadenza) => current + ("Per la spesa: " + _archiviazioneOtticaService.GetIdentificativoArchiviazione(scadenza.SpesaRiferimento) + " l'importo del pagamento è superiore al residuo da pagare"));
// ============================================================
// Esecuzione Pagamenti
// ============================================================
if (string.IsNullOrEmpty(anomalie) && scadenzePagate.Any())
{
AnnullamentoPagamentiSpesa(spesa.ID);
var descrizione = "Pagamento Immediato";
if (spesa.NumeroDocumento != null)
descrizione += $" Fatt. n. {spesa.NumeroDocumento}";
if (spesa.DataDocumento != null)
descrizione += $" del {spesa.DataDocumento.Value:d}";
// Per avere un cascade corretto dell'oggetto ScadenzaFattura la disposizione di pagamento viene collegata allo stesso
// logtransazione del file d'importazione diverso dal log di transazione della spesa
var logTransazioneDisposizione = logTransazione;
if (spesa.FileImportazione != null && spesa.FileImportazione.LogTransazione != null)
logTransazioneDisposizione = spesa.FileImportazione.LogTransazione;
var disposizione = new Disposizione(descrizione, DateTime.Now, spesa.EsercizioRiferimento.CondominioRiferimento.Azienda, logTransazioneDisposizione);
if (logTransazione == null)
_daoFactory.GetDisposizioneDao().SaveOrUpdate(disposizione);
var lista = new List<DisposizionePagamentoDTO>(spesa.Scadenze.Count);
var index = 0;
foreach (var scadenzaDto in scadenzePagate)
{
try
{
var scadenza = _daoFactory.GetScadenzaFatturaDao().Find(scadenzaDto.ID, false);
// Per le scadenze create dall'importazione bollette l'ID della scadenza è valorizzato solo alla fine
if (scadenza == null)
{
if (spesa.FileImportazione != null && scadenzePagate.Count == spesa.Scadenze.Count)
scadenza = spesa.Scadenze.ToList()[index];
}
if (scadenza != null && scadenza.SpesaRiferimento != null && scadenza.SpesaRiferimento.EsercizioRiferimento != null && scadenza.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento != null)
{
var dto = new DisposizionePagamentoDTO
{
DataDocumento = spesa.DataDocumento,
DataScadenza = scadenza.Scadenza,
Detrazione = spesa.Detrazione,
IdScadenza = scadenza.ID,
ImportoAutorizzato = scadenza.Importo,
ImportoPagamento = scadenza.Importo.GetValueOrDefault(),
ImportoPagato = 0,
ImportoRitenuta = scadenza.ImportoRitenuta,
ImportoScadenza = scadenza.Importo,
IdSpesa = scadenza.SpesaRiferimento.ID,
NumeroDocumento = spesa.NumeroDocumento,
Selezionabile = true,
Valuta = scadenza.Scadenza,
IdConto = scadenzaDto.IdContoPagamentoScadenza,
IdSottoConto = scadenzaDto.IdSottoContoPagamentoScadenza,
DataPagamentoRitenuta = scadenzaDto.DataPagamentoRitenuta,
IdEsercizio = scadenza.SpesaRiferimento.EsercizioRiferimento.ID,
IdCondominio = scadenza.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID,
ImponibileSpesa = scadenza.SpesaRiferimento.Imponibile,
IdentificativoArchiviazioneOttica = _archiviazioneOtticaService.GetIdentificativoArchiviazione(scadenza.SpesaRiferimento, true),
StatoSpesa = scadenza.SpesaRiferimento.Stato
};
if (scadenza.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.DatiBancariPrincipale != null)
{
dto.Abi = scadenza.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.DatiBancariPrincipale.Abi;
dto.Cab = scadenza.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.DatiBancariPrincipale.Cab;
}
if (scadenza.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.Responsabile != null)
dto.ResponsabileCondominio = scadenza.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.Responsabile.DisplayName;
if (scadenza.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ResponsabileContabilita != null)
dto.ResponsabileContabilita = scadenza.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ResponsabileContabilita.DisplayName;
dto.Contestata = scadenza.SpesaRiferimento.Contestata;
if (scadenza.SpesaRiferimento.Sinistro > 0)
dto.Sinistro = true;
lista.Add(dto);
}
else
_log.WarnFormat("ATTENZIONE: Anomalia nel tentativo di creare i pagamenti immediati - {0} - scadenza:{1} - spesa:{2}", Utility.GetMethodDescription(), scadenza != null ? scadenza.ID.ToString() : "<NULL>", spesa.ID);
index++;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella creazione dei pagamenti immediati - SINGOLA SCADENZA - {0} - data:{1} - importo:{2:c} - conto:{3} - sottoconto:{4}", ex, Utility.GetMethodDescription(), scadenzaDto.ID, scadenzaDto.IdContoPagamentoScadenza, scadenzaDto.IdSottoContoPagamentoScadenza);
throw;
}
}
createPagamenti(disposizione, lista, StatoSpesaEnum.Pagata, DataPagamentoEnum.Scadenza, TipoPagamentoFatturaEnum.Immediato, spesa.Scadenze.ToList());
// Movimenti Contabili
_movimentiContabilitaService.SetMovimentiPagamenti(disposizione, null, logTransazione);
}
return anomalie;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella creazione dei pagamenti immediati - {0} - spesa:{1}", ex, Utility.GetMethodDescription(), spesa.ID);
throw;
}
}
/// <summary>
/// Crea un movimento contabile valido.
/// E' relativo al conto economico connesso alla registrazione di una spesa
/// </summary>
public MovimentoContabile(TestataMovimentoContabile testata, Spesa spesa, CausaleContabile causale, int? numeroRiga, Conto conto, decimal? importo, string segno)
{
Causale = causale;
Spesa = spesa;
NumeroRiga = numeroRiga;
ContoRiferimento = conto;
Testata = testata;
Importo = importo;
Segno = segno;
Stato = StatoMovimentoContabileEnum.Inserito;
IsVisibileGestione = true;
if (Testata != null)
{
Testata.Movimenti.Add(this);
setNumeroRegistrazione();
}
if (Spesa != null)
Spesa.MovimentiBollette.Add(this);
}
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;
}
public TestataMovimentoContabile SetMovimentiInserimentoSpesa(Spesa spesa, TestataMovimentoContabile testata, DateTime dataRegistrazione)
{
var message = IsAllowDataRegistrazione(new List<int> {spesa.EsercizioRiferimento.CondominioRiferimento.ID}, spesa.EsercizioRiferimento, dataRegistrazione);
if (message.Count == 0)
{
_daoFactory.GetSpesaDao().SaveOrUpdate(spesa);
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("IF");
if (testata == null)
testata = new TestataMovimentoContabile(spesa.EsercizioRiferimento, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null);
testata.SpesaRiferimento = spesa;
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
// ------------------------------------------------
// Conto economico
// ------------------------------------------------
var numeroRiga = 0;
var importoEconomico = 0m;
foreach (var dettaglio in spesa.Dettagli)
{
if (numeroRiga == 0)
testata.Descrizione = dettaglio.GetDescrizione();
foreach (var movimento in dettaglio.Movimenti)
{
movimento.Testata = testata;
movimento.IsMovimentoEconomico = true;
testata.Movimenti.Add(movimento);
numeroRiga++;
movimento.NumeroRiga = numeroRiga;
if (movimento.Importo < 0)
_log.WarnFormat("Presente importo movimento con segno negativo - {0} - movimento:{1}", Utility.GetMethodDescription(), movimento.ID);
importoEconomico += Math.Round(movimento.GetImportoPerSpesa(true).GetValueOrDefault(), 2);
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimento);
}
}
foreach (var movimento in spesa.MovimentiBollette)
{
movimento.Testata = testata;
movimento.IsMovimentoEconomico = true;
testata.Movimenti.Add(movimento);
numeroRiga++;
movimento.NumeroRiga = numeroRiga;
if (movimento.GetImportoConSegno() < 0)
{
movimento.Segno = "A";
movimento.Importo = movimento.GetImportoConSegno()*-1;
}
importoEconomico += movimento.Importo.GetValueOrDefault();
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimento);
}
// ------------------------------------------------
// Debiti VS Fornitori
// ------------------------------------------------
var importoTotale = spesa.ImportoLordo + spesa.AltreSpeseEsenti.GetValueOrDefault();
var importoTotaleArrotondato = Math.Round(importoTotale, 2);
numeroRiga++;
var segno = "A";
if (importoTotale < 0)
{
segno = "D";
importoTotaleArrotondato = importoTotaleArrotondato*-1;
}
var movimentoPatrimoniale = new MovimentoContabile(testata, spesa.FornitoreRiferimento, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(spesa.EsercizioRiferimento.ID, spesa.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoFornitori()), importoTotaleArrotondato, segno)
{
Descrizione = $"Fatt. n. {spesa.NumeroDocumento} del {spesa.DataDocumento.GetValueOrDefault():d}"
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);
// ------------------------------------------------
// Eventuale arrotondamento
// ------------------------------------------------
if (spesa.TipoDocumento == "NOTACC" || spesa.ImportoLordo < 0)
importoTotaleArrotondato = importoTotaleArrotondato*-1;
setMovimentoArrotondamento(importoTotaleArrotondato, importoEconomico, numeroRiga, spesa, testata, causale, null);
return testata;
}
var ex = new InvalidDataException($"La data di registrazione {dataRegistrazione:d} non è valida");
_log.ErrorFormat("Data di registrazione non valida - {0} - data:{1} - spesa:{2} - dataRegistrazione:{3}", ex, Utility.GetMethodDescription(), dataRegistrazione, spesa.ID, dataRegistrazione);
throw ex;
}
private string setRipartoBolletta(Spesa spesa, IList<ImportiDTO> addebitiCalcolati, Conto contoMillesimiSpalo, decimal importoTotaleBollette, IList<RipartoBollette> calcoli, IList<SoggettoCondominio> soggettiAttivi)
{
try
{
var message = string.Empty;
spesa.IsRipartita = true;
// ==================================================
// Calcolo il riparto
// ==================================================
var importoTotaleAddebitato = addebitiCalcolati.Sum(item => item.Importo);
var index = 0;
foreach (var movimento in spesa.MovimentiBollette)
{
try
{
foreach (var speseUnita in movimento.DettaglioRipartizione)
speseUnita.MovimentoRiferimento = null;
movimento.DettaglioRipartizione.Clear();
// Individuo quali sono i consumi da considerare
//var addebitiCalcolatiDaConsiderare = addebitiCalcolati.Where(importoPerUnita => movimento.DettaglioRipartizione.Any(item => item.UnitaRiferimento.ID == importoPerUnita.Id)).ToList();
var unitaDaConsiderare = GetUnitaContoModello(movimento, index);
var addebitiCalcolatiDaConsiderare = addebitiCalcolati.Where(importoPerUnita => unitaDaConsiderare.Any(item => item.ID == importoPerUnita.Id)).ToList();
var percentualeMovimento = (movimento.GetImportoConSegno().GetValueOrDefault() * 100) / importoTotaleBollette;
var importoMovimentoAddebitato = (importoTotaleAddebitato * percentualeMovimento) / 100;
var importoMovimentoSpalo = movimento.GetImportoConSegno().GetValueOrDefault() - importoMovimentoAddebitato;
// Calcolo il riparto per ogni unità
foreach (var importoPerUnita in addebitiCalcolati)
{
try
{
var unita = _daoFactory.GetUnitaImmobiliareDao().GetById(importoPerUnita.Id, false);
// Riparto importo addebitato
var importo = _millesimiService.GetRipartoImportoValori(unita, importoMovimentoAddebitato, addebitiCalcolatiDaConsiderare);
// Riparto spalo
if (contoMillesimiSpalo == null)
importo += _millesimiService.GetRipartoImportoValori(unita, importoMovimentoSpalo, addebitiCalcolatiDaConsiderare);
else
importo += _millesimiService.GetRipartoImporto(unita, contoMillesimiSpalo, importoMovimentoSpalo, null, spesa.EsercizioRiferimento).GetValueOrDefault();
// Aggiorno l'importo a Bilancio sul calcolo acqua
if (calcoli != null)
{
var riparto = (from item in calcoli
where item.UnitaImmobiliare != null && item.UnitaImmobiliare.ID == importoPerUnita.Id
select item).SingleOrDefault();
if (riparto != null)
riparto.ImportoBilancio = riparto.ImportoBilancio.GetValueOrDefault() + importo;
}
// =======================================================================================
// Riparto la spese tra tutti i condomini partecipanti nell'unità immobiliare
// =======================================================================================
// -------------------------
// Proprietario
// -------------------------
var proprietariPrincipali = (from item in soggettiAttivi
where
item.Tipo == TipoSoggetto.Proprietario &&
item.UnitaImmobiliare.ID == unita.ID &&
item.Principale.GetValueOrDefault()
select item).ToList();
if (proprietariPrincipali.Count > 1)
{
if (proprietariPrincipali.All(item => item.DataInizio == null) || proprietariPrincipali.All(item => item.DataFine == null))
_log.Warn("Trovato più di un PROPRIETARIO principale - " + Library.Utility.GetMethodDescription() + " - idUnita: " + unita.ID + " - idEsercizio: " + movimento.Testata.EsercizioRiferimento.ID);
}
var proprietarioPrincipale = proprietariPrincipali.OrderByDescending(item => item.DataInizio.GetValueOrDefault()).FirstOrDefault(item => item.DataFine == null);
// Se il proprietario non è presente lo cerco tra tutti i proprietari
if (proprietarioPrincipale == null)
{
proprietarioPrincipale = (from item in unita.Proprietari
where item.DataInizio == null || item.DataInizio.Value < movimento.Testata.EsercizioRiferimento.DataChiusura
orderby item.DataInizio.GetValueOrDefault() descending
select item).FirstOrDefault();
}
var importoConduzione = _ripartizioneSpeseService.GetImportoCompetenza(importo.GetValueOrDefault(), movimento, TipoSoggetto.Conduttore);
var importoProprieta = _ripartizioneSpeseService.GetImportoCompetenza(importo.GetValueOrDefault(), movimento, TipoSoggetto.Proprietario);
// --------------------------------------------
// Importo di proprietà
// --------------------------------------------
if (importoProprieta != 0)
{
var soggProp = new List<ImportiDTO>();
// --------------------------------------------------------------------
// Individuo tutti i soggetti tra cui ripartire l'importo
// --------------------------------------------------------------------
var conto = movimento.ContoRiferimento;
var soggPropRip = (from itemSogg in conto.SoggettiRipartizione
where itemSogg.Soggetto.Tipo == TipoSoggetto.Proprietario && itemSogg.Soggetto.UnitaImmobiliare.ID == unita.ID
select itemSogg).ToList();
// In presenza di ripartizioni personalizzate occorre dividere l'importo addebito alla proprietà tra i diversi proprietari
if (soggPropRip.Count > 0)
{
var totaleSoggPropRip = soggPropRip.Sum(item => item.PercentualeRipartizione);
soggProp.AddRange(from sogg in soggPropRip
let soggettoRipartizione = sogg.Soggetto
select new ImportiDTO
{
Id = soggettoRipartizione.ID,
Importo = (importoProprieta * sogg.PercentualeRipartizione) / totaleSoggPropRip
});
}
else if (soggPropRip.Count == 0)
{
var proprietariAttivi = soggettiAttivi.Where(item => item.Tipo == TipoSoggetto.Proprietario && item.UnitaImmobiliare.ID == unita.ID).ToList();
if (proprietariAttivi.Count == 0 && proprietarioPrincipale != null)
proprietariAttivi.Add(proprietarioPrincipale);
if (proprietariAttivi.Sum(item => item.PercentualeRiferimento) != 100)
{
if (proprietariAttivi.All(item => item.DataInizio == null) || proprietariAttivi.All(item => item.DataFine == null))
_log.Warn("ATTENZIONE: La somma della percentuale di riparto non è 100 - " + Library.Utility.GetMethodDescription() + " (Spese - Proprietari) - idUnita:" + unita.ID + " - idSpesa: " + spesa.ID + " - idEsercizio: " + movimento.Testata.EsercizioRiferimento.ID);
if (proprietariAttivi.Count == 1)
proprietariAttivi[0].PercentualeRiferimento = 100m;
}
soggProp.AddRange(proprietariAttivi.Select(soggAttivo => new ImportiDTO { Id = soggAttivo.ID, Importo = (importoProprieta * soggAttivo.PercentualeRiferimento.GetValueOrDefault()) / 100 }));
}
foreach (var importiDTO in soggProp)
{
var soggetto = soggettiAttivi.FirstOrDefault(item => item.ID == importiDTO.Id) ?? _daoFactory.GetSoggettoCondominioDao().Find(importiDTO.Id, false);
var spesaUnita = new SpeseUnita(importiDTO.Importo, null, soggetto, movimento);
_daoFactory.GetSpeseUnitaDao().SaveOrUpdate(spesaUnita);
}
}
// --------------------------------------------
// Importo di conduzione
// --------------------------------------------
if (importoConduzione > 0)
{
var soggCond = new List<ImportiDTO>();
var soggCondRip = (from itemSogg in movimento.ContoRiferimento.SoggettiRipartizione
where
itemSogg.Soggetto.Tipo == TipoSoggetto.Conduttore &&
itemSogg.Soggetto.UnitaImmobiliare.ID == unita.ID
select itemSogg).ToList();
if (soggCondRip.Count > 0)
{
var totaleSoggCondRip = soggCondRip.Sum(item => item.PercentualeRipartizione);
soggCond.AddRange(soggCondRip.Select(sogg => new ImportiDTO
{
Id = sogg.Soggetto.ID,
Importo = (importoConduzione * sogg.PercentualeRipartizione) / totaleSoggCondRip
}));
}
else if (soggCondRip.Count == 0)
{
var conduttoriAttivi = (from item in soggettiAttivi
where item.Tipo == TipoSoggetto.Conduttore && item.UnitaImmobiliare.ID == unita.ID
select item).ToList();
if (!conduttoriAttivi.Any())
{
conduttoriAttivi = (from item in soggettiAttivi
where item.Tipo == TipoSoggetto.Proprietario && item.UnitaImmobiliare.ID == unita.ID
select item).ToList();
}
if (conduttoriAttivi.Sum(item => item.PercentualeRiferimento) != 100)
{
_log.Warn("ATTENZIONE: La somma della percentuale di riparto non è 100 - " + Library.Utility.GetMethodDescription() + " (Spese - Conduttori) - idUnita:" + unita.ID + " - idSpesa: " + spesa.ID + " - idEsercizio: " + movimento.Testata.EsercizioRiferimento.ID);
if (conduttoriAttivi.Count == 1)
conduttoriAttivi[0].PercentualeRiferimento = 100m;
}
soggCond.AddRange(conduttoriAttivi.Select(soggAttivo => new ImportiDTO { Id = soggAttivo.ID, Importo = (importoConduzione * soggAttivo.PercentualeRiferimento.GetValueOrDefault()) / 100 }));
}
foreach (var importiDTO in soggCond)
{
var soggetto = soggettiAttivi.FirstOrDefault(item => item.ID == importiDTO.Id) ?? _daoFactory.GetSoggettoCondominioDao().Find(importiDTO.Id, false);
var spesaUnita = new SpeseUnita(importiDTO.Importo, null, soggetto, movimento);
_daoFactory.GetSpeseUnitaDao().SaveOrUpdate(spesaUnita);
}
}
}
catch (Exception ex)
{
_log.Error("Errore durante la ripartizione di una bolletta - SINGOLA UNITA' - " + Library.Utility.GetMethodDescription() + " - unità:" + importoPerUnita.Id + " - movimento:" + movimento.ID + " - idBolletta:" + spesa.ID, ex);
throw;
}
}
index++;
}
catch (Exception ex)
{
_log.Error("Errore durante la ripartizione di una bolletta - SINGOLO MOVIMENTO - " + Library.Utility.GetMethodDescription() + " - movimento:" + movimento.ID + " - idBolletta:" + spesa.ID, ex);
throw;
}
}
return message;
}
catch (Exception ex)
{
_log.Error("Errore durante la ripartizione di una bolletta - " + Library.Utility.GetMethodDescription() + " - idBolletta:" + spesa.ID, ex);
throw;
}
}
public void SalvaRipartizione(Spesa spesa)
{
foreach (var dettaglio in spesa.Dettagli)
{
foreach (var movimento in dettaglio.Movimenti)
{
if (dettaglio.Movimenti.Count > 0)
{
SalvaRipartizione(movimento, spesa.EsercizioRiferimento.CondominioRiferimento.ID);
}
}
}
}
public string SetRipartoBolletta(Spesa spesa, IList<ImportiDTO> addebitiCalcolati, Conto contoMillesimiSpalo, IList<SoggettoCondominio> soggettiAttivi)
{
return setRipartoBolletta(spesa, addebitiCalcolati, contoMillesimiSpalo, spesa.ImportoBolletta.GetValueOrDefault(), null, soggettiAttivi);
}
public ResultBolletta SalvaBolletta(BollettaDTO dto, bool controlloDataRegistrazione)
{
try
{
var message = string.Empty;
if (dto.IdFornitore > 0 && dto.IdEsercizio > 0)
{
foreach (var dettaglioDto in dto.Dettagli)
{
try
{
if (string.IsNullOrEmpty(dettaglioDto.AliquotaIva))
dettaglioDto.ImportoLordo = dettaglioDto.Imponibile;
else
{
var aliquotaIva = new decimal(Library.Decodifica.Instance.GetElement("CodiceIva", dettaglioDto.AliquotaIva).ValoreNumerico);
dettaglioDto.ImportoIva = dettaglioDto.Imponibile * aliquotaIva;
dettaglioDto.ImportoLordo = dettaglioDto.Imponibile + dettaglioDto.ImportoIva;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore durante il salvataggio di una bolletta (Singolo Dettaglio) - {0} - dettaglio:{1} - idBolletta:{2} - pagata:{3}", ex, Library.Utility.GetMethodDescription(), dettaglioDto.ID, dto.ID, dto.Rid);
throw;
}
}
if (dto.Rid && (dto.IdContoPagamento == 0 || dto.IdSottoContoPagamento == 0))
{
return new ResultBolletta(dto, "Se è selezionato il pagamento automatico tramite rid occorre selezionare un conto corrente di pagamento");
}
var spesa = _daoFactory.GetSpesaDao().Find(dto.ID, false);
var esercizio = _daoFactory.GetEsercizioDao().GetById(dto.IdEsercizio.GetValueOrDefault(), false);
if (spesa != null)
{
spesa.Autorizzata = dto.Autorizzata;
if(!dto.Rid && spesa.Pagamenti.Count > 0)
return new ResultBolletta(dto, "Non è possibile aggiornare la registrazione perchè sono presenti dei pagamenti");
var messageAnnullamentoPagamenti = _pagamentoService.IsAllowAnnullamentoPagamentiSpesa(spesa.ID);
if(!string.IsNullOrEmpty(messageAnnullamentoPagamenti.FatalMessage))
return new ResultBolletta(dto, "Non è possibile aggiornare la registrazione perchè sono presenti dei pagamenti non annullabili." + Environment.NewLine + messageAnnullamentoPagamenti.FatalMessage);
spesa.FornitoreRiferimento = _daoFactory.GetFornitoreDao().GetById(dto.IdFornitore.GetValueOrDefault(), false);
spesa.EsercizioRiferimento = esercizio;
var scadenza = spesa.Scadenze.FirstOrDefault();
if (scadenza != null)
{
scadenza.Scadenza = dto.DataScadenza;
scadenza.Importo = dto.Importo;
// Annullo i pagamenti preesistenti
var messageAnnullaPagamenti = _pagamentoService.AnnullamentoPagamentiSpesa(spesa.ID);
if (!string.IsNullOrEmpty(messageAnnullaPagamenti))
{
var utente = _daoFactory.GetUtenteDao().Find(dto.IdUtente, false);
var username = "******";
if (utente != null)
username = utente.Username;
else
_log.ErrorFormat("Non trovato idUtente - {0} - azienda:{1} - bolletta:{2}", Library.Utility.GetMethodDescription(), Security.Login.Instance.CurrentLogin().Azienda, dto.ID);
_persistenceContext.RollbackAndCloseSession(username);
message += Environment.NewLine + messageAnnullaPagamenti + Environment.NewLine;
return new ResultBolletta(dto, message);
}
}
}
else
{
spesa = new Spesa(_daoFactory.GetFornitoreDao().GetById(dto.IdFornitore.GetValueOrDefault(), false), esercizio) { Autorizzata = dto.Autorizzata };
var protocollo = _protocolloService.GetProgressivo(TipoProtocollo.Fattura, esercizio.DataApertura.GetValueOrDefault().Year, spesa.EsercizioRiferimento.CondominioRiferimento);
if (protocollo.Progressivo != null)
{
spesa.NumeroProtocollo = protocollo.Progressivo;
spesa.AnnoArchiviazioneOttica = esercizio.DataApertura.GetValueOrDefault().Year;
}
else
{
message += protocollo.Message + Environment.NewLine;
return new ResultBolletta(null, message);
}
spesa.Scadenze.Add(new ScadenzaFattura(spesa, dto.DataScadenza, dto.Importo));
}
spesa.RidAutomatica = dto.Rid;
spesa.IsRipartita = false;
spesa.TipoDocumento = "BOLLETTA";
spesa.DataDocumento = dto.DataDocumento;
spesa.NumeroDocumento = dto.NumeroDocumento;
spesa.ImportoBolletta = dto.Importo;
spesa.DataInizioCompetenza = dto.DataInizioCompetenza;
spesa.DataFineCompetenza = dto.DataFineCompetenza;
spesa.IsRipartoPersonalizzato = dto.IsRipartoPersonalizzato;
spesa.IsAbilitataArchiviazioneOttica = dto.IsAbilitataArchiviazioneOttica;
spesa.Utenza = _daoFactory.GetUtenzaDao().GetById(dto.IdUtenza, false);
_daoFactory.GetSpesaDao().SaveOrUpdate(spesa);
// ---------------------------
// Dettagli
// ---------------------------
spesa.Dettagli.Clear();
const int index = 0;
foreach (var dettaglioDto in dto.Dettagli)
{
var dettaglio = new DettaglioSpesa(spesa, index)
{
AliquotaIva = dettaglioDto.AliquotaIva,
Descrizione = dettaglioDto.Descrizione,
ID = dettaglioDto.ID,
Note = dettaglioDto.Note,
Tipo = (TipoDettaglioBollettaEnum)Enum.Parse(typeof (TipoDettaglioBollettaEnum), dettaglioDto.Tipo),
Quantita = dettaglioDto.Quantita
};
if (string.IsNullOrEmpty(dettaglioDto.AliquotaIva))
dettaglio.ImportoLordo = dettaglioDto.Imponibile;
else
{
var aliquotaIva = new decimal(Library.Decodifica.Instance.GetElement("CodiceIva", dettaglioDto.AliquotaIva).ValoreNumerico);
dettaglio.ImportoIva = dettaglioDto.Imponibile * aliquotaIva;
dettaglio.ImportoLordo = dettaglioDto.Imponibile + dettaglio.ImportoIva;
}
spesa.Dettagli.Add(dettaglio);
}
// ---------------------------
// Movimenti
// ---------------------------
_movimentoContabileService.SetMovimentoBolletta(dto, spesa, null, controlloDataRegistrazione);
// ==========================================================================================================================================
// BUGID#2159 - COMMENTATO: Con la nuova funzione di riparto aggregato NON devono
// più essere usati gli oggetti SpeseUnita NON deve quindi essere ripartito lo specifico
// movimento
// Sostuitita con calcolo degli addebiti specifici per Lotto, Stabile e Scala.
// ---------------------------
// Ripartizione
// ---------------------------
foreach (var movimentoDto in dto.Movimenti)
{
var movimento = _daoFactory.GetMovimentoContabileDao().Find(movimentoDto.ID, false);
if (movimento == null)
{
_log.Error("Errore durante il salvataggio di una bolletta - MOVIMENTO NON PIù ESISTENTE " + Library.Utility.GetMethodDescription() + " - movimento:" + movimentoDto.ID + " - idBolletta:" + dto.ID + " - pagata:" + dto.Rid);
return new ResultBolletta(null, "E' stato cancellato in un'altra finestra il movimento di contabilità");
}
if (!string.IsNullOrEmpty(movimentoDto.RipartoAggiornato))
{
movimento.LottiAddebito = null;
movimento.GruppiAddebito = null;
movimento.StabiliAddebito = null;
}
switch (movimentoDto.RipartoAggiornato)
{
case "U":
break;
case "G":
if (movimentoDto.Ripartizione.Gruppi != null && movimentoDto.Ripartizione.Gruppi.Count > 0)
{
var lista = movimentoDto.Ripartizione.Gruppi;
foreach (var item in lista)
{
if (item.Selezionato)
movimento.GruppiAddebito += item.ID + "&";
}
// Se sono stati selezionati tutti i gruppi NON salvo l'elenco dei gruppi
if (movimento.GruppiAddebito == spesa.EsercizioRiferimento.CondominioRiferimento.GetGruppiKey())
movimento.GruppiAddebito = string.Empty;
if (!string.IsNullOrEmpty(movimento.GruppiAddebito) && movimento.GruppiAddebito.EndsWith("&"))
movimento.GruppiAddebito = movimento.GruppiAddebito.Substring(0, movimento.GruppiAddebito.Length - 1);
}
break;
case "S":
if (movimentoDto.Ripartizione.Stabili != null && movimentoDto.Ripartizione.Stabili.Count > 0)
{
var lista = movimentoDto.Ripartizione.Stabili;
foreach (var item in lista)
{
if (item.Selezionato)
movimento.StabiliAddebito += item.ID + "&";
}
// Se sono stati selezionati tutti gli stabili NON salvo l'elenco degli stabili
if (movimento.StabiliAddebito == spesa.EsercizioRiferimento.CondominioRiferimento.GetStabiliKey())
movimento.StabiliAddebito = string.Empty;
if (!string.IsNullOrEmpty(movimento.StabiliAddebito) && movimento.StabiliAddebito.EndsWith("&"))
movimento.StabiliAddebito = movimento.StabiliAddebito.Substring(0, movimento.StabiliAddebito.Length - 1);
}
break;
case "L":
if (movimentoDto.Ripartizione.Lotti != null && movimentoDto.Ripartizione.Lotti.Count > 0)
{
var lista = movimentoDto.Ripartizione.Lotti;
foreach (var item in lista)
{
if (item.Selezionato)
movimento.LottiAddebito += item.ID + "&";
}
// Se sono stati selezionati tutti i lotti NON salvo l'elenco dei lotti
if (movimento.LottiAddebito == spesa.EsercizioRiferimento.CondominioRiferimento.GetLottiKey())
movimento.LottiAddebito = string.Empty;
if (!string.IsNullOrEmpty(movimento.LottiAddebito) && movimento.LottiAddebito.EndsWith("&"))
movimento.LottiAddebito = movimento.LottiAddebito.Substring(0, movimento.LottiAddebito.Length - 1);
}
break;
}
}
//foreach (var movimentoDto in dto.Movimenti)
//{
// var movimento = _daoFactory.GetMovimentoContabileDao().Find(movimentoDto.ID, false);
// if (movimento == null)
// {
//
// _log.Error("Errore durante il salvataggio di una bolletta - MOVIMENTO NON PIù ESISTENTE " + Library.Utility.GetMethodDescription() + " - movimento:" + movimentoDto.ID + " - idBolletta:" + dto.ID + " - pagata:" + pagata);
// return new ResultBolletta(null, "E' stato cancellato in un'altra finestra il movimento di contabilità");
// }
// foreach (var dettaglioRipartizione in movimento.DettaglioRipartizione)
// {
// dettaglioRipartizione.MovimentoRiferimento = null;
// dettaglioRipartizione.UnitaRiferimento = null;
// _daoFactory.GetSpeseUnitaDao().Delete(dettaglioRipartizione);
// }
// movimento.DettaglioRipartizione.Clear();
// if (!string.IsNullOrEmpty(movimentoDto.RipartoAggiornato))
// {
// movimento.LottiAddebito = null;
// movimento.GruppiAddebito = null;
// movimento.StabiliAddebito = null;
// }
// switch (movimentoDto.RipartoAggiornato)
// {
// case "U":
// if (movimentoDto.Ripartizione.UnitaImmobiliari != null && movimentoDto.Ripartizione.UnitaImmobiliari.Count > 0)
// {
// var lista = movimentoDto.Ripartizione.UnitaImmobiliari;
// foreach (var item in lista)
// {
// if (item.Selezionato)
// {
// var dettaglioRipartizione = new SpeseUnita(null, _daoFactory.GetUnitaImmobiliareDao().GetById(item.ID, false), movimento);
// _daoFactory.GetSpeseUnitaDao().SaveOrUpdate(dettaglioRipartizione);
// }
// }
// }
// break;
// case "G":
// if (movimentoDto.Ripartizione.Gruppi != null && movimentoDto.Ripartizione.Gruppi.Count > 0)
// {
// var lista = movimentoDto.Ripartizione.Gruppi;
// foreach (var item in lista)
// {
// if (item.Selezionato)
// {
// var gruppo = _daoFactory.GetGruppoStabileDao().GetById(item.ID, false);
// movimento.GruppiAddebito += gruppo.ID + "&";
// foreach (var unita in gruppo.UnitaImmobiliari)
// {
// var dettaglioRipartizione = new SpeseUnita(null, unita, movimento);
// _daoFactory.GetSpeseUnitaDao().SaveOrUpdate(dettaglioRipartizione);
// }
// }
// }
// // Se sono stati selezionati tutti i gruppi NON salvo l'elenco dei gruppi
// if (movimento.GruppiAddebito == spesa.EsercizioRiferimento.CondominioRiferimento.GetGruppiKey())
// movimento.GruppiAddebito = string.Empty;
// if (!string.IsNullOrEmpty(movimento.GruppiAddebito) && movimento.GruppiAddebito.EndsWith("&"))
// movimento.GruppiAddebito = movimento.GruppiAddebito.Substring(0, movimento.GruppiAddebito.Length - 1);
// }
// break;
// case "S":
// if (movimentoDto.Ripartizione.Stabili != null && movimentoDto.Ripartizione.Stabili.Count > 0)
// {
// var lista = movimentoDto.Ripartizione.Stabili;
// foreach (var item in lista)
// {
// if (item.Selezionato)
// {
// var stabile = _daoFactory.GetPalazzinaDao().GetById(item.ID, false);
// movimento.StabiliAddebito += stabile.ID + "&";
// foreach (var dettaglioRipartizione in stabile.GruppiStabile.SelectMany(gruppo => gruppo.UnitaImmobiliari.Select(unita => new SpeseUnita(null, unita, movimento))))
// {
// _daoFactory.GetSpeseUnitaDao().SaveOrUpdate(dettaglioRipartizione);
// }
// }
// }
// // Se sono stati selezionati tutti gli stabili NON salvo l'elenco degli stabili
// if (movimento.StabiliAddebito == spesa.EsercizioRiferimento.CondominioRiferimento.GetStabiliKey())
// movimento.StabiliAddebito = string.Empty;
// if (!string.IsNullOrEmpty(movimento.StabiliAddebito) && movimento.StabiliAddebito.EndsWith("&"))
// movimento.StabiliAddebito = movimento.StabiliAddebito.Substring(0, movimento.StabiliAddebito.Length - 1);
// }
// break;
// case "L":
// if (movimentoDto.Ripartizione.Lotti != null && movimentoDto.Ripartizione.Lotti.Count > 0)
// {
// var lista = movimentoDto.Ripartizione.Lotti;
// foreach (var item in lista)
// {
// if (item.Selezionato)
// {
// var stabili = _daoFactory.GetPalazzinaDao().GetByLotto(_daoFactory.GetLottoDao().GetById(item.ID, false));
// movimento.LottiAddebito += item.ID + "&";
// foreach (var dettaglioRipartizione in stabili.SelectMany(stabile => stabile.GruppiStabile.SelectMany(gruppo => gruppo.UnitaImmobiliari.Select(unita => new SpeseUnita(null, unita, movimento)))))
// {
// _daoFactory.GetSpeseUnitaDao().SaveOrUpdate(dettaglioRipartizione);
// }
// }
// }
// // Se sono stati selezionati tutti i lotti NON salvo l'elenco dei lotti
// if (movimento.LottiAddebito == spesa.EsercizioRiferimento.CondominioRiferimento.GetLottiKey())
// movimento.LottiAddebito = string.Empty;
// if (!string.IsNullOrEmpty(movimento.LottiAddebito) && movimento.LottiAddebito.EndsWith("&"))
// movimento.LottiAddebito = movimento.LottiAddebito.Substring(0, movimento.LottiAddebito.Length - 1);
// }
// break;
// }
//}
// ==========================================================================================================================================
// ---------------------------
// Pagamenti
// ---------------------------
if (dto.Rid)
{
if (spesa.ImportoBolletta > 0)
_pagamentoService.CreatePagamentiImmediatiBolletta(spesa, dto);
else // nota accredito
{
var riscossioni = new List<RiscossioneNotaAccreditoDTO>
{
new RiscossioneNotaAccreditoDTO
{
IdNotaAccredito = spesa.ID,
IdConto = dto.IdContoPagamento,
IdSottoConto = dto.IdSottoContoPagamento,
Importo = dto.Importo
}
};
_pagamentoService.RiscossioneNoteAccredito(riscossioni, dto.DataScadenza);
}
}
//====================================================================
// Se il tipo utenza non è acqua la bolletta viene subito ripartita
//====================================================================
// Aggiorno il selected sul DTO, necessario in caso di inserimento
foreach (var movimentoDto in dto.Movimenti)
{
var movimento = _daoFactory.GetMovimentoContabileDao().GetById(movimentoDto.ID, false);
if (movimentoDto.Ripartizione != null)
{
foreach (var itemDto in movimentoDto.Ripartizione.UnitaImmobiliari)
itemDto.Selezionato = movimento.DettaglioRipartizione.Any(item => item.UnitaRiferimento.ID == itemDto.ID);
}
}
if (spesa.Utenza != null && !spesa.Utenza.RipartoLetture)
{
foreach (var movimento in spesa.MovimentiBollette)
_ripartizioneSpeseService.RicalcoloRipartizioneByMovimento(movimento);
spesa.IsRipartita = true;
}
spesa.IsRipartoPersonalizzato = dto.IsRipartoPersonalizzato;
dto.IdentificativoArchiviazioneOttica = _archiviazioneService.GetIdentificativoArchiviazione(spesa);
spesa.SetStato();
dto.StatoSpesa = spesa.Stato;
}
else
{
_log.Warn("ATTENZIONE: Per la bolletta non è definito il fornitore o l'esercizio - " + Library.Utility.GetMethodDescription() + " - fornitore:" + dto.IdFornitore.GetValueOrDefault() + " - esercizio:" + dto.IdEsercizio.GetValueOrDefault() + " - idBolletta:" + dto.ID + " - pagata:" + dto.Rid);
if (!(dto.IdFornitore > 0))
message += "Per la bolletta non è definito il FORNITORE" + Environment.NewLine;
if (!(dto.IdEsercizio > 0))
message += "Per la bolletta non è definito l'ESERCIZIO" + Environment.NewLine;
}
if (!string.IsNullOrEmpty(message))
dto = null;
return new ResultBolletta(dto, message);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore durante il salvataggio di una bolletta - {0} - idBolletta:{1} - pagata:{2}", ex, Library.Utility.GetMethodDescription(), dto.ID, dto.Rid);
throw;
}
}
public virtual IUpdatableBusinessEntity Copy()
{
var spesa = new Spesa(FornitoreRiferimento, EsercizioRiferimento, null)
{
AliquotaRitenuta = AliquotaRitenuta,
AltreSpese = AltreSpese,
CassaProfessionisti = CassaProfessionisti,
DataDocumento = DataDocumento,
Detrazione = Detrazione,
ImportoRitenuta = ImportoRitenuta,
IsMultiIva = IsMultiIva,
NumeroDocumento = NumeroDocumento,
NumeroProtocollo = NumeroProtocollo,
Stato = Stato,
TipoDocumento = TipoDocumento
};
foreach (var dettaglio in Dettagli)
{
spesa.Dettagli.Add((DettaglioSpesa)dettaglio.Copy());
}
return spesa;
}
public void SetMovimentoArrotondamento(Spesa spesa, TestataMovimentoContabile testata, CausaleContabile causale, LogTransazione logTransazione)
{
var importoTotale = testata.Movimenti.Where(item => item.Segno == "A").Sum(item => Math.Round(item.Importo.GetValueOrDefault(), 2, MidpointRounding.AwayFromZero));
var importoEconomico = testata.Movimenti.Where(item => item.Segno == "D").Sum(item => Math.Round(item.Importo.GetValueOrDefault(), 2, MidpointRounding.AwayFromZero));
var numeroRiga = testata.Movimenti.Max(item => item.NumeroRiga.GetValueOrDefault()) + 1;
setMovimentoArrotondamento(importoTotale, importoEconomico, numeroRiga, spesa, testata, causale, logTransazione);
}
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;
}
private void setMovimentoArrotondamento(decimal importoAvere, decimal importoDare, int numeroRiga, Spesa spesa, TestataMovimentoContabile testata, CausaleContabile causale, LogTransazione logTransazione)
{
if (importoAvere != importoDare)
{
var importoArrotondamento = importoAvere - importoDare;
numeroRiga++;
var segno = "D";
if (importoArrotondamento < 0)
{
segno = "A";
importoArrotondamento = importoArrotondamento * -1;
}
var contoArrotondamenti = _pianoContiService.GetContoArrotondamenti(testata.EsercizioRiferimento);
_daoFactory.GetContoDao().SaveOrUpdate(contoArrotondamenti);
var movimentoArrotondamento = new MovimentoContabile(testata, causale, numeroRiga, contoArrotondamenti, importoArrotondamento, segno)
{
Descrizione = spesa != null ? string.Format("Arrotondamento Fatt. n. {0} del {1:d}", spesa.NumeroDocumento, spesa.DataDocumento.GetValueOrDefault()) : string.Format("Arrotondamento per {0}", testata.GetDescrizione())
};
if(logTransazione == null)
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoArrotondamento);
}
}
private SpesaDetrazioneDTO setDetrazioneDto(Spesa spesa, bool includeDettagli, bool includeDettaglioMovimenti, int? anno, int? detrazione)
{
try
{
var dto = setDto(spesa, includeDettagli, includeDettaglioMovimenti, anno, detrazione);
var dtoDetrazione = new SpesaDetrazioneDTO(dto);
if (spesa.RipartizioneSpesa.Count > 0)
{
foreach (var ripartizioneSpesa in spesa.RipartizioneSpesa)
{
var ripartizioneSpesaDto = getMovimentoRepository().GetRipartizioneSpesaByDomainEntity(ripartizioneSpesa);
dtoDetrazione.RipartizioneDetrazione.Add(ripartizioneSpesaDto);
}
}
else if(spesa.Stato == StatoSpesaEnum.PagataAltroAmministratore)
{
// Nel caso di spesa inserita fiscalmente propongo come riparto le singole righe di dettaglio con i relativi importi
foreach (var dettaglioSpesa in spesa.Dettagli)
{
var ripartizioneSpesaDto = new RipartizioneSpesaDTO { ID = dettaglioSpesa.ID * -1, Descrizione = dettaglioSpesa.Descrizione, Importo = dettaglioSpesa.ImportoLordo, Stato = "RIPARTIZIONE"};
dtoDetrazione.RipartizioneDetrazione.Add(ripartizioneSpesaDto);
}
}
dtoDetrazione.Dettagli = null;
return dtoDetrazione;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella creazione dell'istanza DTO per una spesa - {0} - id:{1}", ex, Utility.GetMethodDescription(), spesa.ID);
throw;
}
}
private MovimentoContabile getMovimentoPrincipale(Spesa spesa, MovimentoContabile movimentoSecondario)
{
foreach (var dettaglio in spesa.Dettagli)
{
if (movimentoSecondario.DettaglioRiferimento == null || dettaglio.NumeroRiga == movimentoSecondario.DettaglioRiferimento.NumeroRiga)
{
foreach (var movimento in dettaglio.Movimenti)
{
if (movimento.NumeroRiga == movimentoSecondario.NumeroRiga)
return movimento;
}
}
}
return null;
}
public void UpdateMovimentiSecondari(Spesa spesa, IList<MovimentoContabile> movimentiSecondari)
{
if (movimentiSecondari.Count > 0)
{
// Caso 1: Spese Accorpate
if (movimentiSecondari[0].DettaglioRiferimento != null)
{
foreach (var movimento in movimentiSecondari)
{
movimento.MovimentoPrincipaleMultiIva = getMovimentoPrincipale(spesa, movimento);
}
}
// Caso 2: Spese Multi Iva
else
{
var dettaglioPrincipale = (from dettaglio in spesa.Dettagli
where dettaglio.NumeroRiga == 1
select dettaglio).SingleOrDefault();
if (dettaglioPrincipale != null)
{
foreach (var dettaglio in spesa.Dettagli)
{
if (dettaglio != dettaglioPrincipale)
{
int index = 0;
foreach (var movimento in dettaglio.Movimenti)
{
index++;
movimento.MovimentoPrincipaleMultiIva = (from mov in dettaglioPrincipale.Movimenti
where mov.NumeroRiga == index
select mov).SingleOrDefault();
}
}
}
}
}
}
}
public SpesaDTO GetByDomainEntity(Spesa item)
{
try
{
return setDto(item, true, false, null, null);
}
catch (Exception ex)
{
_log.Error("Errore nel caricamento delle Fatture/Spese: " + Utility.GetMethodDescription() + " - id:" + item.ID.ToString(), ex);
throw;
}
}
/// <summary>
/// Se non presente viene calcolata e inserita la ripartizione di default.
/// Se l'oggetto RipartizioneSpeseDTO non è null la ripartizione è stata personalizzata dall'operatore e quindi nulla deve essere fatto.
/// </summary>
/// <param name="listaRipartizione">Contiene l'insieme delle ripartizioni personalizzate dall'operatore al momento dell'inserimento della spesa.</param>
/// <param name="spesa">Spesa inserita</param>
public void AddDefaultRipartizione(IDictionary<DettaglioSpesaDTO, RipartizioneSpeseDTO> listaRipartizione, Spesa spesa)
{
try
{
var ripartizioneSpeseService = _windsorRepository.GetContainer(_info.Azienda).Resolve<IRipartizioneSpeseService>();
foreach (var dettaglio in spesa.Dettagli)
{
RipartizioneSpeseDTO ripartizione = null;
if (listaRipartizione.Count > 0)
{
var key = GetDettaglioDto(listaRipartizione, dettaglio.NumeroRiga.GetValueOrDefault());
if (listaRipartizione.ContainsKey(key))
ripartizione = listaRipartizione[key];
}
if (ripartizione?.UnitaImmobiliari == null)
ripartizioneSpeseService.ReloadRipartizioneByDettaglio(dettaglio);
else
{
foreach (var movimento in dettaglio.Movimenti)
{
if (movimento.DettaglioRipartizione.Count == 0)
ripartizioneSpeseService.ReloadRipartizioneByMovimento(movimento);
}
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nell'inserimento dei movimenti di ripartizione - {0} - spesa:{1}", ex, Library.Utility.GetMethodDescription(), spesa.ID);
throw;
}
}
public ResultSpesa(Spesa spesa, string message)
{
Spesa = spesa;
Message = message;
}
public SpesaInfoDTO InserimentoNotaAccredito(NotaAccreditoDTO notaDto, IList<StornoScadenzaDTO> scadenze)
{
try
{
var esercizio = _daoFactory.GetEsercizioDao().Find(notaDto.IdEsercizio, false);
if(esercizio == null)
throw new InvalidDataException("Non è stato necessario l'esercizio di riferimento");
var nota = _daoFactory.GetSpesaDao().Find(notaDto.ID, false);
if (nota == null)
{
nota = new Spesa(_daoFactory.GetFornitoreDao().GetById(notaDto.IdFornitore, false), esercizio, null);
_daoFactory.GetSpesaDao().SaveOrUpdate(nota);
}
var impostazioni = _daoFactory.GetImpostazioniAziendaDao().GetByAzienda(nota.EsercizioRiferimento.CondominioRiferimento.Azienda.ID);
nota.TipoDocumento = "NOTACC";
nota.NumeroDocumento = notaDto.NumeroDocumento;
nota.DataDocumento = notaDto.DataDocumento;
nota.ImportoRitenuta = scadenze.Sum(item => item.ImportoRitenuta);
nota.Stato = StatoSpesaEnum.Stornata;
DettaglioSpesa dettaglio;
if (notaDto.IdDettaglioSpesa == 0)
{
dettaglio = new DettaglioSpesa(nota, 1);
_daoFactory.GetDettaglioSpesaDao().SaveOrUpdate(dettaglio);
}
else
dettaglio = _daoFactory.GetDettaglioSpesaDao().GetById(notaDto.IdDettaglioSpesa, false);
dettaglio.Descrizione = notaDto.Descrizione;
dettaglio.ImportoLordo = scadenze.Sum(item => item.Importo + item.ImportoRitenuta);
var message = StornoNoteAccredito(nota.ID, scadenze, dettaglio, esercizio, notaDto.DataRegistrazione);
var identificativoArchiviazione = string.Empty;
if (string.IsNullOrEmpty(message))
{
var protocollo = _protocolloService.GetProgressivo(TipoProtocollo.Fattura, esercizio.DataApertura.GetValueOrDefault().Year, nota.EsercizioRiferimento.CondominioRiferimento);
if (protocollo.Progressivo != null)
{
nota.NumeroProtocollo = protocollo.Progressivo;
if (nota.IsAbilitataArchiviazioneOttica)
identificativoArchiviazione = _archiviazioneOtticaService.GetIdentificativoArchiviazione(nota, true);
}
else
message += protocollo.Message + Environment.NewLine;
}
return string.IsNullOrEmpty(message) ? new SpesaInfoDTO { Id = nota.ID, IdentificativoArchiviazione = identificativoArchiviazione, NumeroProtocollo = nota.NumeroProtocollo.GetValueOrDefault(), StampaEtichettaArchiviazione = impostazioni.UtilizzoEtichettatriceArchiviazioneOtticaFatture && nota.EsercizioRiferimento.CondominioRiferimento.IsAbilitataArchiviazioneOtticaPassivi.GetValueOrDefault(), EtichettatriceArchiviazione = impostazioni.EtichettatriceArchiviazioneOttica, TipoEtichettaArchiviazione = impostazioni.TipoEtichettaArchiviazioneOttica } : new SpesaInfoDTO { Id = 0, IdentificativoArchiviazione = null, NumeroProtocollo = 0, StampaEtichettaArchiviazione = false, EtichettatriceArchiviazione = string.Empty, TipoEtichettaArchiviazione = "Testo", Message = message };
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nell'inserimento di una nota di accredito - {0} - idNota:{1} - numeroNota:{2} - fornitore:{3} - esercizio:{4} - descrizione:{5}", ex, Utility.GetMethodDescription(), notaDto.ID, notaDto.NumeroDocumento, notaDto.IdFornitore, notaDto.IdEsercizio, notaDto.Descrizione);
throw;
}
}
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 CreatePagamentiImmediatiBolletta(Spesa spesa, BollettaDTO bolletta, LogTransazione logTransazione)
{
if (bolletta.IdContoPagamento > 0)
{
var scadenze = new List<ScadenzaFatturaDTO>(spesa.Scadenze.Count);
scadenze.AddRange(spesa.Scadenze.Select(scadenza => new ScadenzaFatturaDTO
{
ID = scadenza.ID,
DataPagamentoScadenza = scadenza.Scadenza,
IdContoPagamentoScadenza = bolletta.IdContoPagamento,
IdSottoContoPagamentoScadenza = bolletta.IdSottoContoPagamento,
IdSpesa = spesa.ID,
Importo = scadenza.Importo,
Scadenza = scadenza.Scadenza,
Stato = "I",
StatoScadenza = StatoSpesaEnum.Inserita
}));
return CreatePagamentiImmediati(spesa, scadenze, logTransazione);
}
return string.Empty;
}
