private DisposizioneDTO setDisposizioniDto(Disposizione disposizione)
{
var dto = new DisposizioneDTO {Data = disposizione.Data, Descrizione = disposizione.Descrizione, ID = disposizione.ID};
var azienda = _daoFactory.GetAziendaDao().GetById(disposizione.Azienda.ID, false);
dto.IdAzienda = azienda.ID;
dto.DescrizioneAzienda = azienda.Descrizione;
return dto;
}
/// <summary>
/// Crea un Pagamento valido
/// </summary>
public Pagamento(ScadenzaFattura scadenza, Disposizione disposizione, decimal? importo, DateTime? dataPagamento, TipoPagamentoFatturaEnum tipo)
{
ScadenzaRiferimento = scadenza;
DisposizioneRiferimento = disposizione;
Importo = importo;
Data = dataPagamento;
Tipo = tipo;
if (scadenza != null)
scadenza.Pagamenti.Add(this);
if (disposizione != null)
disposizione.Pagamenti.Add(this);
}
public void SetMovimentiPagamenti(Disposizione disposizione, string tipoConto, LogTransazione logTransazione)
{
try
{
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("PF");
var lista = new Dictionary<Esercizio, TestataMovimentoContabile>(disposizione.Pagamenti.Count);
foreach (var pag in disposizione.Pagamenti)
{
try
{
var numeroRiga = 0;
var esercizioRiferimento = getEsercizioCompetenza(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento, pag.Data.GetValueOrDefault());
if (esercizioRiferimento == null)
{
var ex = new InvalidDataException(string.Format("Non trovato nessun esercizio attivo"));
_log.FatalFormat("Non trovato nessun esercizio attivo - {0} - condominio:{1} - disposizione:{2} - tipoConto:{3}", ex, Utility.GetMethodDescription(), pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, disposizione.ID, tipoConto);
throw ex;
}
var message = IsAllowDataRegistrazione(new List<int> { esercizioRiferimento.CondominioRiferimento.ID }, esercizioRiferimento, pag.Data.GetValueOrDefault());
if (message.Count == 0)
{
// ================================================
// Testata
// ================================================
TestataMovimentoContabile testata;
if (lista.ContainsKey(esercizioRiferimento))
testata = lista[esercizioRiferimento];
else
{
testata = new TestataMovimentoContabile(esercizioRiferimento, pag.Data, TipoTestataMovimentoContabileEnum.Automatica, logTransazione);
if(logTransazione == null)
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
// Per ora ritengo opportuno avere una testata di movimento contabile distinta per ogni pagamento.
// Per avere un testata che accorpi diversi pagamenti è sufficiente scommentare la riga successiva.
//lista.Add(esercizioRiferimento, testata);
}
// ================================================
// Debiti VS Fornitori
// ------------------------------------------------
// Se è già presente un movimento contabile legato alla ritenute
// vuol dire che il pagamento stato annullato.
// In questo caso il movimento di ritenuta non deve essere generato
// ================================================
numeroRiga++;
var importoFornitori = pag.Importo.GetValueOrDefault();
if (pag.RitenutaAcconto != null && pag.RitenutaAcconto.MovimentoContabileCreazione == null)
importoFornitori += pag.RitenutaAcconto.Importo.GetValueOrDefault();
var movimentoPatrimoniale = new MovimentoContabile(testata, pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.ID, pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoFornitori()), importoFornitori, "D")
{
Descrizione = string.Format("Pagamento Fatt. n.{0} del {1:d}", pag.ScadenzaRiferimento.SpesaRiferimento.NumeroDocumento, pag.ScadenzaRiferimento.SpesaRiferimento.DataDocumento.GetValueOrDefault())
};
if(logTransazione == null)
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);
// ================================================
// Ritenuta
// ================================================
decimal importoRitenuta = 0;
if (pag.ScadenzaRiferimento.SpesaRiferimento.Detrazione.GetValueOrDefault() == 0 && pag.RitenutaAcconto != null && pag.RitenutaAcconto.MovimentoContabileCreazione == null && pag.RitenutaAcconto.Importo != null && pag.RitenutaAcconto.Importo.GetValueOrDefault() != 0)
{
numeroRiga++;
var segnoRitenuta = "A";
importoRitenuta = pag.RitenutaAcconto.Importo.GetValueOrDefault();
if (pag.RitenutaAcconto.Importo.GetValueOrDefault() < 0)
{
segnoRitenuta = "D";
importoRitenuta = importoRitenuta * -1;
}
var movimentoRitenuta = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.ID, pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoRitenuta()), importoRitenuta, segnoRitenuta)
{
FornitoreRiferimento = movimentoPatrimoniale.FornitoreRiferimento
};
if (!string.IsNullOrEmpty(pag.ScadenzaRiferimento.SpesaRiferimento.NumeroDocumento) && pag.ScadenzaRiferimento.SpesaRiferimento.DataDocumento != null)
movimentoRitenuta.Descrizione = "Ritenuta Fatt. n." + pag.ScadenzaRiferimento.SpesaRiferimento.NumeroDocumento + " del " + pag.ScadenzaRiferimento.SpesaRiferimento.DataDocumento.Value.ToShortDateString();
pag.RitenutaAcconto.MovimentoContabileCreazione = movimentoRitenuta;
if(logTransazione == null)
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoRitenuta);
}
// ================================================
// Conto Patrimoniale
// ================================================
numeroRiga++;
if (pag.Conto == null)
{
switch (tipoConto)
{
case "B":
pag.Conto = _daoFactory.GetContoDao().GetByCodice(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.ID, pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoBancario());
break;
case "C":
pag.Conto = _daoFactory.GetContoDao().GetByCodice(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.ID, pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, "903");
break;
}
}
var segnoPagamento = "A";
var importoPagamento = importoFornitori - importoRitenuta;
if (importoPagamento < 0)
{
segnoPagamento = "D";
importoPagamento = importoPagamento * -1;
// Inverto segno e importo anche per il movimento di Debiti v/Fornitori
movimentoPatrimoniale.Segno = invertiSegno("D");
movimentoPatrimoniale.Importo = importoFornitori * -1;
}
var movimentoBancario = new MovimentoContabile(testata, causale, numeroRiga, pag.Conto, importoPagamento, segnoPagamento)
{
Descrizione = movimentoPatrimoniale.GetDescrizione(),
NumeroAssegno = pag.NumeroAssegno,
FornitoreRiferimento =
pag.ScadenzaRiferimento.SpesaRiferimento.
FornitoreRiferimento,
SottoContoRiferimento = pag.SottoConto,
ContoCorrenteBancario = pag.ContoCorrenteBancario
};
pag.MovimentoContabile = movimentoBancario;
if (logTransazione == null)
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoBancario);
}
else
{
var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", pag.Data.GetValueOrDefault()));
_log.FatalFormat("Data di registrazione non valida - {0} - data:{1} - pagamento:{2} - disposizione:{3} - tipoConto:{4} - esercizio:{5}", ex, Utility.GetMethodDescription(), pag.Data.GetValueOrDefault(), pag.ID, disposizione.ID, tipoConto, esercizioRiferimento.ID);
throw ex;
}
}
catch (Exception ex)
{
_log.FatalFormat("Errore inaspettato durante la scrittura dei movimenti per pagamenti - (SINGOLO PAGAMENTO) - {0} - pagamento:{1} - disposizione:{2}", ex, Utility.GetMethodDescription(), pag.ID, disposizione.ID);
throw;
}
}
}
catch (Exception ex)
{
_log.FatalFormat("Errore inaspettato durante la scrittura dei movimenti per pagamenti - {0} - disposizione:{1}", ex, Utility.GetMethodDescription(), disposizione.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;
}
}
/*
private decimal getImportoDataPagare(ScadenzaFattura scadenza)
{
decimal importo = scadenza.SpesaRiferimento.ImportoLordo - scadenza.SpesaRiferimento.ImportoRitenuta.GetValueOrDefault() + scadenza.SpesaRiferimento.AltreSpeseEsenti.GetValueOrDefault();
return scadenza.Pagamenti.Aggregate(importo, (current, pagamento) => current - pagamento.Importo.GetValueOrDefault());
}
*/
public ResultPagamento CreatePagamenti(IList<DisposizionePagamentoDTO> lista, string descrizione, TipoPagamentoFatturaEnum tipo, bool invio, string tipoConto, int? idModello, bool testataPerCondominio, bool mittenteCondominio, int idAzienda)
{
// ================================
// Controllo Pagamenti
// ================================
var message = string.Empty;
foreach (var dto in lista)
{
var scadenza = _daoFactory.GetScadenzaFatturaDao().Find(dto.IdScadenza.GetValueOrDefault(), false);
if (scadenza != null)
{
decimal importoRitenutaDaPagare = 0;
if (scadenza.SpesaRiferimento.Detrazione > 0)
importoRitenutaDaPagare = scadenza.ImportoRitenuta.GetValueOrDefault();
if (dto.ImportoPagamento > (scadenza.Importo.GetValueOrDefault() + importoRitenutaDaPagare) - scadenza.ImportoPagato)
message += string.Format("Per la spesa: {0} l'importo del pagamento è superiore al residuo da pagare", _archiviazioneOtticaService.GetIdentificativoArchiviazione(scadenza.SpesaRiferimento));
}
}
// ================================
// Esecuzione Pagamenti
// ================================
if (string.IsNullOrEmpty(message))
{
DateTime? dataDisposizione = DateTime.Today;
var tipoDataPagamento = DataPagamentoEnum.Today;
if (tipo == TipoPagamentoFatturaEnum.Manuale)
{
tipoDataPagamento = DataPagamentoEnum.Custom;
if (lista.Count > 0)
dataDisposizione = lista[0].DataPagamento;
}
var disposizione = new Disposizione(descrizione, dataDisposizione, _daoFactory.GetAziendaDao().GetById(idAzienda, false), null);
_daoFactory.GetDisposizioneDao().SaveOrUpdate(disposizione);
createPagamenti(disposizione, lista, StatoSpesaEnum.Pagata, tipoDataPagamento, tipo, null);
var result = new ResultPagamento(null, new DocumentInfo(), null);
if (invio)
result = _esecuzionePagamento.EsecuzionePagamenti(disposizione, false, idModello, testataPerCondominio, mittenteCondominio);
if ((result.DocumentInfo.Body != null && string.IsNullOrEmpty(result.Message)) || !_esecuzionePagamento.IsNecessaryFile || !invio)
{
_movimentiContabilitaService.SetMovimentiPagamenti(disposizione, tipoConto, null);
return result;
}
_persistenceContext.RollbackAndCloseSession(Security.Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Security.Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new ResultPagamento(result.Message, new DocumentInfo(), null);
}
_persistenceContext.RollbackAndCloseSession(Security.Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Security.Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new ResultPagamento(message, new DocumentInfo(), null);
}
private void createPagamenti(Disposizione disposizione, IList<DisposizionePagamentoDTO> lista, StatoSpesaEnum stato, DataPagamentoEnum tipoDataPagamento, TipoPagamentoFatturaEnum tipo, IList<ScadenzaFattura> scadenze)
{
try
{
var index = 0;
foreach (var disposizionePagamento in lista)
{
DateTime? dataPagamento = null;
try
{
if (disposizionePagamento.ImportoPagamento > 0 || disposizionePagamento.ImportoAutorizzato > 0)
{
var scadenza = _daoFactory.GetScadenzaFatturaDao().Find(disposizionePagamento.IdScadenza.Value, false);
if (scadenza == null && scadenze != null && lista.Count == scadenze.Count)
scadenza = scadenze[index];
scadenza.ImportoAutorizzato = disposizionePagamento.ImportoAutorizzato;
if (disposizionePagamento.PagamentoCompletoRitenuta)
scadenza.PagamentoCompletoRitenuta = true;
var importoRitenutaResiduo = scadenza.GetImportoRitenutaResiduo();
// Calcolo la data di pagamento
switch (tipoDataPagamento)
{
case DataPagamentoEnum.Today:
dataPagamento = DateTime.Today;
break;
case DataPagamentoEnum.Scadenza:
dataPagamento = disposizionePagamento.DataScadenza;
break;
case DataPagamentoEnum.Custom:
dataPagamento = disposizionePagamento.DataPagamento;
break;
case DataPagamentoEnum.Undefined:
dataPagamento = null;
break;
default:
dataPagamento = DateTime.Today;
break;
}
var pag = _daoFactory.GetPagamentoDao().Find(disposizionePagamento.IdPagamento.GetValueOrDefault(), false) ?? new Pagamento(scadenza, disposizione, disposizionePagamento.ImportoAutorizzato, dataPagamento, tipo);
// ==============================================================================================
// Se non viene pagato completamente l'importo autorizzato creo un nuovo pagamento e sottraggo
// dell'importo del pagamento originale l'importo pagato
// ==============================================================================================
Pagamento pagToUpdate;
if (tipo != TipoPagamentoFatturaEnum.Undefined && tipo != TipoPagamentoFatturaEnum.Immediato && pag.Importo > disposizionePagamento.ImportoPagamento)
{
pag.Importo = pag.Importo - disposizionePagamento.ImportoPagamento;
pagToUpdate = new Pagamento(scadenza, disposizione, disposizionePagamento.ImportoPagamento, dataPagamento, tipo);
}
else
pagToUpdate = pag;
pagToUpdate.Tipo = tipo;
pagToUpdate.Data = dataPagamento;
if (disposizione != null)
{
disposizione.Pagamenti.Add(pagToUpdate);
pagToUpdate.DisposizioneRiferimento = disposizione;
}
pagToUpdate.Stato = stato;
pagToUpdate.Valuta = disposizionePagamento.Valuta;
// La ritenuta solo se NON di tratta di una spesa con detrazione
decimal? importoRitenuta = 0;
if (scadenza.SpesaRiferimento.Detrazione.GetValueOrDefault() == 0)
{
// L'importo della ritenuta se richiesto dall'utente corrisponde all'intero importo se è il primo pagamento
if (!scadenza.PagamentoCompletoRitenuta)
importoRitenuta = Common.ContabilitaHelper.GetImportoRitenuta(scadenza.SpesaRiferimento, disposizionePagamento.ImportoPagamento);
else
importoRitenuta = scadenza.Pagamenti.Count == 1 ? scadenza.ImportoRitenuta : importoRitenutaResiduo;
}
pagToUpdate.RitenutaAcconto = new Ritenuta(importoRitenuta);
pagToUpdate.NumeroAssegno = disposizionePagamento.NumeroAssegno;
if (disposizionePagamento.IdModalitaPagamento > 0)
pagToUpdate.ModalitaPagamento = _daoFactory.GetModalitaPagamentoDao().GetById(disposizionePagamento.IdModalitaPagamento.Value, false);
if (disposizionePagamento.IdConto != null)
{
var conto = _daoFactory.GetContoDao().Find(disposizionePagamento.IdConto.Value, false);
if (conto != null)
pagToUpdate.Conto = conto;
else
{
_log.WarnFormat("ATTENZIONE: Non trovato conto corrente bancario - {0} - conto:{1}", Utility.GetMethodDescription(), disposizionePagamento.IdConto.GetValueOrDefault());
pagToUpdate.Conto = getDefaultContoPagamento(scadenza.SpesaRiferimento.EsercizioRiferimento);
}
}
if (disposizionePagamento.IdSottoConto != null)
{
if (disposizionePagamento.IdSottoConto > 0)
{
var sottoconto = _daoFactory.GetSottoContoDao().Find(disposizionePagamento.IdSottoConto.Value, false);
if (sottoconto != null)
{
_log.WarnFormat("ATTENZIONE: Non trovato conto corrente bancario - {0} - sottoconto:{1}", Utility.GetMethodDescription(), disposizionePagamento.IdSottoConto.GetValueOrDefault());
pagToUpdate.SottoConto = sottoconto;
}
}
else if (disposizionePagamento.IdSottoConto < 0)
{
var contocorrente = _daoFactory.GetDatiBancariCondominiDao().Find(disposizionePagamento.IdSottoConto.Value * -1, false);
if (contocorrente != null)
pagToUpdate.ContoCorrenteBancario = contocorrente;
else
{
_log.WarnFormat("ATTENZIONE: Non trovato conto corrente bancario - {0} - idContoCorrente:{1}", Utility.GetMethodDescription(), disposizionePagamento.IdSottoConto.GetValueOrDefault());
pagToUpdate.ContoCorrenteBancario = scadenza.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.DatiBancariPrincipale;
}
}
}
// Aggiorno dati scadenza
scadenza.Stato = stato;
if (stato == StatoSpesaEnum.Pagata)
{
scadenza.ImportoAutorizzato -= disposizionePagamento.ImportoPagamento;
pagToUpdate.Importo = disposizionePagamento.ImportoPagamento;
if (scadenza.Importo > scadenza.ImportoPagato)
scadenza.Stato = StatoSpesaEnum.ParzialmentePagata;
}
scadenza.SpesaRiferimento.SetStato();
// Eseguo il pagamento anche della ritenuta
var contoRitenuta = _daoFactory.GetContoDao().GetByCodice(scadenza.SpesaRiferimento.EsercizioRiferimento.ID, scadenza.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoBancario());
if (disposizionePagamento.DataPagamentoRitenuta != null && pagToUpdate.RitenutaAcconto != null && pagToUpdate.RitenutaAcconto.Importo != 0)
{
int? idSottoconto = null;
if (pagToUpdate.ContoCorrenteBancario != null)
idSottoconto = pagToUpdate.ContoCorrenteBancario.ID * -1;
if (Conversione.IsSqlSmallDateTime(disposizionePagamento.DataPagamentoRitenuta.GetValueOrDefault()))
_ritenutaAccontoService.PagamentoRitenuta(pagToUpdate, disposizionePagamento.DataPagamentoRitenuta.Value, contoRitenuta, idSottoconto, disposizione.Descrizione, null, null, null);
else
{
_log.WarnFormat("La data di pagamento della ritenuta non è corretta - {0} - dataPagamento:{1:d} - conto:{2} - dataPagamentoRitenuta:{3:d} - descrizione:{4}", Utility.GetMethodDescription(), disposizionePagamento.DataPagamentoRitenuta, contoRitenuta.ID, dataPagamento, disposizione.Descrizione);
}
}
}
index++;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella creazione dei pagamenti immediati - SINGOLA DISPOSIZIONE - {0} - condominio:{1} - dataPagamento:{2} - tipoDataPagamento:{3} - data:{4:d} - documento:{5} - dataDocumento:{6:d}", ex, Utility.GetMethodDescription(), disposizionePagamento.Condominio, dataPagamento, tipoDataPagamento, disposizionePagamento.DataScadenza, disposizionePagamento.NumeroDocumento, disposizionePagamento.DataDocumento);
throw;
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella creazione dei pagamenti immediati - {0} - disposizione:{1} - data:{2:d} - descrizione:{3} - azienda:{4}", ex, Utility.GetMethodDescription(), disposizione.ID, disposizione.Data, disposizione.Descrizione, disposizione.Azienda.ID);
throw;
}
}
public string StornoNoteAccredito(int idNota, IList<StornoScadenzaDTO> scadenze, DettaglioSpesa dettaglioSpesa, Esercizio esercizio, DateTime dataRegistrazione)
{
try
{
var message = string.Empty;
var nota = _daoFactory.GetSpesaDao().GetById(idNota, false);
Disposizione disposizione = null;
if (nota.Riscossioni.Count > 0)
{
var riscossione = IesiGenericCollections<Riscossione>.GetByIndex(nota.Riscossioni, 0);
if (riscossione.Pagamenti.Count > 0)
disposizione = IesiGenericCollections<Pagamento>.GetByIndex(riscossione.Pagamenti, 0).DisposizioneRiferimento;
}
if (disposizione == null)
{
disposizione = new Disposizione($"Storno da nota accredito n.{nota.NumeroDocumento} del:{nota.DataDocumento.GetValueOrDefault():d}", dataRegistrazione, nota.EsercizioRiferimento.CondominioRiferimento.Azienda, null);
_daoFactory.GetDisposizioneDao().SaveOrUpdate(disposizione);
}
//==============================================================
// Controlli
//==============================================================
IList<ScadenzaFattura> scadenzeFattura = new List<ScadenzaFattura>();
foreach (var scadenzaImporto in scadenze)
{
var scadenza = _daoFactory.GetScadenzaFatturaDao().GetById(scadenzaImporto.Id, false);
scadenzeFattura.Add(scadenza);
if (scadenza.Stato != StatoSpesaEnum.Pagata && scadenza.Stato != StatoSpesaEnum.ParzialmentePagata && scadenzaImporto.Importo > scadenza.Importo.GetValueOrDefault() - scadenza.ImportoPagato)
message += $"L'importo {scadenzaImporto.Importo:c} è superiore al residuo da pagare: {(scadenza.Importo.GetValueOrDefault() - scadenza.ImportoPagato):c}{Environment.NewLine}";
}
//==============================================================
// Verifico se devo impostare automaticamente la detrazione
//==============================================================
try
{
if (scadenzeFattura.All(item => item.SpesaRiferimento.Detrazione.GetValueOrDefault() == 36))
nota.Detrazione = 36;
else if (scadenzeFattura.All(item => item.SpesaRiferimento.Detrazione.GetValueOrDefault() == 55))
nota.Detrazione = 55;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella impostazione automatica della detrazione per una nota di accredito - {0} - idNota:{1}", ex, Utility.GetMethodDescription(), idNota);
}
//==============================================================
// Cancellazione riscossioni esistenti
//==============================================================
IList<Riscossione> riscossioni = nota.Riscossioni.ToList();
nota.Riscossioni.Clear();
nota.TestateMovimenti.Clear();
var movimentiToDelete = new List<int>();
foreach (var riscossione in riscossioni)
{
riscossione.ScadenzaRiferimento = null;
riscossione.SpesaRiferimento = null;
// Memorizzazione dei movimenti da cancellare, la cancellazione NON viene eseguita ora
// per evitare problemi nella successione degli script eseguiti sul database da NHibernate
if (riscossione.MovimentoContabile != null)
movimentiToDelete.Add(riscossione.MovimentoContabile.ID);
riscossione.MovimentoContabile = null;
riscossione.Pagamenti.Clear();
_daoFactory.GetRiscossioneDao().Delete(riscossione);
}
IList<Pagamento> pagamenti = disposizione.Pagamenti.ToList();
disposizione.Pagamenti.Clear();
foreach (var pagamento in pagamenti)
{
pagamento.DisposizioneRiferimento = null;
if (pagamento.ScadenzaRiferimento != null)
pagamento.ScadenzaRiferimento.Pagamenti.Remove(pagamento);
pagamento.ScadenzaRiferimento = null;
if (pagamento.NotaStorno != null)
pagamento.NotaStorno.Pagamenti.Remove(pagamento);
pagamento.NotaStorno = null;
pagamento.File = null;
pagamento.MovimentoContabile = null;
pagamento.MovimentoContabileStorno = null;
_daoFactory.GetPagamentoDao().Delete(pagamento);
}
//==============================================================
// Esecuzione
//==============================================================
if (string.IsNullOrEmpty(message))
{
foreach (var scadenzaImporto in scadenze)
{
var scadenza = _daoFactory.GetScadenzaFatturaDao().GetById(scadenzaImporto.Id, false);
var pagamento = new Pagamento(scadenza, disposizione, scadenzaImporto.Importo, dataRegistrazione, TipoPagamentoFatturaEnum.Storno)
{
RitenutaAcconto = new Ritenuta(scadenzaImporto.ImportoRitenuta) { Stato = StatoRitenutaEnum.Stornata },
Stato = StatoSpesaEnum.Pagata
};
_daoFactory.GetPagamentoDao().SaveOrUpdate(pagamento);
var riscossione = new Riscossione(nota, scadenzaImporto.Importo);
_daoFactory.GetRiscossioneDao().SaveOrUpdate(riscossione);
riscossione.ImportoRitenuta = (scadenza.ImportoRitenuta * scadenzaImporto.Importo) / scadenza.Importo;
riscossione.DataRitenuta = dataRegistrazione;
riscossione.Pagamenti.Add(pagamento);
riscossione.ScadenzaRiferimento = scadenza;
pagamento.NotaStorno = riscossione;
riscossione.MovimentoContabile = _movimentiContabilitaService.SetMovimentiStornoScadenza(dettaglioSpesa, scadenza, scadenzaImporto.Importo + scadenzaImporto.ImportoRitenuta, esercizio, dataRegistrazione);
riscossione.MovimentoContabile.Testata.SpesaRiferimento = nota;
nota.TestateMovimenti.Add(riscossione.MovimentoContabile.Testata);
scadenza.SetStato();
if (scadenza.Stato == StatoSpesaEnum.Pagata)
scadenza.Stato = StatoSpesaEnum.Stornata;
}
// Cancellazione dei movimenti precedentemente individuati, la cancellazione viene eseguita solo ora
// per evitare problemi nella successione degli script eseguiti sul database da NHibernate
foreach (var idMovimentoContabile in movimentiToDelete)
_movimentiContabilitaService.DeleteMovimento(idMovimentoContabile);
}
return message;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nello storno di una fattura - {0} - idNota:{1}", ex, Utility.GetMethodDescription(), idNota);
throw;
}
}
public ResultPagamento EsecuzionePagamenti(Disposizione disposizione, bool accorpate, int? idModello, bool testataPerCondominio, bool mittenteCondominio)
{
_disposizione = disposizione;
byte[] bytes = null;
var message = string.Empty;
StreamWriter sw = null;
try
{
message = IsAllowPagamento(disposizione.Pagamenti.Select(item => item.ScadenzaRiferimento.ID).ToList(), true);
if (string.IsNullOrEmpty(message))
{
// =============================================================================================
// Divido le disposizione per Condominio (Codice SIA) se è previsto l'accorpamento ......
// ..... altrimenti creo un blocco di testata-piede per ogni singolo pagamento
//
// Azienda Mittente --> Condominio
// Ricevente --> Banca del Condominio (ordinante)
// Destinatario --> Banca del Fornitore (beneficiario)
//
// Se è previsto di NON dividere i blocchi di righe per condominio (testataPerCondominio == false)
// nel file sarà presente una sola riga di testata e una sola riga di piede, in questo caso
// i dati bancari presenti in testata saranno quelli dello Studio (Azienda)
// =============================================================================================
var pagamenti = new Dictionary<string, List<Pagamento>>();
foreach (var pag in disposizione.Pagamenti)
{
List<Pagamento> listaPagamenti;
var condominio = pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento;
var contoCorrente = pag.ContoCorrenteBancario ?? condominio.DatiBancariPrincipale;
var key = string.Empty;
if (testataPerCondominio)
{
if (accorpate)
key = disposizione.ID + "&" + condominio.CodiceSIA + "&" + contoCorrente.Abi;
else
key = pag.ID.ToString();
}
if (pagamenti.ContainsKey(key))
listaPagamenti = pagamenti[key];
else
{
listaPagamenti = new List<Pagamento>();
pagamenti.Add(key, listaPagamenti);
}
listaPagamenti.Add(pag);
}
var fileName = Path.GetTempPath() + "\\" + Guid.NewGuid();
if (File.Exists(fileName))
File.Delete(fileName);
// =============================================================================================
// Creo un blocco di testata/piede per ogni condominio (Codice SIA)
// =============================================================================================
using (sw = File.CreateText(fileName))
{
foreach (var key in pagamenti.Keys)
{
try
{
var numeroDisposizione = 0;
decimal importoTotale = 0;
var numeroRighe = 1;
string codiceSia;
string codiceAbi;
var cond = pagamenti[key][0].ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento;
if (testataPerCondominio)
{
codiceSia = cond.CodiceSIA;
codiceAbi = cond.DatiBancariPrincipale.Abi;
}
else
{
codiceSia = cond.Azienda.CodiceSIA;
codiceAbi = cond.Azienda.BancaRiferimentoRitenuta.ID.Abi;
}
writeTestataPC(codiceSia, codiceAbi, key, sw);
foreach (var pag in pagamenti[key])
{
try
{
importoTotale += pag.Importo.GetValueOrDefault();
numeroDisposizione++;
numeroRighe++;
writeMovimento10(pag, sw, numeroDisposizione);
numeroRighe++;
writeMovimento16(pag, sw, numeroDisposizione);
numeroRighe++;
writeMovimento17(pag, sw, numeroDisposizione);
numeroRighe++;
writeMovimento20(pag, sw, numeroDisposizione, mittenteCondominio);
numeroRighe++;
writeMovimento30(pag, sw, numeroDisposizione);
numeroRighe++;
writeMovimento50(pag, sw, numeroDisposizione);
numeroRighe++;
writeMovimento70(pag, sw, numeroDisposizione);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la creazione del file CBI dei bonifici - SINGOLO PAGAMENTO - {0} - key:{1} - pag:{2}", ex, Library.Utility.GetMethodDescription(), key, pag.ID);
throw;
}
}
numeroRighe++;
writeCodaEF(cond.CodiceSIA, cond.DatiBancariPrincipale.Abi, key, sw, numeroDisposizione, importoTotale, numeroRighe);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la creazione del file CBI dei bonifici - {0} - key:{1}", ex, Library.Utility.GetMethodDescription(), key);
throw;
}
}
}
var infile = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read);
bytes = new byte[infile.Length];
infile.Read(bytes, 0, bytes.Length);
disposizione.ContenutoFile = Library.Conversione.ToString(bytes);
}
return new ResultPagamento(message, new DocumentInfo { Body = bytes, FileName = ContabilitaHelper.GetFileName("Pagamenti", null), FileExtension = ".txt" }, null);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la creazione del file CBI dei bonifici - {0} - modello:{1} - disposizione:{2} - azienda:{3}", ex, Library.Utility.GetMethodDescription(), idModello, disposizione.ID, disposizione.Azienda.ID);
message = "Si sono verificati problemi inaspettati durante la creazione del file CBI dei bonifici." + Environment.NewLine + "Controllare il log per ulteriori dettagli.";
return new ResultPagamento(message, new DocumentInfo { Body = bytes }, null);
}
finally
{
if (sw != null)
{
sw.Close();
sw.Dispose();
}
}
}
/// <summary>
/// Crea il file per la disposizione dei bonifici in formato SEPA SCT
/// Nel caso in cui siano presenti più debitori (Condomini) viene creato un file zip contenente tutte le disposizioni di bonifico
/// </summary>
/// <param name="disposizione">Oggetto contenente tutti i metadati dei bonifici</param>
/// <param name="accorpate">Usato solo per i bonifici CBI</param>
/// <param name="idModello">Usato solo per i pagamenti manuali</param>
/// <param name="testataPerCondominio">Usato solo per i bonifici CBI</param>
/// <param name="mittenteCondominio">Usato solo per i bonifici CBI</param>
/// <returns></returns>
public ResultPagamento EsecuzionePagamenti(Disposizione disposizione, bool accorpate, int? idModello, bool testataPerCondominio, bool mittenteCondominio)
{
string message;
try
{
var documentInfo = new DocumentInfo();
message = IsAllowPagamento(disposizione.Pagamenti.Select(item => item.ScadenzaRiferimento.ID).ToList(), true);
if (string.IsNullOrEmpty(message))
{
var pagamenti = disposizione.Pagamenti.GroupBy(item => item.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento).ToList();
var stream = new MemoryStream();
ZipFile zipFile = null;
var singleFileName = string.Empty;
if (pagamenti.Count > 1)
zipFile = new ZipFile();
foreach (var pagamentiGroupByCondominio in pagamenti)
{
try
{
var sepa = new CBIPaymentRequest000400
{
PaymentInfo = getPaymentInfo(pagamentiGroupByCondominio.Key, pagamentiGroupByCondominio.ToList()),
GroupHeader = getGroupHeader(pagamentiGroupByCondominio.ToList(), pagamentiGroupByCondominio.Key)
};
var envelop = new CBIBdyPaymentRequest000400 { CBIEnvelPaymentRequest = { CBIPaymentRequest = sepa } };
var streamContent = Library.XML.SerializerHelper<CBIBdyPaymentRequest000400>.Serialize(envelop, new List<string> { "urn:CBI:xsd:CBIBdyPaymentRequest.00.04.00", "urn:CBI:xsd:CBIPaymentRequest.00.04.00" });
var fileName = ContabilitaHelper.GetFileName("Pagamenti", pagamentiGroupByCondominio.Key);
if (zipFile != null)
{
streamContent.Seek(0, SeekOrigin.Begin);
zipFile.AddEntry($"{fileName}.xml", streamContent);
}
else
{
stream = (MemoryStream)streamContent;
singleFileName = fileName;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la creazione del file CBI dei bonifici - SINGOLO CONDOMINIO - {0} - condominio:{1} - modello:{2} - disposizione:{3} - azienda:{4}", ex, Library.Utility.GetMethodDescription(), pagamentiGroupByCondominio.Key.ID, idModello, disposizione.ID, disposizione.Azienda.ID);
throw;
}
}
if (zipFile != null)
{
documentInfo.FileName = ContabilitaHelper.GetFileName("Pagamenti", null);
documentInfo.FileExtension = ".zip";
zipFile.Save(stream);
var documentMessages = _documentService.SaveDocument(stream.ToArray(), documentInfo.FileName, documentInfo.FileExtension, null, disposizione.Azienda.ID);
var documento = new Documento(documentMessages.Documento.Checksum, documentInfo.FileName, documentInfo.FileExtension, "DisposizioneBonifico", false, disposizione.Azienda);
_daoFactory.GetDocumentoDao().Save(documento);
disposizione.Documento = documento;
documentInfo.Body = stream.ToArray();
zipFile.Dispose();
}
else
{
documentInfo.Body = stream.ToArray();
documentInfo.FileName = singleFileName;
documentInfo.FileExtension = ".xml";
disposizione.ContenutoFile = Library.Conversione.ToString(documentInfo.Body);
}
stream.Close();
stream.Dispose();
}
return new ResultPagamento(message, documentInfo, null);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la creazione del file CBI dei bonifici - {0} - modello:{1} - disposizione:{2} - azienda:{3}", ex, Library.Utility.GetMethodDescription(), idModello, disposizione.ID, disposizione.Azienda.ID);
message = "Si sono verificati problemi inaspettati durante la creazione del file CBI dei bonifici." + Environment.NewLine + "Controllare il log per ulteriori dettagli.";
return new ResultPagamento(message, new DocumentInfo(), null);
}
}
public ResultPagamento EsecuzionePagamenti(Disposizione disposizione, bool accorpamento, int? idModelloLettera, bool testataPerCondominio, bool mittenteCondominio)
{
IList<ReportPagamentoDTO> pagamenti = new List<ReportPagamentoDTO>();
var message = string.Empty;
try
{
foreach (var pag in disposizione.Pagamenti)
{
try
{
var coordinateBancarieCondominio = pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.DatiBancariPrincipale;
if (coordinateBancarieCondominio != null)
{
var abiCab = _daoFactory.GetAbiCabDao().GetById(new AbiCabId(coordinateBancarieCondominio.Abi, coordinateBancarieCondominio.Cab), false);
var condominio = pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento;
var fornitore = pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento;
var oggetto = "RICHIESTA DI BONIFICO AI SENSI DELLA LEGGE FINANZIARIA 1998 ART.1 AGEVOLAZIONI FISCALI SU INTERVENTI DI RECUPERO DEL PATRIMONIO EDILIZIO";
if(idModelloLettera != null)
{
var modello = _daoFactory.GetModelloLetteraTestoDao().Find(idModelloLettera.Value, false);
if (modello != null)
oggetto = modello.Oggetto;
}
var reportPagamento = new ReportPagamentoDTO
{
IdPagamento = pag.ID,
NomeBanca = abiCab.DescrizioneAbi + " - " + abiCab.DescrizioneCab,
OggettoLettera = oggetto
};
if (pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.Azienda.IndirizzoSede?.Comune != null)
reportPagamento.LuogoPagamento = pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.Azienda.IndirizzoSede.Comune.Descrizione;
// Condominio
reportPagamento.DescrizioneCondominio = condominio.Descrizione;
if (condominio.Indirizzo != null)
{
reportPagamento.IndirizzoCondominio = condominio.Indirizzo.Indirizzo + " " + condominio.Indirizzo.Civico;
reportPagamento.CapCondominio = condominio.Indirizzo.Cap;
if (condominio.Indirizzo.Comune != null)
reportPagamento.ComuneCondominio = condominio.Indirizzo.Comune.Descrizione + " " + condominio.Indirizzo.Comune.ProvinciaAppartenenza.Codice;
}
reportPagamento.CodiceFiscaleCondominio = condominio.CodiceFiscale;
reportPagamento.ContoCorrenteCondominio = coordinateBancarieCondominio.ContoCorrente;
if(condominio.Azienda.Amministratore?.PersonaRiferimento != null)
reportPagamento.CodiceFiscaleAmministratore = condominio.Azienda.Amministratore.PersonaRiferimento.CodiceFiscale;
else
{
_log.WarnFormat("ATTENZIONE: Non è definito l'amministratore dell'azienda - {0} - azienda:{1}", Library.Utility.GetMethodDescription(), condominio.Azienda.ID);
}
// Beneficiario
reportPagamento.RagioneSocialeBeneficiario = fornitore.DisplayName;
if (fornitore.PersonaRiferimento.IndirizzoResidenza != null)
{
reportPagamento.IndirizzoBeneficiario = fornitore.PersonaRiferimento.IndirizzoResidenza.Indirizzo + " " + fornitore.PersonaRiferimento.IndirizzoResidenza.Civico;
reportPagamento.CapBeneficiario = fornitore.PersonaRiferimento.IndirizzoResidenza.Cap;
if (fornitore.PersonaRiferimento.IndirizzoResidenza.Comune != null)
reportPagamento.ComuneBeneficiario = fornitore.PersonaRiferimento.IndirizzoResidenza.Comune.Descrizione;
}
reportPagamento.CodiceFiscaleBeneficiario = fornitore.PersonaRiferimento.CodiceFiscale;
reportPagamento.PartitaIvaBeneficiario = fornitore.PersonaRiferimento.PartitaIva;
reportPagamento.AbiBeneficiario = fornitore.PersonaRiferimento.Abi;
reportPagamento.CabBeneficiario = fornitore.PersonaRiferimento.Cab;
reportPagamento.ContoCorrenteBeneficiario = fornitore.PersonaRiferimento.ContoCorrente;
reportPagamento.CinBeneficiario = fornitore.PersonaRiferimento.Cin;
reportPagamento.IbanBeneficiario = fornitore.PersonaRiferimento.Iban;
// Pagamento
reportPagamento.ImportoPagamento = pag.Importo.GetValueOrDefault();
if (pag.Valuta != null)
reportPagamento.ValutaPagamento = pag.Valuta.GetValueOrDefault();
reportPagamento.NumeroDocumento = pag.ScadenzaRiferimento.SpesaRiferimento.NumeroDocumento;
if (pag.ScadenzaRiferimento.SpesaRiferimento.DataDocumento != null)
reportPagamento.DataDocumento = pag.ScadenzaRiferimento.SpesaRiferimento.DataDocumento.GetValueOrDefault();
reportPagamento.DataPagamento = pag.Data.GetValueOrDefault();
var descrizione = string.Empty;
foreach (var dettaglio in pag.ScadenzaRiferimento.SpesaRiferimento.Dettagli)
{
descrizione = dettaglio.GetDescrizione();
break;
}
reportPagamento.DescrizioneDocumento = descrizione;
reportPagamento.CausaleBeneficiario = $"Sd. Ft.{reportPagamento.NumeroDocumento} del {reportPagamento.DataDocumento.ToShortDateString()} {reportPagamento.DescrizioneDocumento}";
pagamenti.Add(reportPagamento);
}
else
message = "Per il condominio " + pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.DisplayName + " non è definita nessuna banca principale";
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante l'apertura del documento - SINGOLO PAGAMENTO - {0} - pagamento:{1} - documento: /Bonifico_{2:dd-MM-yy}", ex, Library.Utility.GetMethodDescription(), pag.ID, DateTime.Today);
throw;
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante l'apertura del documento - {0} - documento: /Bonifico_{1:dd-MM-yy}", ex, Library.Utility.GetMethodDescription(), DateTime.Today);
}
return new ResultPagamento(message, new DocumentInfo(), pagamenti);
}
public virtual IUpdatableBusinessEntity Copy()
{
var disposizione = new Disposizione("<DA MODIFICARE>", Data, Azienda, null);
return disposizione;
}
