public string PagamentoRitenuta(Pagamento pagamento, DateTime dataPagamento, Conto conto, int? idSottoconto, string descrizione, decimal? importo, decimal? importoInteressi, decimal? importoSanzione)
{
try
{
var anomalie = string.Empty;
if (Conversione.IsSqlSmallDateTime(dataPagamento))
{
if (!string.IsNullOrEmpty(descrizione) && descrizione.Trim().Length > 500)
descrizione = descrizione.Trim().Substring(0, 500);
var pagamentoRitenuta = new PagamentoRitenuta(pagamento.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.Azienda.ID, descrizione, dataPagamento, true, TipoVersamentoF24Enum.Immediato);
pagamentoRitenuta.Pagamenti.Add(pagamento);
_daoFactory.GetPagamentoRitenutaDao().SaveOrUpdate(pagamentoRitenuta);
if (importoInteressi != null)
pagamento.RitenutaAcconto.ImportoInteressi = importoInteressi.Value;
if (importoSanzione != null)
pagamento.RitenutaAcconto.ImportoSanzione = importoSanzione.Value;
pagamento.RitenutaAcconto.Stato = StatoRitenutaEnum.Pagata;
pagamento.RitenutaAcconto.TestataRiferimento = pagamentoRitenuta;
pagamentoRitenuta.TestataContabile = _movimentiContabilitaService.SetMovimentiRitenuta(pagamento, pagamento.RitenutaAcconto, conto, idSottoconto, dataPagamento, descrizione, null, null, importo);
}
else
{
_log.WarnFormat("La data di pagamento della ritenuta non è corretta - {0} - pagamento:{1} - importo:{2} - dataPagamento:{3:d} - conto:{4} - idSottoconto:{5} - descrizione:{6}", Utility.GetMethodDescription(), pagamento.ID, importo, dataPagamento, conto.ID, idSottoconto.GetValueOrDefault(), descrizione);
}
return anomalie;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante l'inserimento pagamento della ritenuta - {0} - pagamento:{1} - importo:{2} - dataPagamento:{3:d} - conto:{4} - idSottoconto:{5} - descrizione:{6}", ex, Utility.GetMethodDescription(), pagamento.ID, importo, dataPagamento, conto.ID, idSottoconto.GetValueOrDefault(), descrizione);
throw;
}
}
private void writeMovimento50(Pagamento pag, StreamWriter sw, int numeroDisposizione)
{
var sb = new StringBuilder(120);
// Tipo Record
sb.Append(" 50");
// Numero Disposizione
sb.Append(numeroDisposizione.ToString(CultureInfo.InvariantCulture).PadLeft(7, '0'));
// --------------------------------------------------------------------
// Descrizione disposizione per fornitore
// --------------------------------------------------------------------
// 1° segmento (numero fattura 24ch + data fattura GGMMAA)
var descrizione = string.Empty;
if(pag.ScadenzaRiferimento.SpesaRiferimento.NumeroDocumento != null)
{
var numeroDocumento = pag.ScadenzaRiferimento.SpesaRiferimento.NumeroDocumento;
if (numeroDocumento.Length > 24)
numeroDocumento = numeroDocumento.Substring(0, 24);
sb.Append(numeroDocumento.PadLeft(24, '0'));
descrizione += "Fatt. nr." + pag.ScadenzaRiferimento.SpesaRiferimento.NumeroDocumento;
}
if (pag.ScadenzaRiferimento.SpesaRiferimento.DataDocumento != null)
{
sb.Append(convertData(pag.ScadenzaRiferimento.SpesaRiferimento.DataDocumento.Value));
descrizione += "del " + pag.ScadenzaRiferimento.SpesaRiferimento.DataDocumento.Value.ToShortDateString();
}
// 2° segmento 3 ° segmento
if (descrizione.Length > 60)
descrizione = descrizione.Substring(0, 60);
sb.Append(descrizione.PadRight(60));
// sb.Append((pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID + "&" + pag.ID).PadLeft(30, ' '));
// filler
sb.Append(string.Empty.PadLeft(20));
sw.WriteLine(sb.ToString());
}
private void writeMovimento70(Pagamento pag, StreamWriter sw, int numeroDisposizione)
{
var sb = new StringBuilder(120);
// Tipo Record
sb.Append(" 70");
// Numero Disposizione
sb.Append(numeroDisposizione.ToString().PadLeft(7, '0'));
// filler
sb.Append(string.Empty.PadLeft(15));
// campo non disponibile
sb.Append(string.Empty.PadLeft(5));
// qualificatore flusso
sb.Append(string.Empty.PadLeft(7));
// codice MP
sb.Append(string.Empty.PadLeft(5));
// filler
sb.Append(string.Empty.PadLeft(27));
// --------------------------------------------------------------------
// Identificazione della disposizione di pagamento
// --------------------------------------------------------------------
// flag richiesta
sb.Append("3");
// Identificativo della disposizione (pagamento)
sb.Append(pag.ID.ToString().PadLeft(30, '0'));
// filler
sb.Append(string.Empty.PadLeft(10));
// CIN fornitore
sb.Append(pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento.PersonaRiferimento.Cin.PadLeft(1, ' '));
// filler
sb.Append(string.Empty.PadLeft(1));
// chiavi di controllo
sb.Append(string.Empty.PadLeft(8));
sw.WriteLine(sb.ToString());
}
public BilancioAperturaMessage SetBilancioApertura(TestataMovimentoContabileGestioneDTO testata)
{
try
{
var fatalMessage = string.Empty;
var warnMessage = string.Empty;
//==============================================
// Controllo esercizio
//==============================================
if (testata.CodiceEsercizio == 0)
{
_log.ErrorFormat("Non è definito alcun esercizio - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage("Non è definito alcun esercizio", string.Empty, false);
}
var esercizio = _daoFactory.GetEsercizioDao().Find(testata.CodiceEsercizio, false);
if(esercizio == null)
{
_log.ErrorFormat("L'esercizio non è stato trovato - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage($"L'esercizio '{testata.CodiceEsercizio}' non è stato trovato.", string.Empty, false);
}
if(esercizio.Gestione == GestioneEsercizioEnum.Straordinario)
{
_log.ErrorFormat("L'esercizio deve essere un esercizio ordinario - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage("L'esercizio deve essere un esercizio ordinario", string.Empty, false);
}
//==============================================
// Controllo Saldi Condomini
//==============================================
var saldiCondomini = _daoFactory.GetSaldoSoggettoDao().GetByEsercizioStabileScala(esercizio, null, null);
var contoCreditiCondomini = _daoFactory.GetContoDao().GetAllByCodice(esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoVersamentiCondomini()).FirstOrDefault(item => item.EsercizioRiferimento == null);
if (contoCreditiCondomini != null)
{
var movimentiVersamentiCondomini = testata.Movimenti.Where(item => item.IdConto == contoCreditiCondomini.ID).ToList();
if (movimentiVersamentiCondomini.Count > 1)
{
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage($"Non può essere presente più di un movimento per il conto {contoCreditiCondomini.Codice} - {contoCreditiCondomini.Descrizione}", string.Empty, false);
}
if (movimentiVersamentiCondomini.Count == 1)
{
var importoCreditiCondomini = movimentiVersamentiCondomini.Sum(item => item.ImportoDare.GetValueOrDefault() - item.ImportoAvere.GetValueOrDefault());
if (importoCreditiCondomini > 0)
{
if (saldiCondomini.Count == 0)
{
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage("Prima di registrare il bilancio di apertura occorre inserire i saldi iniziali dei singoli condomini", string.Empty, true);
}
var totaleSaldiCondomini = saldiCondomini.Sum(item => item.Importo);
if (importoCreditiCondomini != totaleSaldiCondomini)
{
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage($"L'importo del conto crediti v/condomini: {importoCreditiCondomini:c} non corrisponde con la somma dei saldi dei singoli condomini: {totaleSaldiCondomini:c}", string.Empty, true);
}
}
}
}
//==============================================
// Controllo data registrazione
//==============================================
if (testata.DataRegistrazione == null || !Conversione.IsSqlSmallDateTime(testata.DataRegistrazione.GetValueOrDefault()))
{
_log.ErrorFormat("Non è definita la data di registrazione - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage("Non è definita la data di registrazione", string.Empty, false);
}
if(testata.DataRegistrazione.GetValueOrDefault() < esercizio.DataApertura.GetValueOrDefault())
{
_log.DebugFormat("La data di registrazione è inferiore alla data di apertura dell'esercizio - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage("La data di registrazione è inferiore alla data di apertura dell'esercizio", string.Empty, false);
}
//==============================================
// Controllo correttezza importi
//==============================================
if (testata.Movimenti == null)
{
_log.FatalFormat("I movimenti sono a null - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage("I movimenti sono a null", string.Empty, false);
}
if (testata.Movimenti.Sum(mov => mov.ImportoDare.GetValueOrDefault()) != testata.Movimenti.Sum(mov => mov.ImportoAvere.GetValueOrDefault()))
fatalMessage = $"Il totale Dare:{testata.Movimenti.Sum(mov => mov.ImportoDare.GetValueOrDefault()):c} non corrisponde col totale Avere:{testata.Movimenti.Sum(mov => mov.ImportoAvere.GetValueOrDefault()):c}.{Environment.NewLine}";
else
{
var listaDettagli = new Dictionary<int, DettaglioSpesa>();
// ==============================================================================================================
// Se il bilancio di apertura NON è registrato nel primo esercizio occorre registrare solo i movimenti contabili
// ==============================================================================================================
if (IsRequiredDatiFatturaBilancioApertura(esercizio.ID))
{
// ===============================================
// Controllo movimenti
// ===============================================
foreach (var dto in testata.Movimenti)
{
if (dto.Stato == "U")
{
var messageControllo = IsAllowUpdateMovimentoBilancioApertura(dto.ID, dto.IdSpesa);
if (string.IsNullOrEmpty(messageControllo))
{
// ------------------------------------------------------------------------------------
// Se il conto non è Fornitori e Ritenuta devo cancellare l'eventuale spesa associata
// ------------------------------------------------------------------------------------
var conto = _daoFactory.GetContoDao().GetById(dto.IdConto.GetValueOrDefault(), false);
if (conto.Codice == _pianoContiService.GetCodiceContoFornitori() || conto.Codice == _pianoContiService.GetCodiceContoRitenuta())
dto.IdSpesa = 0;
else
{
if (dto.IdSpesa > 0)
{
var messageDeleteSpesa = IsAllowDelete(dto.IdSpesa);
if (!string.IsNullOrEmpty(messageDeleteSpesa.FatalMessage))
return new BilancioAperturaMessage(messageDeleteSpesa.FatalMessage, string.Empty, false);
else
{
var movimento = _daoFactory.GetMovimentoContabileDao().Find(dto.ID, false);
if(movimento != null)
{
movimento.Spesa = null;
movimento.Testata.Movimenti.Remove(movimento);
movimento.Testata = null;
_daoFactory.GetMovimentoContabileDao().Delete(movimento);
}
Delete(dto.IdSpesa);
dto.ID = 0;
dto.IdSpesa = 0;
dto.IdFornitore = 0;
dto.NumeroDocumento = null;
dto.DataDocumento = null;
dto.ImportoFattura = null;
dto.ImportoIva = null;
dto.ImportoRitenuta = null;
dto.InteressiRitenuta = null;
dto.SanzioniRitenuta = null;
dto.AliquotaRitenuta = null;
dto.AltreSpese = null;
dto.AltreSpeseEsenti = null;
dto.DataPagamento = null;
dto.DataVersamentoRitenuta = null;
}
}
}
}
else
{
fatalMessage += messageControllo + Environment.NewLine;
_log.WarnFormat("{0} - {1} - testata:{2}", fatalMessage, Utility.GetMethodDescription(), testata.ID);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage(fatalMessage, string.Empty, false);
}
}
}
var index = 0;
// ===============================================
// Elaborazione di tutti i movimenti
// ===============================================
foreach (var movimento in testata.Movimenti)
{
try
{
if (movimento.Stato == "U")
{
if (movimento.IdConto == null)
{
_log.FatalFormat("I movimenti sono a null - 2 - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage($"Non è presente il conto per la riga:{movimento.NumeroRiga.GetValueOrDefault()}", string.Empty, false);
}
index++;
if (movimento.ID == 0)
movimento.ID = index*-1;
// ----------------------------------------------------------
// Se è presente il fornitore devo gestire la fattura
// ----------------------------------------------------------
var conto = _daoFactory.GetContoDao().GetById(movimento.IdConto.GetValueOrDefault(), false);
if (movimento.IdFornitore > 0 && (conto.Codice == _pianoContiService.GetCodiceContoFornitori() || conto.Codice == _pianoContiService.GetCodiceContoRitenuta()))
{
var fornitore = _daoFactory.GetFornitoreDao().GetById(movimento.IdFornitore.GetValueOrDefault(), false);
// ----------------------------------
// Importi
// ----------------------------------
decimal importo;
decimal? importoRitenuta = null;
try
{
if (movimento.ImportoAvere.GetValueOrDefault() > 0)
{
importo = movimento.ImportoAvere.GetValueOrDefault() - movimento.AltreSpeseEsenti.GetValueOrDefault();
importoRitenuta = movimento.ImportoRitenuta;
}
else
{
importo = (movimento.ImportoDare.GetValueOrDefault() - movimento.AltreSpeseEsenti.GetValueOrDefault()) * -1;
if(movimento.ImportoRitenuta != null)
importoRitenuta = movimento.ImportoRitenuta.GetValueOrDefault()*-1;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - IMPORTI - {0} - idTestata:{1}", ex, Utility.GetMethodDescription(), testata.ID);
throw;
}
// ----------------------------------
// Spesa
// ----------------------------------
GestioneCondomini.Domain.Spesa spesa;
try
{
if (movimento.ID > 0)
{
var mov = _daoFactory.GetMovimentoContabileDao().Find(movimento.ID, false);
if (mov != null)
{
if (mov.Spesa != null)
spesa = mov.Spesa;
else
{
if (mov.DettaglioRiferimento?.SpesaRiferimento == null)
{
var messageSpesa = getNewSpesa(fornitore, esercizio, testata, movimento, out spesa);
if (!string.IsNullOrEmpty(messageSpesa))
{
fatalMessage += messageSpesa + Environment.NewLine;
_log.ErrorFormat("Errore nella generazione della spesa - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage(fatalMessage, string.Empty, false);
}
}
else
spesa = mov.DettaglioRiferimento.SpesaRiferimento;
}
}
else
{
int? idMov = null;
if (mov != null)
idMov = mov.ID;
_log.ErrorFormat("Non è stato trovato il movimento contabile - {0} - id:{1}", Utility.GetMethodDescription(), idMov);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage("Non è stato trovato il movimento contabile", string.Empty, false);
}
if (spesa != null)
spesa.FornitoreRiferimento = fornitore;
}
else
{
spesa = new GestioneCondomini.Domain.Spesa(fornitore, esercizio, null);
try
{
if (_protocolloService == null)
{
_log.ErrorFormat("Errore di inizializzazione del protocollo service - {0} - idEsercizio:{1} - idTestata:{2}", Utility.GetMethodDescription(), testata.CodiceEsercizio, testata.ID);
fatalMessage = "Errore di inizializzazione del protocollo service.";
}
if (movimento.DataDocumento == null)
{
_log.ErrorFormat("La data del documento è null - {0} - documento:{1} - movimento:{2} - esercizio:{3} - testata:{4}", Utility.GetMethodDescription(), movimento.NumeroDocumento, movimento.ID, testata.CodiceEsercizio, testata.ID);
fatalMessage = "La data del documento è null.";
}
if (esercizio.CondominioRiferimento == null)
{
_log.FatalFormat("Il Condominio è null - {0} - documento:{1} - movimento:{2} - esercizio:{3} - testata:{4}", Utility.GetMethodDescription(), movimento.NumeroDocumento, movimento.ID, testata.CodiceEsercizio, testata.ID);
fatalMessage = "Il Condominio è null.";
}
var protocollo = _protocolloService.GetProgressivo(TipoProtocollo.Fattura, esercizio.DataApertura.GetValueOrDefault().Year, esercizio.CondominioRiferimento);
if (protocollo.Progressivo != null)
spesa.NumeroProtocollo = protocollo.Progressivo;
else
return new BilancioAperturaMessage(protocollo.Message, string.Empty, false);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel recuperare il progressivo - {0} - data:{1:d} - condominio:{2} - movimento:{3} - esercizio:{4} - testata:{5}", ex, Utility.GetMethodDescription(), movimento.DataDocumento.GetValueOrDefault(), esercizio.CondominioRiferimento.ID, movimento.ID, testata.CodiceEsercizio, testata.ID);
fatalMessage = "Errore inaspettato nel recuperare il progressivo.";
}
_daoFactory.GetSpesaDao().SaveOrUpdate(spesa);
}
if (spesa != null)
{
spesa.TipoDocumento = "FATBILAPP";
spesa.ImportoRitenuta = importoRitenuta;
spesa.AltreSpeseEsenti = movimento.AltreSpeseEsenti;
spesa.AltreSpese = movimento.AltreSpese;
spesa.IsRitenutaCalcoloImponibile = spesa.FornitoreRiferimento.IsRitenutaCalcolataImponibile;
if(movimento.AliquotaRitenuta != null)
spesa.AliquotaRitenuta = movimento.AliquotaRitenuta.GetValueOrDefault()/100;
else
spesa.AliquotaRitenuta = null;
spesa.NumeroDocumento = movimento.NumeroDocumento;
spesa.DataDocumento = movimento.DataDocumento;
spesa.Stato = conto.Codice == _pianoContiService.GetCodiceContoFornitori() ? StatoSpesaEnum.Inserita : StatoSpesaEnum.Pagata;
movimento.IdSpesa = spesa.ID;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - SPESA - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID);
throw;
}
// ----------------------------------
// Dettaglio Spesa
// ----------------------------------
DettaglioSpesa dettaglio = null;
try
{
if (conto.Codice == _pianoContiService.GetCodiceContoFornitori() || conto.Codice == _pianoContiService.GetCodiceContoRitenuta())
{
if (movimento.ID > 0 && _daoFactory.GetMovimentoContabileDao().GetById(movimento.ID, false).DettaglioRiferimento != null)
dettaglio = _daoFactory.GetMovimentoContabileDao().GetById(movimento.ID, false).DettaglioRiferimento;
else
{
dettaglio = new DettaglioSpesa(spesa, 1);
_daoFactory.GetDettaglioSpesaDao().SaveOrUpdate(dettaglio);
}
dettaglio.Descrizione = movimento.Descrizione;
dettaglio.ImportoLordo = conto.Codice == _pianoContiService.GetCodiceContoFornitori() ? importo - movimento.AltreSpese.GetValueOrDefault() : movimento.ImportoFattura;
dettaglio.ImportoIva = movimento.ImportoIva;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - DETTAGLIO SPESA - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID);
throw;
}
// ------------------------------------------------------
// Scadenza - SOLO se non di tratta di nota di accredito
// ------------------------------------------------------
ScadenzaFattura scadenza = null;
try
{
if (spesa != null && movimento.ImportoDare.GetValueOrDefault() == 0)
{
if (movimento.ID > 0)
scadenza = IesiGenericCollections<ScadenzaFattura>.GetByIndex(spesa.Scadenze, 0);
if (scadenza == null)
{
scadenza = new ScadenzaFattura(spesa, esercizio.DataApertura, importo - spesa.ImportoRitenuta.GetValueOrDefault())
{
Stato = conto.Codice == _pianoContiService.GetCodiceContoFornitori() ? StatoSpesaEnum.Inserita : StatoSpesaEnum.Pagata
};
_daoFactory.GetScadenzaFatturaDao().SaveOrUpdate(scadenza);
}
if (conto.Codice == _pianoContiService.GetCodiceContoFornitori())
{
scadenza.Importo = importo + spesa.AltreSpeseEsenti.GetValueOrDefault() - spesa.ImportoRitenuta.GetValueOrDefault();
scadenza.ImportoRitenuta = spesa.ImportoRitenuta;
if (movimento.DataPagamento != null)
scadenza.Scadenza = movimento.DataPagamento.GetValueOrDefault();
}
else
{
scadenza.Importo = 0;
scadenza.ImportoRitenuta = importoRitenuta;
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - SCADENZA - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID);
throw;
}
// =================================================================================
// RITENUTE
// ----------------------------------
// Pagamento
// ----------------------------------
try
{
// Inserimento pagamento fattura per ritenuta in bilancio di apertura da pagare
if (scadenza != null && conto.Codice == _pianoContiService.GetCodiceContoRitenuta())
{
Pagamento pagamento;
if (scadenza.Pagamenti.Count > 0)
{
pagamento = scadenza.Pagamenti.First();
pagamento.Data = movimento.DataPagamento.GetValueOrDefault();
pagamento.RitenutaAcconto.Importo = scadenza.ImportoRitenuta;
pagamento.RitenutaAcconto.ImportoInteressi = movimento.InteressiRitenuta;
pagamento.RitenutaAcconto.ImportoSanzione = movimento.SanzioniRitenuta;
pagamento.Importo = spesa.ImportoLordo - pagamento.RitenutaAcconto.Importo.GetValueOrDefault();
pagamento.Stato = StatoSpesaEnum.Pagata;
// Se il pagamento è già presente devo annullare la ritenuta eventualmente già versata
// TODO: Verificare se è necessario controllare che non si tratti di un versamento CBI
if (pagamento.RitenutaAcconto != null && pagamento.RitenutaAcconto.TestataRiferimento != null)
{
var messageDeleteRitenuta = _ritenutaService.DeletePagamentoRitenuta(pagamento.RitenutaAcconto.TestataRiferimento.ID);
if (!string.IsNullOrEmpty(messageDeleteRitenuta))
fatalMessage += messageDeleteRitenuta + Environment.NewLine;
}
}
else
{
pagamento = new Pagamento(scadenza, null, spesa.ImportoLordo, movimento.DataPagamento.GetValueOrDefault(), TipoPagamentoFatturaEnum.AltroAmministratore)
{
RitenutaAcconto = new Ritenuta(scadenza.ImportoRitenuta)
{
ImportoInteressi = movimento.InteressiRitenuta,
ImportoSanzione = movimento.SanzioniRitenuta,
Stato = StatoRitenutaEnum.Inserita
},
Stato = StatoSpesaEnum.Pagata
};
_daoFactory.GetPagamentoDao().SaveOrUpdate(pagamento);
}
// -------------------------------------------------------------------------------------------
// Se presente la data di versamento della ritenuta la ritenuta inserita è già stata versata
// -------------------------------------------------------------------------------------------
if (string.IsNullOrEmpty(fatalMessage) && movimento.DataVersamentoRitenuta != null)
{
var contoRitenuta = _daoFactory.GetContoDao().GetByCodice(scadenza.SpesaRiferimento.EsercizioRiferimento.ID, scadenza.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoBancario());
_ritenutaService.PagamentoRitenuta(pagamento, movimento.DataVersamentoRitenuta.GetValueOrDefault(), contoRitenuta, null, testata.Descrizione, null, null, null);
}
}
if (dettaglio != null)
listaDettagli.Add(movimento.ID, dettaglio);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - PAGAMENTO - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID);
throw;
}
// =================================================================================
// FATTURE
// ---------------------------------------------------------------------------------
// Inserimento pagamento fattura per fattura in bilancio di apertura ma già pagata
// ---------------------------------------------------------------------------------
try
{
if (spesa != null && string.IsNullOrEmpty(fatalMessage) && conto.Codice == _pianoContiService.GetCodiceContoFornitori() && movimento.DataPagamento != null)
{
if (spesa.ID > 0 && scadenza?.Pagamenti != null && scadenza.Pagamenti.Count > 0)
{
var messageAnnullamentoPagamenti = _pagamentoService.IsAllowAnnullamentoPagamentiSpesa(spesa.ID);
if (string.IsNullOrEmpty(messageAnnullamentoPagamenti.FatalMessage))
_pagamentoService.AnnullamentoPagamentiSpesa(spesa.ID);
else
fatalMessage += messageAnnullamentoPagamenti.FatalMessage + Environment.NewLine;
}
if (string.IsNullOrEmpty(fatalMessage))
{
var idScadenza = 0;
decimal? importoScadenza = spesa.ImportoLordo;
var dataScadenza = movimento.DataPagamento;
var statoScadenza = StatoSpesaEnum.Inserita;
if (scadenza != null)
{
idScadenza = scadenza.ID;
importoScadenza = scadenza.Importo;
dataScadenza = scadenza.Scadenza;
statoScadenza = scadenza.Stato;
}
int? idSottoConto = null;
var datiBancari = esercizio.CondominioRiferimento.DatiBancariPrincipale;
if (datiBancari != null)
idSottoConto = datiBancari.ID*-1;
var scadenze = new List<ScadenzaFatturaDTO>(1)
{
new ScadenzaFatturaDTO
{
ID = idScadenza,
IdContoPagamentoScadenza = _pianoContiService.GetContoBancario(esercizio).ID,
DataPagamentoRitenuta = null,
DataPagamentoScadenza = movimento.DataPagamento.GetValueOrDefault(),
IdSottoContoPagamentoScadenza = idSottoConto,
IdSpesa = spesa.ID,
Importo = importoScadenza,
ImportoRitenuta = movimento.ImportoRitenuta,
Scadenza = dataScadenza,
StatoScadenza = statoScadenza,
Stato = "U"
}
};
var messagePagamenti = _pagamentoService.CreatePagamentiImmediati(spesa.ID, scadenze, null);
if (!string.IsNullOrEmpty(messagePagamenti))
fatalMessage += messagePagamenti + Environment.NewLine;
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - PAGAMENTO 2 - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID);
throw;
}
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - SINGOLO MOVIMENTO - {0} - movimento:{1} - testata:{2}", ex, Utility.GetMethodDescription(), movimento.ID, testata.ID);
throw;
}
}
}
try
{
if(string.IsNullOrEmpty(fatalMessage))
{
var result = _movimentoContabileService.SetBilancioApertura(testata);
fatalMessage += result.Message;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - MOVIMENTI CONTABILI - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID);
throw;
}
try
{
if(string.IsNullOrEmpty(fatalMessage))
{
foreach (var dto in testata.Movimenti)
{
try
{
if (dto.IdMovimentoRiferimento > 0 && listaDettagli.ContainsKey(dto.ID))
_daoFactory.GetMovimentoContabileDao().GetById(dto.IdMovimentoRiferimento, false).DettaglioRiferimento = listaDettagli[dto.ID];
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - IMPOSTAZIONE DETTAGLIO RIFERIMENTO (SINGOLO DETTAGLIO) - {0} - id:{1} - testata:{2}", ex, Utility.GetMethodDescription(), dto.ID, testata.ID);
throw;
}
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - IMPOSTAZIONE DETTAGLIO RIFERIMENTO - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID);
throw;
}
// =============================================================================================
// Esercizi Precedenti: Se chiusi occorre eliminare le registrazioni di chiusura - bugid#2472
// =============================================================================================
var eserciziPrecedenti =
esercizio.CondominioRiferimento.Esercizi.Where(
item =>
item.Stato == StatoEsercizioEnum.Chiuso &&
item.Gestione == GestioneEsercizioEnum.Ordinario &&
item.DataApertura.GetValueOrDefault() < esercizio.DataApertura.GetValueOrDefault()).ToList();
foreach (var esercizioPrecedente in eserciziPrecedenti)
_movimentoContabileService.EliminazioneOperazioniAperturaChiusura(esercizioPrecedente);
}
if (!string.IsNullOrEmpty(fatalMessage))
{
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
}
return new BilancioAperturaMessage(fatalMessage, warnMessage, false);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID);
throw;
}
}
private void writeMovimento30(Pagamento pag, StreamWriter sw, int numeroDisposizione)
{
var sb = new StringBuilder(120);
// Tipo Record
sb.Append(" 30");
// Numero Disposizione
sb.Append(numeroDisposizione.ToString().PadLeft(7, '0'));
// --------------------------------------------------------------------
// Descrizione beneficiario (fornitore)
// --------------------------------------------------------------------
var descrizioneFornitore = Library.Conversione.ToInvioTelematico(pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento.DisplayName);
var descrizione1 = string.Empty;
var descrizione2 = string.Empty;
var descrizione3 = string.Empty;
if (descrizioneFornitore.Length <= 30)
{
descrizione1 = descrizioneFornitore.PadRight(30, ' ');
descrizione2 = string.Empty.PadLeft(30, ' ');
descrizione3 = string.Empty.PadLeft(30, ' ');
}
else if (descrizioneFornitore.Length > 30 && descrizioneFornitore.Length <= 60)
{
descrizione1 = descrizioneFornitore.Substring(0, 30);
descrizione2 = descrizioneFornitore.PadRight(61, ' ').Substring(31, 30);
descrizione3 = string.Empty.PadLeft(30, ' ');
}
else if (descrizioneFornitore.Length > 60)
{
descrizione1 = descrizioneFornitore.Substring(0, 30);
descrizione2 = descrizioneFornitore.Substring(31, 30);
descrizione3 = descrizioneFornitore.Substring(61).PadRight(30, ' ');
}
// Descrizione fornitore
sb.Append(descrizione1);
sb.Append(descrizione2);
sb.Append(descrizione3);
// Codice Fiscale
if (pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento.PersonaRiferimento.CodiceFiscale != null)
sb.Append(pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento.PersonaRiferimento.CodiceFiscale.PadRight(16, ' '));
// filler
sb.Append(string.Empty.PadLeft(4));
sw.WriteLine(sb.ToString());
}
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 TestataMovimentoContabile SetMovimentiRitenuta(Pagamento pagamento, Ritenuta ritenuta, Conto contoPatrimoniale, int? idSottoConto, DateTime dataRegistrazione, string descrizione, string descrizioneAddebitoInteressi, string descrizioneAddebitoSanzioni, decimal? importo)
{
var esercizio = _daoFactory.GetEsercizioDao().GetEsercizioCompetenza(pagamento.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento, dataRegistrazione);
if (esercizio == null || esercizio.Stato == StatoEsercizioEnum.Chiuso)
{
throw new InvalidDataException(string.Format("La data di registrazione {0:d} del versamento della ritenuta per {1:c} non è valida per il condominio:'{2}' perchè non è stato trovato un esercizio aperto di competenza", dataRegistrazione, ritenuta.Importo, pagamento.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.DisplayName));
}
var message = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
if (message.Count == 0)
{
var numeroRiga = 0;
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("VR");
var importoRitenuta = ritenuta.Importo.GetValueOrDefault();
if (importo != null)
importoRitenuta = importo.Value;
importoRitenuta = Math.Round(importoRitenuta, 2);
// ------------------------------------------------
// Testata
// ------------------------------------------------
var testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null) { SpesaRiferimento = pagamento.ScadenzaRiferimento.SpesaRiferimento };
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
var contoRitenuta = _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoRitenuta());
var spesa = pagamento.ScadenzaRiferimento.SpesaRiferimento;
var firstDettaglio = spesa.Dettagli.FirstOrDefault();
TestataMovimentoContabile testataFattura = null;
if (firstDettaglio != null)
{
var firstMovimento = firstDettaglio.Movimenti.FirstOrDefault();
if (firstMovimento != null)
testataFattura = firstMovimento.Testata;
}
// ------------------------------------------------
// Interessi per Ravvedimento Operoso
// ------------------------------------------------
if (ritenuta.ImportoInteressi > 0)
{
if (testataFattura != null && !testataFattura.AperturaBilancio)
{
foreach (var dettaglio in spesa.Dettagli)
{
if (dettaglio.Movimenti.Count > 0)
{
foreach (var movimento in dettaglio.Movimenti)
{
var importoMovimento = movimento.GetImportoConSegno().GetValueOrDefault();
if (movimento.ContoRiferimento.Tipo == TipoContoEconomicoEnum.Patrimoniale)
importoMovimento = importoMovimento * -1;
numeroRiga++;
var interesseCompetenza = ritenuta.ImportoInteressi.GetValueOrDefault();
if (spesa.ImportoLordo != 0)
interesseCompetenza = (ritenuta.ImportoInteressi.GetValueOrDefault() * importoMovimento) / spesa.ImportoLordo;
var movimentoInteresse = new MovimentoContabile(testata, causale, numeroRiga, movimento.ContoRiferimento, interesseCompetenza, "D")
{
SottoContoRiferimento = movimento.SottoContoRiferimento,
FornitoreRiferimento = movimento.FornitoreRiferimento
};
if (!string.IsNullOrEmpty(descrizioneAddebitoInteressi))
movimentoInteresse.Descrizione = descrizioneAddebitoInteressi.Replace("<DescrizioneSpesa>", movimento.GetDescrizione());
_ripartizioneService.CloneRipartizioneByMovimento(movimentoInteresse, movimento);
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoInteresse);
}
}
else
{
numeroRiga++;
var movimentoInteresse = new MovimentoContabile(testata, causale, numeroRiga, contoRitenuta, ritenuta.ImportoInteressi, "D")
{
FornitoreRiferimento = spesa.FornitoreRiferimento,
Descrizione = "Interesse versamento ritenuta"
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoInteresse);
}
}
}
else
{
numeroRiga++;
var sottoContoInteressiSanzioni = _daoFactory.GetSottoContoDao().GetInteressiSanzioniByEsercizio(testata.EsercizioRiferimento.ID, testata.EsercizioRiferimento.CondominioRiferimento.ID);
if (sottoContoInteressiSanzioni != null)
{
var movimentoInteresse = new MovimentoContabile(testata, causale, numeroRiga, sottoContoInteressiSanzioni.ContoRiferimento, ritenuta.ImportoInteressi, "D")
{
SottoContoRiferimento = sottoContoInteressiSanzioni,
FornitoreRiferimento = spesa.FornitoreRiferimento,
Descrizione = "Interesse versamento ritenuta"
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoInteresse);
}
else
{
ritenuta.ImportoInteressi = 0;
}
}
}
// ------------------------------------------------
// Sanzione per Ravvedimento Operoso
// ------------------------------------------------
if (ritenuta.ImportoSanzione > 0)
{
if (testataFattura != null && !testataFattura.AperturaBilancio)
{
foreach (var dettaglio in spesa.Dettagli)
{
if (dettaglio.Movimenti.Count > 0)
{
foreach (var movimento in dettaglio.Movimenti)
{
var importoMovimento = movimento.GetImportoConSegno().GetValueOrDefault();
if (movimento.ContoRiferimento.Tipo == TipoContoEconomicoEnum.Patrimoniale)
importoMovimento = importoMovimento*-1;
numeroRiga++;
var sanzioneCompetenza = ritenuta.ImportoSanzione.GetValueOrDefault();
if (spesa.ImportoLordo != 0)
sanzioneCompetenza = (ritenuta.ImportoSanzione.GetValueOrDefault()*
importoMovimento)/spesa.ImportoLordo;
var movimentoSanzione = new MovimentoContabile(testata, causale, numeroRiga,
movimento.ContoRiferimento, sanzioneCompetenza, "D")
{
SottoContoRiferimento = movimento.SottoContoRiferimento,
FornitoreRiferimento = movimento.FornitoreRiferimento
};
if (!string.IsNullOrEmpty(descrizioneAddebitoSanzioni))
movimentoSanzione.Descrizione = descrizioneAddebitoSanzioni.Replace("<DescrizioneSpesa>", movimento.GetDescrizione());
_ripartizioneService.CloneRipartizioneByMovimento(movimentoSanzione, movimento);
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoSanzione);
}
}
else
{
numeroRiga++;
var movimentoSanzione = new MovimentoContabile(testata, causale, numeroRiga, contoRitenuta, ritenuta.ImportoSanzione, "D")
{
FornitoreRiferimento = spesa.FornitoreRiferimento,
Descrizione = "Sanzione versamento ritenuta"
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoSanzione);
}
}
}
else
{
numeroRiga++;
var sottoContoInteressiSanzioni = _daoFactory.GetSottoContoDao().GetInteressiSanzioniByEsercizio(testata.EsercizioRiferimento.ID, testata.EsercizioRiferimento.CondominioRiferimento.ID);
if (sottoContoInteressiSanzioni != null)
{
var movimentoSanzione = new MovimentoContabile(testata, causale, numeroRiga, sottoContoInteressiSanzioni.ContoRiferimento, ritenuta.ImportoSanzione, "D")
{
SottoContoRiferimento = sottoContoInteressiSanzioni,
FornitoreRiferimento = spesa.FornitoreRiferimento,
Descrizione = "Sanzione versamento ritenuta"
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoSanzione);
}
else
{
ritenuta.ImportoSanzione = 0;
}
}
}
// ------------------------------------------------
// Ritenuta
// ------------------------------------------------
numeroRiga++;
var movimentoPatrimoniale = new MovimentoContabile(testata, causale, numeroRiga, contoRitenuta, importoRitenuta, "D")
{
FornitoreRiferimento = pagamento.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento,
Descrizione = "Ritenuta " + pagamento.GetDescrizione()
};
if (!string.IsNullOrEmpty(descrizione))
movimentoPatrimoniale.Descrizione += " - " + descrizione;
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);
// ------------------------------------------------
// Conto Patrimoniale
// ------------------------------------------------
numeroRiga++;
var movimentoBancario = new MovimentoContabile(testata, causale, numeroRiga, contoPatrimoniale, importoRitenuta + ritenuta.ImportoInteressi.GetValueOrDefault() + ritenuta.ImportoSanzione.GetValueOrDefault(), "A")
{
FornitoreRiferimento = movimentoPatrimoniale.FornitoreRiferimento,
Descrizione = movimentoPatrimoniale.Descrizione
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoBancario);
if (idSottoConto != null)
{
if (idSottoConto > 0)
movimentoBancario.SottoContoRiferimento = _daoFactory.GetSottoContoDao().GetById(idSottoConto.Value, false);
if (idSottoConto < 0)
movimentoBancario.ContoCorrenteBancario = _daoFactory.GetDatiBancariCondominiDao().GetById(idSottoConto.Value*-1, false);
}
if (contoPatrimoniale.Codice == _pianoContiService.GetCodiceContoBancario() &&
movimentoBancario.ContoCorrenteBancario == null)
movimentoBancario.ContoCorrenteBancario = esercizio.CondominioRiferimento.DatiBancariPrincipale;
testata.Descrizione = movimentoPatrimoniale.Descrizione;
ritenuta.MovimentoContabilePagamento = movimentoBancario;
return testata;
}
var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", dataRegistrazione));
_log.FatalFormat("Data di registrazione non valida - {0} - data:{1} - pagamento:{2} - conto:{3}", ex, Utility.GetMethodDescription(), dataRegistrazione, pagamento.ID, contoPatrimoniale.ID);
throw ex;
}
private CBICreditTransferTransactionInformation getCreditTransferTransactionInfo(Pagamento pagamento, int index)
{
var debitore = pagamento.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento;
var creditInfo = new CBICreditTransferTransactionInformation
{
PaymentId = new PaymentIdentification1
{
InstructionId = index.ToString(),
EndToEndId = pagamento.ID.ToString()
},
Amount = new CBIAmountType1
{
InstructedAmount = new ActiveOrHistoricCurrencyAndAmount
{
Currency = "EUR",
Value = pagamento.Importo.GetValueOrDefault()
}
},
Creditor = getCreditor(debitore),
CreditorAccount = new CBICashAccount2
{
Id = new CBIAccountIdentification1 {IBAN = debitore.PersonaRiferimento.Iban}
},
PaymentTypeInfo = new CBIPaymentTypeInformation2
{
CategoryPurpose = new CategoryPurpose1Choice {Code = "SUPP"}
},
RemittanceInformation = new RemittanceInformation5
{
Unstructured = new List<string> {pagamento.GetDescrizione().TrimForSepa() }
},
RelatedRemittanceInformation = new List<CBIRemittanceLocation1>
{
new CBIRemittanceLocation1 {RmtId = pagamento.ID.ToString()}
}
};
//creditInfo.ServiceInformation = CBISrvInf1.ESBEN;
//creditInfo.DestCdtrRsp = new CBIPartyIdentification5();
//creditInfo.DestCdtrRsp.Name = _disposizione.Azienda.Descrizione;
//creditInfo.DestCdtrRsp.Id = new CBIIdType3();
//creditInfo.DestCdtrRsp.Id.OrganisationId = new CBIOrganisationIdentification4();
//creditInfo.DestCdtrRsp.Id.OrganisationId.Othr = new CBIGenericIdentification2();
//creditInfo.DestCdtrRsp.Id.OrganisationId.Othr.Id = _disposizione.Azienda.CodiceCUC;
//creditInfo.DestCdtrRsp.Id.OrganisationId.Othr.Issr = "CBI";
//creditInfo.PaymentTypeInfo.CategoryPurpose.Item = "SUPP";
//creditInfo.PaymentTypeInfo.CategoryPurpose.ItemElementName = ItemChoiceType.Cd;
return creditInfo;
}
private void writeMovimento10(Pagamento pag, StreamWriter sw, int numeroDisposizione)
{
var sb = new StringBuilder(120);
// Tipo Record
sb.Append(" 10");
// Numero Disposizione
sb.Append(numeroDisposizione.ToString().PadLeft(7, '0'));
// filler
sb.Append(string.Empty.PadLeft(6));
// data esecuzione bonifico
sb.Append(convertData(DateTime.Today));
// data valuta
// sb.Append(convertData(pag.Valuta.Value));
// La valuta è ora decisa dalla banca quindi il campo non viene più valorizzato
sb.Append(string.Empty.PadLeft(6));
// causale
sb.Append("48000");
// importo
sb.Append(Math.Round(pag.Importo.GetValueOrDefault() * 100, 0).ToString().PadLeft(13, '0'));
// segno
sb.Append("+");
// --------------------------------------------------------------------
// Coordinate banca ordinante (banca del condominio)
// --------------------------------------------------------------------
var contoCorrente = pag.ContoCorrenteBancario ?? pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.DatiBancariPrincipale;
// ABI
sb.Append(contoCorrente.Abi.PadLeft(5, '0'));
// CAB
sb.Append(contoCorrente.Cab.PadLeft(5, '0'));
// Conto Corrente
var contoCorrenteValue = contoCorrente.ContoCorrente;
if (!string.IsNullOrEmpty(contoCorrenteValue) && contoCorrenteValue.Length > 12)
contoCorrenteValue = contoCorrenteValue.Substring(0, 12);
sb.Append(contoCorrenteValue.PadLeft(12, '0'));
// --------------------------------------------------------------------
// Coordinate banca destinataria (banca del fornitore)
// --------------------------------------------------------------------
// ABI
sb.Append(pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento.PersonaRiferimento.Abi.PadLeft(5, '0'));
// CAB
sb.Append(pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento.PersonaRiferimento.Cab.PadLeft(5, '0'));
// Conto Corrente
sb.Append(pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento.PersonaRiferimento.ContoCorrente.PadLeft(12, '0'));
// --------------------------------------------------------------------
// Coordinate azienda ordinante (condominio)
// --------------------------------------------------------------------
// Codice SIA
sb.Append(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.CodiceSIA.PadLeft(5, '0'));
// Tipo codice
sb.Append("3");
// Codice Fiscale del beneficiario (Fornitore)
string codiceFiscaleFornitore = pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento.PersonaRiferimento.PartitaIva;
if(string.IsNullOrEmpty(codiceFiscaleFornitore) && !string.IsNullOrEmpty(pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento.PersonaRiferimento.CodiceFiscale))
codiceFiscaleFornitore = pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento.PersonaRiferimento.CodiceFiscale;
if (!string.IsNullOrEmpty(codiceFiscaleFornitore) && codiceFiscaleFornitore.Length > 16)
codiceFiscaleFornitore = codiceFiscaleFornitore.Substring(0, 16);
if (string.IsNullOrEmpty(codiceFiscaleFornitore))
codiceFiscaleFornitore = pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento.ID.ToString();
sb.Append(codiceFiscaleFornitore.PadRight(16, ' '));
// Modilità pagamento
sb.Append("1");
// filler
sb.Append(string.Empty.PadLeft(5));
// divisa
sb.Append("E");
sw.WriteLine(sb.ToString());
}
private PagamentoSpesaDTO setSpesaDto(Pagamento item)
{
try
{
var dto = new PagamentoSpesaDTO
{
ID = item.ID,
Data = item.Data,
CodiceConfermaBonifico = item.CodiceConfermaBonifico,
Importo = item.Importo,
StatoPagamento = item.Stato,
Valuta = item.Valuta,
Tipo = item.Tipo,
Version = item.Version,
IdScadenzaFattura = item.ScadenzaRiferimento.ID
};
if (item.DisposizioneRiferimento != null)
{
dto.DescrizioneDisposizioneRiferimento = item.DisposizioneRiferimento.Descrizione;
dto.IdDisposizioneRiferimento = item.DisposizioneRiferimento.ID;
}
if (item.TipoCodiceConfermaBonifico != TipoCodiceEsitoDisposizioneBonifico.Undefined)
dto.TipoCodiceConfermaBonifico = item.TipoCodiceConfermaBonifico;
if (item.MovimentoContabile != null)
{
dto.Conto = item.MovimentoContabile.ContoRiferimento.Descrizione;
if (item.MovimentoContabile.SottoContoRiferimento != null)
dto.SottoConto = item.MovimentoContabile.SottoContoRiferimento.GetDescrizione(item.MovimentoContabile.Testata.EsercizioRiferimento, null, item.MovimentoContabile);
else if (item.MovimentoContabile.ContoCorrenteBancario != null)
dto.SottoConto = item.MovimentoContabile.ContoCorrenteBancario.DisplayName;
}
if (item.RitenutaAcconto != null)
{
dto.ImportoRitenuta = item.RitenutaAcconto.Importo;
dto.StatoRitenuta = item.RitenutaAcconto.Stato;
if (item.RitenutaAcconto.TestataRiferimento != null)
dto.DataPagamentoRitenuta = item.RitenutaAcconto.TestataRiferimento.Data;
}
return dto;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella creazione dell'istanza DTO - {0} - id:{1}", ex, Library.Utility.GetMethodDescription(), item.ID);
throw;
}
}
private string getDisposizioneUniqueId(Pagamento pagamento)
{
try
{
return $"{pagamento.DisposizioneRiferimento.ID}+{pagamento.ContoCorrenteBancario.ID:000000000}+{DateTime.Now:yyyy-MM-dd-HHmm}";
}
catch (Exception ex)
{
var disposizione = string.Empty;
if (pagamento?.DisposizioneRiferimento != null)
disposizione = pagamento.DisposizioneRiferimento.ID.ToString();
var contoCorrente = string.Empty;
if (pagamento?.ContoCorrenteBancario != null)
contoCorrente = pagamento.ContoCorrenteBancario.ID.ToString();
_log.ErrorFormat("Errore nell'identificazione del pagamento - {0} - pagamento:{1} - disposizione:{2} - contoCorrente:{3}", ex, Library.Utility.GetMethodDescription(), pagamento?.ID.ToString() ?? "<NULL>", disposizione, contoCorrente);
throw;
}
}
private PagamentoDTO setDto(Pagamento item)
{
try
{
if (item != null)
{
var dto = new PagamentoDTO
{
ID = item.ID,
Data = item.Data,
IdScadenzaFattura = item.ScadenzaRiferimento.ID,
IdFattura = item.ScadenzaRiferimento.SpesaRiferimento.ID,
IdentificativoArchiviazione = getArchiviazioneOtticaService().GetIdentificativoArchiviazione(item.ScadenzaRiferimento.SpesaRiferimento),
Importo = item.Importo,
StatoSpesa = item.ScadenzaRiferimento.SpesaRiferimento.Stato,
TipoDocumentoSpesa = Library.Decodifica.Instance.GetElement("TipoDocumentoContabile", item.ScadenzaRiferimento.SpesaRiferimento.TipoDocumento).Descrizione,
CodiceEsercizioSpesa = item.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.ID,
StatoPagamento = item.Stato,
Valuta = item.Valuta,
CodiceConfermaBonifico = item.CodiceConfermaBonifico,
Tipo = item.Tipo,
Version = item.Version
};
if (item.TipoCodiceConfermaBonifico != TipoCodiceEsitoDisposizioneBonifico.Undefined)
dto.TipoCodiceConfermaBonifico = item.TipoCodiceConfermaBonifico;
if (item.DisposizioneRiferimento != null)
{
dto.DescrizioneDisposizioneRiferimento = item.DisposizioneRiferimento.Descrizione;
dto.IdDisposizioneRiferimento = item.DisposizioneRiferimento.ID;
}
if (item.MovimentoContabile != null)
{
dto.CodiceMovimentoPagamentoFattura = item.MovimentoContabile.ID;
dto.CodiceTestataMovimentoPagamentoFattura = item.MovimentoContabile.Testata.ID;
dto.Conto = item.MovimentoContabile.ContoRiferimento.Descrizione;
if (item.MovimentoContabile.SottoContoRiferimento != null)
dto.SottoConto = item.MovimentoContabile.SottoContoRiferimento.GetDescrizione(item.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento, null, item.MovimentoContabile);
else if (item.MovimentoContabile.ContoRiferimento.Codice == getPianoContiService().GetCodiceContoBancario() && item.MovimentoContabile.ContoCorrenteBancario != null)
dto.SottoConto = item.MovimentoContabile.ContoCorrenteBancario.DisplayName;
}
if (item.RitenutaAcconto != null)
{
dto.ImportoRitenuta = item.RitenutaAcconto.Importo;
dto.StatoRitenuta = item.RitenutaAcconto.Stato;
if (item.RitenutaAcconto.TestataRiferimento != null)
dto.DataPagamentoRitenuta = item.RitenutaAcconto.TestataRiferimento.Data;
if (item.RitenutaAcconto.MovimentoContabilePagamento != null)
{
dto.CodiceMovimentoPagamentoRitenuta = item.RitenutaAcconto.MovimentoContabilePagamento.ID;
dto.CodiceTestataMovimentoPagamentoRitenuta = item.RitenutaAcconto.MovimentoContabilePagamento.Testata.ID;
}
}
if (item.ScadenzaRiferimento.SpesaRiferimento != null)
{
dto.DescrizioneCondominio = item.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.DisplayName;
dto.DescrizioneFornitore = item.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento.DisplayName;
dto.NumeroDocumento = item.ScadenzaRiferimento.SpesaRiferimento.NumeroDocumento;
dto.DataDocumento = item.ScadenzaRiferimento.SpesaRiferimento.DataDocumento;
var detrazione = string.Empty;
if (item.ScadenzaRiferimento.SpesaRiferimento.Detrazione.GetValueOrDefault() == 36)
detrazione = item.Data <= new DateTime(2012, 6, 25)
? "36 - Ristr.Edilizia"
: "50% - Ristr.Edilizia";
else if (item.ScadenzaRiferimento.SpesaRiferimento.Detrazione.GetValueOrDefault() == 55)
detrazione = "55% - Riqual.Energetica";
dto.Detrazione = detrazione;
}
return dto;
}
return null;
}
catch (Exception ex)
{
var idStr = string.Empty;
if (item != null)
idStr = item.ID.ToString(CultureInfo.InvariantCulture);
_log.ErrorFormat("Errore nella creazione dell'istanza DTO - {0} - id:{1}", ex, Library.Utility.GetMethodDescription(), idStr);
throw;
}
}
public PagamentoDTO GetByDomainEntity(Pagamento item)
{
try
{
return setDto(item);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel caricamento dei pagamenti delle Fatture/Spese - {0} - id:{1}", ex, Library.Utility.GetMethodDescription(), item.ID);
throw;
}
}
public virtual IUpdatableBusinessEntity Copy()
{
Pagamento pagamento = new Pagamento(ScadenzaRiferimento, DisposizioneRiferimento, null, Data, Tipo);
return pagamento;
}
private List<DatiCertificazioneDTO> setDatiCertificazione(List<DatiCertificazioneDTO> dati, Pagamento pag, DateTime? dataPagamentoRitenuta, int anno, bool esenteRegimeMinimo)
{
if (pag.RitenutaAcconto != null && (pag.RitenutaAcconto.Importo.GetValueOrDefault() != 0 || esenteRegimeMinimo))
{
var datiCertificazione = (from item in dati
where item.IdCondominio == pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID &&
item.IdFornitore == pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento.ID
select item).SingleOrDefault();
if (datiCertificazione == null)
{
datiCertificazione = new DatiCertificazioneDTO
{
DescrizioneFornitore = pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento.DisplayName,
IdFornitore = pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento.ID,
IdPersona = pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento.PersonaRiferimento.ID,
CodiceCondominio = pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.Codice,
IdCondominio = pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID,
DescrizioneCondominio = pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.Descrizione,
CodiceFiscaleCondominio = pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.CodiceFiscale,
CodiceFiscaleFornitore = pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento.PersonaRiferimento.CodiceFiscale,
PartitaIvaFornitore = pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento.PersonaRiferimento.PartitaIva,
EsenteRegimeMinimo = esenteRegimeMinimo
};
var contatti = new ContattoCollection(pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento.PersonaRiferimento.Contatti);
var contattoEmail = contatti.GetFirstContatto<Email>();
if (contattoEmail != null)
datiCertificazione.Email = contattoEmail.Valore;
var contattoEmailCertificato = contatti.GetFirstContatto<EmailCertificata>();
if(contattoEmailCertificato != null)
datiCertificazione.EmailCertificata = contattoEmailCertificato.Valore;
var contattoFax = contatti.GetFirstContatto<Fax>();
if (contattoFax != null)
datiCertificazione.Fax = contattoFax.Valore;
var contattoCellulare = contatti.GetFirstContatto<Cellulare>();
if (contattoCellulare != null)
datiCertificazione.Cellulare = contattoCellulare.Valore;
if (pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento.PersonaRiferimento.IndirizzoResidenza != null)
{
var indirizzo = pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento.PersonaRiferimento.IndirizzoResidenza.DisplayNameArray;
datiCertificazione.IndirizzoFornitore = indirizzo[0];
datiCertificazione.SecondaRigaIndirizzoFornitore = indirizzo[1];
datiCertificazione.CapFornitore = pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento.PersonaRiferimento.IndirizzoResidenza.Cap;
if (pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento.PersonaRiferimento.IndirizzoResidenza.Comune != null)
datiCertificazione.ComuneFornitore = pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento.PersonaRiferimento.IndirizzoResidenza.Comune.Descrizione;
}
if (pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.Indirizzo != null)
{
var indirizzo = pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.Indirizzo.DisplayNameArray;
datiCertificazione.IndirizzoCondominio = indirizzo[0];
datiCertificazione.SecondaRigaIndirizzoCondominio = indirizzo[1];
}
datiCertificazione.Dettaglio = new List<DettaglioDatiCertificazioneDTO>();
dati.Add(datiCertificazione);
}
// ========================================================
// Dettagli della certificazione
// ========================================================
var dettaglioDatiCertificazione = new DettaglioDatiCertificazioneDTO
{
IdCondominio = datiCertificazione.IdCondominio,
IdFornitore = datiCertificazione.IdFornitore,
CodiceTributo = pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento.CodiceTributo,
DataFattura = pag.ScadenzaRiferimento.SpesaRiferimento.DataDocumento.GetValueOrDefault(),
NumeroFattura = pag.ScadenzaRiferimento.SpesaRiferimento.NumeroDocumento,
DataPagamentoFattura = pag.Data.GetValueOrDefault(),
DataPagamentoRitenuta = dataPagamentoRitenuta,
IdFattura = pag.ScadenzaRiferimento.SpesaRiferimento.ID,
ImportoIva = pag.ScadenzaRiferimento.SpesaRiferimento.ImportoIva,
ImportoImponibile = pag.ScadenzaRiferimento.SpesaRiferimento.Imponibile,
ImportoRitenuta = pag.RitenutaAcconto.Importo.GetValueOrDefault(),
PercentualeRitenuta = pag.ScadenzaRiferimento.SpesaRiferimento.AliquotaRitenuta.GetValueOrDefault() * 100,
CompensiSoggetti = esenteRegimeMinimo ? 0m : pag.ScadenzaRiferimento.SpesaRiferimento.GetImponibileRitenuta(),
CompensiNonSoggetti = esenteRegimeMinimo ? pag.ScadenzaRiferimento.SpesaRiferimento.GetImponibileRitenuta() : pag.ScadenzaRiferimento.SpesaRiferimento.AltreSpese.GetValueOrDefault(),
AltreSpeseNonSoggette = pag.ScadenzaRiferimento.SpesaRiferimento.SpeseEsentiRitenuta.GetValueOrDefault(),
ImportoTotale = pag.ScadenzaRiferimento.SpesaRiferimento.ImportoLordo,
ImportoPagato = pag.Importo.GetValueOrDefault()
};
// In casi di pagamento parziale
if (pag.ScadenzaRiferimento.SpesaRiferimento.ImportoLordo - pag.ScadenzaRiferimento.SpesaRiferimento.ImportoRitenuta.GetValueOrDefault() != pag.Importo)
{
var percentualePagata = 1m;
// Nel caso in cui l'importo lordo corrisponde con la ritenuta siamo nel caso di fattura da bilancio di apertura inserita in modo non corretto bugid#7583
var denominatore = pag.ScadenzaRiferimento.SpesaRiferimento.ImportoLordo;
// Nel caso di fattura inserita in bilancio d'apertura con conto "Ritenuta Fiscale" non devo sottrarre l'importo della ritenuta bugid#9391
if (pag.ScadenzaRiferimento.SpesaRiferimento.TipoDocumento.ToUpper() != "FATBILAPP" || pag.ScadenzaRiferimento.SpesaRiferimento.MovimentiBollette.FirstOrDefault() == null || pag.ScadenzaRiferimento.SpesaRiferimento.MovimentiBollette.FirstOrDefault().ContoRiferimento.Codice != "904")
denominatore -= pag.ScadenzaRiferimento.SpesaRiferimento.ImportoRitenuta.GetValueOrDefault();
if (denominatore != 0)
percentualePagata = pag.Importo.GetValueOrDefault() / denominatore;
dettaglioDatiCertificazione.ImportoTotale = dettaglioDatiCertificazione.ImportoTotale * percentualePagata;
dettaglioDatiCertificazione.CompensiSoggetti = dettaglioDatiCertificazione.CompensiSoggetti * percentualePagata;
dettaglioDatiCertificazione.CompensiNonSoggetti = dettaglioDatiCertificazione.CompensiNonSoggetti * percentualePagata;
dettaglioDatiCertificazione.ImportoIva = dettaglioDatiCertificazione.ImportoIva * percentualePagata;
dettaglioDatiCertificazione.ImportoImponibile = dettaglioDatiCertificazione.ImportoImponibile * percentualePagata;
dettaglioDatiCertificazione.AltreSpeseNonSoggette = dettaglioDatiCertificazione.AltreSpeseNonSoggette*percentualePagata;
}
// Per le fatture da bilancio di apertura il campo AltreSpeseEsenti viene usato come: SpeseEsentiRitenuta perchè il campo SpeseEsentiRitenuta non è presente
// occorre quindi sottrarre il valore di tale campo per i CompensiSoggetti bugid#4139
if (pag.ScadenzaRiferimento.SpesaRiferimento.TipoDocumento == "FATBILAPP")
{
dettaglioDatiCertificazione.CompensiSoggetti -= pag.ScadenzaRiferimento.SpesaRiferimento.AltreSpeseEsenti.GetValueOrDefault();
}
datiCertificazione.Dettaglio.Add(dettaglioDatiCertificazione);
}
return dati;
}
private void writeMovimento16(Pagamento pag, StreamWriter sw, int numeroDisposizione)
{
var sb = new StringBuilder(120);
// Tipo Record
sb.Append(" 16");
// Numero Disposizione
sb.Append(numeroDisposizione.ToString().PadLeft(7, '0'));
// --------------------------------------------------------------------
// Coordinate banca ordinante (banca del condominio)
// --------------------------------------------------------------------
var contoCorrente = pag.ContoCorrenteBancario ?? pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.DatiBancariPrincipale;
var coord = new Library.BusinessData.CoordinateBancarie
{
Abi = contoCorrente.Abi,
Cab = contoCorrente.Cab,
ContoCorrente = contoCorrente.ContoCorrente
};
// Codice Paese
sb.Append("IT");
// CheckDigit IBAN
sb.Append(coord.CalcolaCheckIBAN());
// CIN
sb.Append(coord.CalcolaCin());
// ABI
sb.Append(coord.Abi);
// CAB
sb.Append(coord.Cab);
// Conto Corrente
sb.Append(coord.ContoCorrente);
// filler
sb.Append(string.Empty.PadLeft(83));
sw.WriteLine(sb.ToString());
}
private string getKeyOrdine(Pagamento pagamento)
{
var key = pagamento.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento.CodiceTributo + "¥";
key += pagamento.Data.GetValueOrDefault().Year + pagamento.Data.GetValueOrDefault().Month.ToString().PadLeft(2, '0');
return key;
}
private void writeMovimento17(Pagamento pag, StreamWriter sw, int numeroDisposizione)
{
var sb = new StringBuilder(120);
// Tipo Record
sb.Append(" 17");
// Numero Disposizione
sb.Append(numeroDisposizione.ToString().PadLeft(7, '0'));
// --------------------------------------------------------------------
// Coordinate bancarie beneficiario (banca del fornitore)
// --------------------------------------------------------------------
var coord = new Library.BusinessData.CoordinateBancarie
{
Abi = pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento.PersonaRiferimento.Abi,
Cab = pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento.PersonaRiferimento.Cab,
ContoCorrente = pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento.PersonaRiferimento.ContoCorrente
};
// Codice Paese
sb.Append("IT");
// CheckDigit IBAN
sb.Append(coord.CalcolaCheckIBAN());
// CIN
sb.Append(coord.CalcolaCin());
// ABI
sb.Append(coord.Abi);
// CAB
sb.Append(coord.Cab);
// Conto Corrente
sb.Append(coord.ContoCorrente);
// filler
sb.Append(string.Empty.PadLeft(83));
sw.WriteLine(sb.ToString());
}
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;
}
}
private void writeMovimento20(Pagamento pag, StreamWriter sw, int numeroDisposizione, bool mittenteCondominio)
{
var sb = new StringBuilder(120);
// Tipo Record
sb.Append(" 20");
// Numero Disposizione
sb.Append(numeroDisposizione.ToString().PadLeft(7, '0'));
// --------------------------------------------------------------------
// Descrizione azienda ordinante - condominio se mittente è condominio
// --------------------------------------------------------------------
// Descrizione condominio
string descrizioneMittente = Library.Conversione.ToInvioTelematico(mittenteCondominio ? pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.Descrizione : pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.Azienda.Descrizione);
if (descrizioneMittente.Length > 30)
descrizioneMittente = descrizioneMittente.Substring(0, 30);
sb.Append(descrizioneMittente.PadRight(30, ' '));
// Indirizzo
string indirizzoCondominio = string.Empty;
if (mittenteCondominio)
{
if (pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.Indirizzo != null)
indirizzoCondominio = Library.Conversione.ToInvioTelematico(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.Indirizzo.GetIndirizzoCompleto());
}
else
{
if (pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.Azienda.IndirizzoSede != null)
indirizzoCondominio = Library.Conversione.ToInvioTelematico(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.Azienda.IndirizzoSede.GetIndirizzoCompleto());
}
if (indirizzoCondominio.Length > 30)
indirizzoCondominio = indirizzoCondominio.Substring(0, 30);
sb.Append(indirizzoCondominio.PadRight(30, ' '));
// Località
string localitaCondominio = string.Empty;
if (mittenteCondominio)
{
if (pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.Indirizzo != null)
localitaCondominio = Library.Conversione.ToInvioTelematico(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.Indirizzo.Comune.Descrizione);
}
else
{
if (pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.Azienda.IndirizzoSede != null)
localitaCondominio = Library.Conversione.ToInvioTelematico(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.Azienda.IndirizzoSede.Comune.Descrizione);
}
if (localitaCondominio.Length > 30)
localitaCondominio = localitaCondominio.Substring(0, 30);
sb.Append(localitaCondominio.PadRight(30, ' '));
// Codice Fiscale
sb.Append(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.CodiceFiscale.PadRight(16, ' '));
// filler
sb.Append(string.Empty.PadLeft(4));
sw.WriteLine(sb.ToString());
}
public MovimentoContabile SetMovimentiStornoPagamento(Pagamento pag, decimal importo, DateTime dataRegistrazione)
{
try
{
var esercizio = _daoFactory.GetEsercizioDao().GetEsercizioCompetenza(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento, dataRegistrazione);
var message = IsAllowDataRegistrazione(new List<int> { pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
if (message.Count == 0)
{
var numeroRiga = 0;
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("SS");
// ================================================
// Testata
// ================================================
var testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null);
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
// ================================================
// Debiti VS Fornitori
// ================================================
numeroRiga++;
var segno = "A";
if (importo < 0)
{
segno = "D";
importo = importo * -1;
}
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()), importo, segno)
{
Descrizione = "Storno Fatt. n." + pag.ScadenzaRiferimento.SpesaRiferimento.NumeroDocumento + " del " + pag.ScadenzaRiferimento.SpesaRiferimento.DataDocumento.GetValueOrDefault().ToShortDateString()
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);
// ================================================
// Conto Patrimoniale
// ================================================
numeroRiga++;
var movimentoBancario = new MovimentoContabile(testata, causale, numeroRiga, pag.Conto, importo, invertiSegno(segno))
{
Descrizione = movimentoPatrimoniale.Descrizione,
FornitoreRiferimento = pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento,
SottoContoRiferimento = pag.SottoConto,
ContoCorrenteBancario = pag.ContoCorrenteBancario
};
pag.MovimentoContabileStorno = movimentoBancario;
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoBancario);
return movimentoBancario;
}
var ex = new InvalidDataException(string.Format("La data di registrazione {0:d} non è valida", dataRegistrazione));
_log.ErrorFormat("Data di registrazione non valida - {0} - data:{1} - pagamento:{2} - importo:{3}", ex, Utility.GetMethodDescription(), dataRegistrazione, pag.ID, importo);
throw ex;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella funzione - {0} - data:{1} - pagamento:{2} - importo:{3}", ex, Utility.GetMethodDescription(), dataRegistrazione, pag.ID, importo);
throw;
}
}
public SpesaInfoDTO SalvaFiscale(SpesaFiscaleDTO dto)
{
try
{
var message = string.Empty;
var fornitore = _daoFactory.GetFornitoreDao().GetById(dto.IdFornitore, false);
var esercizio = _daoFactory.GetEsercizioDao().Find(dto.IdEsercizio, false);
if (esercizio == null)
throw new InvalidDataException("L'esercizio selezionato non è più presente in archivio.");
GestioneCondomini.Domain.Spesa spesa;
if (dto.ID == 0)
{
spesa = new GestioneCondomini.Domain.Spesa(fornitore, esercizio, null);
var protocollo = _protocolloService.GetProgressivo(TipoProtocollo.Fattura, esercizio.DataApertura.GetValueOrDefault().Year, esercizio.CondominioRiferimento);
if (protocollo.Progressivo != null)
{
spesa.NumeroProtocollo = protocollo.Progressivo;
_daoFactory.GetSpesaDao().SaveOrUpdate(spesa);
}
else
message = protocollo.Message + Environment.NewLine;
}
else
{
spesa = _daoFactory.GetSpesaDao().GetById(dto.ID, false);
spesa.FornitoreRiferimento = fornitore;
spesa.EsercizioRiferimento = esercizio;
}
var info = new SpesaInfoDTO();
if (string.IsNullOrEmpty(message))
{
spesa.ImportoRitenuta = dto.Scadenze.Sum(item => item.ImportoRitenuta);
spesa.AltreSpese = dto.AltreSpese;
spesa.AltreSpeseEsenti = dto.SpeseEsenti;
spesa.SpeseEsentiRitenuta = dto.SpeseEsentiRitenuta;
spesa.CassaProfessionisti = dto.CassaProfessionisti;
spesa.DataDocumento = dto.DataDocumento;
spesa.NumeroDocumento = dto.NumeroDocumento;
spesa.AliquotaRitenuta = dto.AliquotaRitenuta;
spesa.IsAbilitataArchiviazioneOttica = dto.IsAbilitataArchiviazioneOttica;
spesa.IsRitenutaCalcoloImponibile = dto.IsRitenutaCalcoloImponibile;
spesa.Stato = StatoSpesaEnum.Pagata;
spesa.TipoDocumento = dto.TipoDocumento;
spesa.Detrazione = dto.Detrazione;
spesa.EsenteRegimeMinimo = dto.EsenteRegimeMinimo;
// ----------------------------------------------------
// Dettagli
// ----------------------------------------------------
spesa.Dettagli.Clear();
var index = 0;
foreach (var dtoDettaglio in dto.Dettagli)
{
index++;
DettaglioSpesa dettaglio;
if (dtoDettaglio.ID == 0)
dettaglio = new DettaglioSpesa(spesa, index);
else
{
dettaglio = _daoFactory.GetDettaglioSpesaDao().GetById(dtoDettaglio.ID, false);
dettaglio.NumeroRiga = index;
spesa.Dettagli.Add(dettaglio);
}
dettaglio.AliquotaIva = dtoDettaglio.AliquotaIva;
dettaglio.Descrizione = dtoDettaglio.Descrizione;
dettaglio.ImportoIva = dtoDettaglio.ImportoIva;
dettaglio.ImportoLordo = dtoDettaglio.ImportoLordo;
dettaglio.SoggettoRitenutaAcconto = dtoDettaglio.SoggettoRitenutaAcconto;
}
// ----------------------------------------------------
// Scadenze / Pagamenti
// ----------------------------------------------------
// Pulizia movimenti, scadenze e pagamenti presenti
foreach (var scadenza in spesa.Scadenze)
{
foreach (var pagamento in scadenza.Pagamenti)
_daoFactory.GetPagamentoDao().Delete(pagamento);
_daoFactory.GetScadenzaFatturaDao().Delete(scadenza);
}
spesa.Scadenze.Clear();
foreach (var scadenzaDto in dto.Scadenze)
{
var scadenzaNew = new ScadenzaFattura(spesa, scadenzaDto.DataPagamento, scadenzaDto.Importo) { Stato = StatoSpesaEnum.Pagata };
var pagamentoNew = new Pagamento(scadenzaNew, null, scadenzaNew.Importo, scadenzaNew.Scadenza, TipoPagamentoFatturaEnum.Immediato) { Stato = StatoSpesaEnum.Pagata };
scadenzaNew.Pagamenti.Add(pagamentoNew);
_daoFactory.GetScadenzaFatturaDao().SaveOrUpdate(scadenzaNew);
// -----------------------------------------------------
// Ritenuta
// -----------------------------------------------------
// ritenuta PAGATA dal vecchio amministratore i dati, compresi interessi e sanzioni servono per il modello 770
var ritenuta = new Ritenuta(scadenzaDto.ImportoRitenuta);
if (!scadenzaDto.RitenutaNONPagata)
{
ritenuta.Stato = StatoRitenutaEnum.PagataAltroAmministratore;
ritenuta.DataPagamentoRitenuta = scadenzaDto.DataPagamentoRitenuta;
ritenuta.ImportoInteressi = scadenzaDto.ImportoInteressi;
ritenuta.ImportoSanzione = scadenzaDto.ImportoSanzioni;
}
// ritenuta NON Pagata inserita come da pagare
else
{
ritenuta.Stato = StatoRitenutaEnum.Inserita;
ritenuta.DataPagamentoRitenuta = null;
_daoFactory.GetSpesaDao().SaveOrUpdate(spesa);
_movimentoContabileService.SetMovimentiRitenutaPagataAltroAmministratore(spesa, scadenzaDto.DataPagamento.GetValueOrDefault());
}
pagamentoNew.RitenutaAcconto = ritenuta;
}
info = new SpesaInfoDTO
{
Id = spesa.ID,
NumeroProtocollo = spesa.NumeroProtocollo.GetValueOrDefault(),
};
if (spesa.IsAbilitataArchiviazioneOttica)
{
var impostazioni = _daoFactory.GetImpostazioniAziendaDao().GetByAzienda(spesa.EsercizioRiferimento.CondominioRiferimento.Azienda.ID);
info.IdentificativoArchiviazione = _archiviazioneService.GetIdentificativoArchiviazione(spesa);
info.StampaEtichettaArchiviazione = impostazioni.UtilizzoEtichettatriceArchiviazioneOtticaFatture && spesa.EsercizioRiferimento.CondominioRiferimento.IsAbilitataArchiviazioneOtticaPassivi.GetValueOrDefault();
info.EtichettatriceArchiviazione = impostazioni.EtichettatriceArchiviazioneOttica;
info.TipoEtichettaArchiviazione = impostazioni.TipoEtichettaArchiviazioneOttica;
}
spesa.Stato = StatoSpesaEnum.PagataAltroAmministratore;
}
else
info.Message = message;
return info;
}
catch (Exception ex)
{
_log.Fatal("Errore inaspettato nel salvataggio della spesa FISCALE - " + Utility.GetMethodDescription() + " - spesa:" + dto.ID, ex);
throw;
}
}