/// <summary>
/// Crea un movimento contabile valido.
/// </summary>
public MovimentoContabile(TestataMovimentoContabile testata, CausaleContabile causale, int? numeroRiga, SottoConto sottoConto, decimal? importo, string segno)
{
Causale = causale;
NumeroRiga = numeroRiga;
SottoContoRiferimento = sottoConto;
ContoRiferimento = sottoConto.ContoRiferimento;
Testata = testata;
Importo = importo;
Segno = segno;
Stato = StatoMovimentoContabileEnum.Inserito;
IsVisibileGestione = true;
if (Testata != null)
{
Testata.Movimenti.Add(this);
setNumeroRegistrazione();
}
}
public void SetMovimentoArrotondamento(Spesa spesa, TestataMovimentoContabile testata, CausaleContabile causale, LogTransazione logTransazione)
{
var importoTotale = testata.Movimenti.Where(item => item.Segno == "A").Sum(item => Math.Round(item.Importo.GetValueOrDefault(), 2, MidpointRounding.AwayFromZero));
var importoEconomico = testata.Movimenti.Where(item => item.Segno == "D").Sum(item => Math.Round(item.Importo.GetValueOrDefault(), 2, MidpointRounding.AwayFromZero));
var numeroRiga = testata.Movimenti.Max(item => item.NumeroRiga.GetValueOrDefault()) + 1;
setMovimentoArrotondamento(importoTotale, importoEconomico, numeroRiga, spesa, testata, causale, logTransazione);
}
public MovimentoContabile SetMovimentoBancarioGenerico(DatiBancariCondomini banca, Esercizio esercizioRiferimento, SottoConto sottoconto, decimal importo, string descrizione, DateTime dataRegistrazione, CausaleContabile causale)
{
try
{
var message = IsAllowDataRegistrazione(new List<int> { esercizioRiferimento.CondominioRiferimento.ID }, esercizioRiferimento, dataRegistrazione);
if (message.Count > 0)
{
var ex = new InvalidDataException($"La data di registrazione {dataRegistrazione} non è valida");
_log.FatalFormat("Data di registrazione non valida - {0} - data:{1} - esercizio:{2}", ex, Utility.GetMethodDescription(), dataRegistrazione, esercizioRiferimento.ID);
throw ex;
}
var testata = new TestataMovimentoContabile(esercizioRiferimento, dataRegistrazione, TipoTestataMovimentoContabileEnum.Manuale, null)
{
Descrizione = descrizione,
IsAbilitataArchiviazioneOttica = false,
IsAllowUpdate = true
};
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
// -------------------------------------------------
// Segno Movimento
// ------------------------------------------------
string segnoContoEconomico = "D";
if (importo > 0)
segnoContoEconomico = "A";
else
importo = importo * -1;
// ------------------------------------------------
// Conto economico
// ------------------------------------------------
var movimentoContoEconomico = new MovimentoContabile(testata, causale, 1, sottoconto, importo, segnoContoEconomico) {Descrizione = descrizione};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoContoEconomico);
_ripartizioneService.SalvaRipartizione(movimentoContoEconomico, esercizioRiferimento.CondominioRiferimento.ID);
// ------------------------------------------------
// BANCA
// ------------------------------------------------
var movimentoBancario = new MovimentoContabile(testata, causale, 2, _daoFactory.GetContoDao().GetByCodice(esercizioRiferimento.ID, esercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoBancario()), importo, invertiSegno(segnoContoEconomico))
{
Descrizione = descrizione,
Stato = StatoMovimentoContabileEnum.Evaso,
ContoCorrenteBancario = banca
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoBancario);
return movimentoBancario;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella contabilizzazione di un movimento bancario - {0} - importo:{1} - descrizione:{2} - data registrazione:{3:d}", ex, Utility.GetMethodDescription(), importo, descrizione, dataRegistrazione);
throw;
}
}
public IList<TestataMovimentoContabile> SetMovimentiVersamentoCondomino(TestataMovimentoContabile testata, MovimentoContabile movimentoPatrimonialeAttivo, Esercizio esercizio, VersamentoSoggetto versamento, DateTime dataRegistrazione, CausaleContabile causale, Conto contoVersamentoCondomini, int? idMovimentoBancario, FileCBI file, LogTransazione logTransazione)
{
var testate = new List<TestataMovimentoContabile>();
if(causale == null)
causale = _daoFactory.GetCausaleContabileDao().GetByCodice("RR");
if (contoVersamentoCondomini == null)
contoVersamentoCondomini = _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoVersamentiCondomini());
bool evasioneBancaria = false;
// ================================================================================
// Registrazione Movimenti Contabili per Versamento Condomino
// ================================================================================
var rateVersate = string.Empty;
foreach (var versamentoRata in versamento.Rate)
{
if (!string.IsNullOrEmpty(rateVersate))
rateVersate += ", ";
rateVersate += versamentoRata.Rata.PianoRatealeDettaglio.Progressivo;
}
if (!string.IsNullOrEmpty(rateVersate))
rateVersate = "(" + rateVersate + ")";
var descrizione = $"Versamento Rata di {versamento.Soggetto.DisplayName} {rateVersate}";
// ------------------------------------------------
// Testata
// ------------------------------------------------
if (testata == null)
{
testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, file, logTransazione)
{
Descrizione = descrizione
};
}
testate.Add(testata);
var message = IsAllowDataRegistrazione(new List<int>(), testata.EsercizioRiferimento, testata.DataRegistrazione.GetValueOrDefault());
if (message.Count > 0)
{
var ex = new InvalidDataException($"La data di registrazione {testata.DataRegistrazione.GetValueOrDefault()} non è valida");
_log.FatalFormat("Data di registrazione non valida - {0} - data:{1} - versamento:{2} - message:{3}", ex, Utility.GetMethodDescription(), testata.DataRegistrazione.GetValueOrDefault(), versamento.ID, message.Aggregate(string.Empty, (current, str) => current + string.Format("{0}{1}", message, Environment.NewLine)));
throw ex;
}
var numeroRiga = testata.Movimenti.Count;
// ------------------------------------------------
// Crediti V/S Condomini - a Saldo
// ------------------------------------------------
numeroRiga++;
var movimentoPatrimoniale = new MovimentoContabile(testata, causale, numeroRiga, contoVersamentoCondomini, versamento.Importo, "A")
{
CondominoRiferimento = versamento.Soggetto,
Descrizione = descrizione
};
// ------------------------------------------------
// Banca / Cassa
// ------------------------------------------------
if (movimentoPatrimonialeAttivo == null)
{
evasioneBancaria = true;
numeroRiga++;
movimentoPatrimonialeAttivo = new MovimentoContabile(testata, causale, numeroRiga, versamento.ContoPatrimoniale, versamento.Importo, "D")
{
Descrizione = descrizione,
SottoContoRiferimento = versamento.SottoContoPatrimoniale,
ContoCorrenteBancario = versamento.ContoBancario,
NumeroAssegno = versamento.NumeroAssegno
};
}
else
movimentoPatrimonialeAttivo.Importo = movimentoPatrimonialeAttivo.GetImportoSenzaSegno() + versamento.Importo;
// ================================================================================
// SOLO ESERCIZI ORDINARI
// Se la data di registrazione è successiva alla data di chiusura dell'esercizio
// registro i movimenti, usando un contro transitorio, che permette di rilevare
// il versamento nello stato patrimoniale dell'esercizio.
// ================================================================================
if (versamento.TipoVersamentoDopoChiusura.GetValueOrDefault() == TipoVersamentoDopoChiusuraEnum.Giroconto && esercizio.Gestione == GestioneEsercizioEnum.Ordinario)
{
var esercizioPrecedente = esercizio.GetEsercizioPrecedente();
if (esercizioPrecedente != null)
{
var causaleVersamentiCondominiDopoChiusura = _daoFactory.GetCausaleContabileDao().GetByCodice("VS");
var contoVersamentiDopoChiusura = _pianoContiService.GetContoVersamentiSuccessiviAllaChiusura(esercizio);
try
{
if (movimentoPatrimoniale.CondominoRiferimento != null)
{
var descrizioneStorno = string.Format("Versamento dopo data chiusura - {0} del {1} {2}", movimentoPatrimoniale.CondominoRiferimento.DisplayName, movimentoPatrimoniale.Testata.DataRegistrazione.GetValueOrDefault().ToShortDateString(), rateVersate);
// ---------------------------------------------------------------------------------------
// Movimenti per storno e riconoscimento versamenti ai condomini
// Nuova testata nell'esercizio precedente per registrare lo storno
// ---------------------------------------------------------------------------------------
var numeroRigaStorno = 0;
var testataStorno = new TestataMovimentoContabile(esercizioPrecedente, esercizioPrecedente.DataChiusura, TipoTestataMovimentoContabileEnum.Automatica, file, logTransazione)
{
Descrizione = descrizioneStorno
};
testate.Add(testataStorno);
numeroRigaStorno++;
var movimentoVersamento = new MovimentoContabile(testataStorno, causaleVersamentiCondominiDopoChiusura, numeroRigaStorno, movimentoPatrimoniale.ContoRiferimento, movimentoPatrimoniale.Importo, movimentoPatrimoniale.Segno)
{
CondominoRiferimento = movimentoPatrimoniale.CondominoRiferimento,
Descrizione = descrizioneStorno
};
numeroRigaStorno++;
var movimentoContoTemporaneo = new MovimentoContabile(testataStorno, causaleVersamentiCondominiDopoChiusura, numeroRigaStorno, contoVersamentiDopoChiusura, movimentoPatrimoniale.Importo, invertiSegno(movimentoPatrimoniale.Segno))
{
CondominoRiferimento = movimentoPatrimoniale.CondominoRiferimento,
Descrizione = descrizioneStorno
};
// ---------------------------------------------------------------------------------------
// Nella stessa testata del versamento originale aggiungo il movimento di chiusura del conto temporaneo
// ---------------------------------------------------------------------------------------
numeroRiga++;
var descrizioneChiusuraStorno = string.Format("Chiusura dello storno del versamento dopo data chiusura - {0} del {1} {2}", movimentoPatrimoniale.CondominoRiferimento.DisplayName, movimentoPatrimoniale.Testata.DataRegistrazione.GetValueOrDefault().ToShortDateString(), rateVersate);
var movimentoVersamentoChiusura = new MovimentoContabile(testata, causaleVersamentiCondominiDopoChiusura, numeroRiga, movimentoPatrimoniale.ContoRiferimento, movimentoPatrimoniale.Importo, invertiSegno(movimentoPatrimoniale.Segno))
{
CondominoRiferimento = movimentoPatrimoniale.CondominoRiferimento,
Descrizione = descrizioneChiusuraStorno
};
numeroRiga++;
var movimentoContoTemporaneoChiusura = new MovimentoContabile(testata, causaleVersamentiCondominiDopoChiusura, numeroRiga, contoVersamentiDopoChiusura, movimentoPatrimoniale.Importo, movimentoPatrimoniale.Segno)
{
CondominoRiferimento = movimentoPatrimoniale.CondominoRiferimento,
Descrizione = descrizioneChiusuraStorno
};
versamento.TestataMovimentoDopoChiusura = testataStorno;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la registrazione dei movimenti per i versamenti eseguiti dopo la chiusura - SINGOLO MOVIMENTO - {0} - esercizio:{1} - movimento:{2}", ex, Utility.GetMethodDescription(), esercizio.ID, movimentoPatrimoniale.ID);
throw;
}
}
else
{
_log.ErrorFormat("Esercizio precedente a null - {0} - versamento:{1} - esercizio:{2}", Utility.GetMethodDescription(), versamento.ID, esercizio.ID);
}
}
// ================================================================================
// SOLO ESERCIZI ORDINARI - bugid#6223
// Se la data di registrazione è antecedente alla data di apertura dell'esercizio
// registro i movimenti, usando un contro transitorio, che permette di rilevare
// il versamento nello stato patrimoniale dell'esercizio.
// ================================================================================
if (versamento.TipoVersamentoPrimaApertura.GetValueOrDefault() == TipoVersamentoPrimaAperturaEnum.Giroconto && esercizio.Gestione == GestioneEsercizioEnum.Ordinario)
{
var annoSuccessivo = _daoFactory.GetAnnoGestionaleDao().GetAnnoSuccessivo(esercizio.AnnoGestionale.ID);
if (annoSuccessivo != null)
{
if (annoSuccessivo.EsercizioOrdinario != null)
{
var causaleVersamentiCondominiPrimaApertura = _daoFactory.GetCausaleContabileDao().GetByCodice("VA");
var contoVersamentiPrecedentiAllaApertura = _pianoContiService.GetContoVersamentiPrecedentiAllaApertura(esercizio);
try
{
if (movimentoPatrimoniale.CondominoRiferimento != null)
{
var descrizioneStorno = string.Format("Versamento prima della data di apertura - {0} del {1} {2}", movimentoPatrimoniale.CondominoRiferimento.DisplayName, movimentoPatrimoniale.Testata.DataRegistrazione.GetValueOrDefault().ToShortDateString(), rateVersate);
// ---------------------------------------------------------------------------------------
// Movimenti per storno e riconoscimento versamenti ai condomini
// Nuova testata nell'esercizio successivo per registrare lo storno
// ---------------------------------------------------------------------------------------
var numeroRigaStorno = 0;
var testataStorno = new TestataMovimentoContabile(annoSuccessivo.EsercizioOrdinario, annoSuccessivo.EsercizioOrdinario.DataApertura, TipoTestataMovimentoContabileEnum.Automatica, file, logTransazione)
{
Descrizione = descrizioneStorno
};
testate.Add(testataStorno);
numeroRigaStorno++;
var movimentoVersamento = new MovimentoContabile(testataStorno, causaleVersamentiCondominiPrimaApertura, numeroRigaStorno, movimentoPatrimoniale.ContoRiferimento, movimentoPatrimoniale.Importo, movimentoPatrimoniale.Segno)
{
CondominoRiferimento = movimentoPatrimoniale.CondominoRiferimento,
Descrizione = descrizioneStorno
};
numeroRigaStorno++;
var movimentoContoTemporaneo = new MovimentoContabile(testataStorno, causaleVersamentiCondominiPrimaApertura, numeroRigaStorno, contoVersamentiPrecedentiAllaApertura, movimentoPatrimoniale.Importo, invertiSegno(movimentoPatrimoniale.Segno))
{
CondominoRiferimento = movimentoPatrimoniale.CondominoRiferimento,
Descrizione = descrizioneStorno
};
// ---------------------------------------------------------------------------------------
// Nella stessa testata del versamento originale aggiungo il movimento di chiusura del conto temporaneo
// ---------------------------------------------------------------------------------------
numeroRiga++;
var descrizioneChiusuraStorno = string.Format("Chiusura dello storno del versamento prima della data di apertura - {0} del {1} {2}", movimentoPatrimoniale.CondominoRiferimento.DisplayName, movimentoPatrimoniale.Testata.DataRegistrazione.GetValueOrDefault().ToShortDateString(), rateVersate);
var movimentoVersamentoChiusura = new MovimentoContabile(testata, causaleVersamentiCondominiPrimaApertura, numeroRiga, movimentoPatrimoniale.ContoRiferimento, movimentoPatrimoniale.Importo, invertiSegno(movimentoPatrimoniale.Segno))
{
CondominoRiferimento = movimentoPatrimoniale.CondominoRiferimento,
Descrizione = descrizioneChiusuraStorno
};
numeroRiga++;
var movimentoContoTemporaneoChiusura = new MovimentoContabile(testata, causaleVersamentiCondominiPrimaApertura, numeroRiga, contoVersamentiPrecedentiAllaApertura, movimentoPatrimoniale.Importo, movimentoPatrimoniale.Segno)
{
CondominoRiferimento = movimentoPatrimoniale.CondominoRiferimento,
Descrizione = descrizioneChiusuraStorno
};
versamento.TestataMovimentoDopoChiusura = testataStorno;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la registrazione dei movimenti per i versamenti eseguiti dopo la chiusura - SINGOLO MOVIMENTO - {0} - esercizio:{1} - movimento:{2}", ex, Utility.GetMethodDescription(), esercizio.ID, movimentoPatrimoniale.ID);
throw;
}
}
}
else
{
_log.ErrorFormat("Esercizio successivo a null - {0} - versamento:{1} - esercizio:{2}", Utility.GetMethodDescription(), versamento.ID, esercizio.ID);
}
}
// ================================================================================
// Evado il corrispondente Movimento Bancario
// ================================================================================
if (evasioneBancaria && idMovimentoBancario != null)
{
EvadiMovimento(string.Format("Evasione automatica per contabilizzazione versamento condomino del {0}", dataRegistrazione.ToShortDateString()), new List<MovimentoContabile> { movimentoPatrimonialeAttivo }, new List<int> { idMovimentoBancario.Value }, dataRegistrazione, logTransazione);
_log.DebugFormat("Evasione automatica per contabilizzazione versamento condomino - {0} - movimento economico:{1} - movimento bancario:{2} - data registrazione:{3}", Utility.GetMethodDescription(), movimentoPatrimoniale.ID, idMovimentoBancario.GetValueOrDefault(), dataRegistrazione);
}
versamento.MovimentoContabilePatrimoniale = movimentoPatrimonialeAttivo;
return testate;
}
private IEnumerable<RisultatoElaborazioneCBI> elaboraMav(string blocco, FileCBI file, int numeroRiga, IList<DatiBancariCondomini> datiBancari, IList<Conto> contiBancari, IList<Conto> contiVersamentoCondomini, CausaleContabile causaleVersamento, LogTransazione logTransazione)
{
return _mavCbiService.RicezioneMav(blocco, file, numeroRiga, datiBancari, contiBancari, contiVersamentoCondomini, causaleVersamento, logTransazione);
}
private IEnumerable<RisultatoElaborazioneCBI> elaboraBlocco(string blocco, FileCBI file, int numeroRiga, IList<DatiBancariCondomini> datiBancari, IList<Conto> contiBancari, IList<Conto> contiVersamentoCondomini, IList<MovimentiBancariControlloDuplicatiDTO> listaMovimentiBancari, CausaleContabile causaleVersamento, LogTransazione logTransazione)
{
var result = new List<RisultatoElaborazioneCBI>();
try
{
string codiceRiga = blocco.Substring(1, 2);
switch (codiceRiga)
{
case "CN":
result.AddRange(elaboraConfermaRicezione(blocco));
break;
case "EP":
result.AddRange(elaboraEsitoPagamento(blocco, file, numeroRiga));
break;
case "IM":
result.AddRange(elaboraMav(blocco, file, numeroRiga, datiBancari, contiBancari, contiVersamentoCondomini, causaleVersamento, logTransazione));
break;
case "RH":
result.AddRange(elaboraRendicontazioneMovimenti(blocco, file, listaMovimentiBancari, numeroRiga));
break;
case "EC":
result.AddRange(elaboraEstrattoContoPeriodico(blocco));
break;
case "RP":
result.AddRange(elaboraRendicontazionePortafoglio(blocco));
break;
case "A4":
result.AddRange(elaboraAccettazioneRifiutiF24(blocco));
break;
case "Q4":
result.AddRange(elaboraQuietanzaF24(blocco));
break;
default:
result.Add(new RisultatoElaborazioneCBI { Tipo = "Generico", Warning = string.Format("Trovata riga con codice non gestito: <strong>{0}</strong><br/><i>{1}</i><br/>", codiceRiga, blocco) });
_log.WarnFormat("Trovata riga con codice non gestito:{0}", codiceRiga);
break;
}
}
catch (Exception ex)
{
_log.FatalFormat("Errore inaspettato durante l'elaborazione del blocco - {0} - blocco:{1}", ex, Utility.GetMethodDescription(), blocco);
throw;
}
return result;
}
public ResultVersamento InsertVersamentoCondomino(Esercizio esercizio, RataSoggetto rata, DatiBancariCondomini banca, Conto contoBancario, CausaleContabile causaleVersamento, Conto contoVersamentoCondomini, DateTime dataVersamento, FileCBI file, LogTransazione logTransazione, TipoVersamentoDopoChiusuraEnum? tipoVersamentoDopoChiusura = null, TipoVersamentoPrimaAperturaEnum? tipoVersamentoPrimaApertura = null)
{
int? protocollo = null;
int? idMovimentoContabile = null;
var message = string.Empty;
var descrizione = string.Empty;
VersamentoSoggetto versamento = null;
// La richiesta del versamento può avvenire solo se il versamento è successivo alla data di chiusura dell'esercizio
if (dataVersamento <= esercizio.DataChiusura.GetValueOrDefault())
tipoVersamentoDopoChiusura = null;
// La richiesta del versamento prima dell'apertura può avvenire solo se il versamento è precedente alla data di apertura dell'esercizio
if (dataVersamento >= esercizio.DataApertura.GetValueOrDefault())
tipoVersamentoPrimaApertura = null;
try
{
// ----------------------------------------------------
// Creo Versamento
// ----------------------------------------------------
if (string.IsNullOrEmpty(message))
{
var progressivo = _protocolloService.GetProgressivo(TipoProtocollo.VersamentoCondomino, esercizio);
if (progressivo.Progressivo != null)
{
protocollo = progressivo.Progressivo;
// ------------------------------------------------------
// Trovo l'esercizio contabile, se non esiste oppure se è chiuso
// interrompo l'operazione di versamento
// ------------------------------------------------------
var esercizioContabile = esercizio;
if (esercizioContabile.Gestione == GestioneEsercizioEnum.Ordinario || (esercizioContabile.Gestione == GestioneEsercizioEnum.Straordinario && (esercizioContabile.Stato == StatoEsercizioEnum.Chiuso || esercizioContabile.DataChiusura.GetValueOrDefault() < dataVersamento)))
{
esercizioContabile = _daoFactory.GetEsercizioDao().GetEsercizioCompetenza(esercizio.CondominioRiferimento, dataVersamento);
if (esercizioContabile == null || esercizioContabile.Stato == StatoEsercizioEnum.Chiuso)
{
var messageEsercizio = esercizioContabile == null ? "l'esercizio di competenza non è ancora stato aperto" : $"l'esercizio '{esercizioContabile.DisplayName}' è chiuso";
return new ResultVersamento(null, null, null, null, null, $"Non è possibile registrare il versamento in data {dataVersamento.ToShortDateString()} perchè {messageEsercizio}.");
}
}
try
{
versamento = new VersamentoSoggetto(esercizio, rata.Soggetto, contoBancario, dataVersamento, rata.Importo, file, banca, logTransazione, tipoVersamentoDopoChiusura, tipoVersamentoPrimaApertura);
_movimentoContabileService.SetMovimentiVersamentoCondomino(null, null, esercizioContabile, versamento, dataVersamento, causaleVersamento, contoVersamentoCondomini, null, file, logTransazione);
}
catch (InvalidDataException exception)
{
_log.ErrorFormat("Errore inaspettato nella registrazione del versamento del condomino - {0} - esercizio:{1} - rata:{2}", Utility.GetMethodDescription(), esercizioContabile.ID, rata.ID);
if (versamento != null)
{
if (logTransazione != null)
{
logTransazione.Versamenti.Remove(versamento);
versamento.LogTransazione = null;
}
if (file != null)
{
file.Versamenti.Remove(versamento);
versamento.File = null;
}
esercizio.VersamentiCondomini.Remove(versamento);
versamento.Esercizio = null;
rata.Soggetto.Versamenti.Remove(versamento);
versamento.Soggetto = null;
versamento = null;
}
return new ResultVersamento(null, null, null, null, null, $"Non è possibile registrare il versamento in data {dataVersamento.ToShortDateString()} perchè {exception.Message}.");
}
setRataVersamentoDopoChiusura(versamento, esercizioContabile, logTransazione);
// ---------------------------------------------------------------------
// Se la rata non è ancora stata pagata associo il versamento alla rata
// ---------------------------------------------------------------------
// se la rata è già stata pagata, oppure se l'esercizio di riferimento è chiuso viene registrata come rata fuori piano rateale
if (rata.Stato != StatoRataEnum.Pagata && rata.Stato != StatoRataEnum.ParzialmentePagata && rata.Esercizio.Stato == StatoEsercizioEnum.Aperto )
{
var versamentoRata = new VersamentiRate(versamento, rata, rata.Importo);
rata.SetStato();
}
else
{
versamento.Causale = $"Versamento fuori piano rateale perchè la rata si trova in stato di {rata.Stato}";
}
idMovimentoContabile = versamento.MovimentoContabilePatrimoniale.ID;
descrizione = getDescrizioneVersamentoConfermato(versamento);
}
else
message += progressivo.Message + Environment.NewLine;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel metodo: {0} - rata:{1} - dataVersamento:{2}", ex, Utility.GetMethodDescription(), rata.ID, dataVersamento);
throw;
}
return new ResultVersamento(setVersamentoRicevutaDTO(versamento), null, protocollo, idMovimentoContabile, descrizione, message);
}
private IEnumerable<RisultatoElaborazioneCBI> elabora(string linea, int numeroRiga, IList<DatiBancariCondomini> datiBancari, IList<Conto> contiBancari, IList<Conto> contiVersamentiCondomini, CausaleContabile causaleVersamento, LogTransazione logTransazione)
{
var tipoRecord = string.Empty;
try
{
var anomalie = new List<RisultatoElaborazioneCBI>();
tipoRecord = linea.Substring(1, 2);
RisultatoElaborazioneCBI result = null;
RisultatoElaborazioneCBI resultConferma = null;
switch (tipoRecord)
{
case "IM":
result = elaboraTestataIM(linea);
break;
case "14":
_linea14 = linea;
result = elaboraMovimento14(linea, datiBancari);
break;
case "20":
result = elaboraMovimento20(linea);
break;
case "30":
result = elaboraMovimento30(linea);
break;
case "40":
result = elaboraMovimento40(linea);
break;
case "50":
result = elaboraMovimento50(linea);
break;
case "51":
result = elaboraMovimento51(linea);
break;
case "70":
result = elaboraMovimento70(linea);
resultConferma = confermaMovimento(contiBancari, contiVersamentiCondomini, causaleVersamento, logTransazione);
break;
}
if (result != null)
{
result.NumeroRiga = numeroRiga;
anomalie.Add(result);
}
if (resultConferma != null)
{
resultConferma.NumeroRiga = numeroRiga;
anomalie.Add(resultConferma);
}
return anomalie;
}
catch (Exception ex)
{
_log.FatalFormat("Errore inaspettato durante l'importazione dei MAV - {0} - tipoRecord:{1} - linea:{2}", ex, Utility.GetMethodDescription(), tipoRecord, linea);
throw;
}
}
public CausaleContabileDTO GetCausaleByDomainEntity(CausaleContabile causale)
{
try
{
return setCausaleDto(causale);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel caricamento delle causali contabili - {0} - id:{1}", ex, Utility.GetMethodDescription(), causale.ID);
throw;
}
}
private CausaleContabileDTO setCausaleDto(CausaleContabile causale)
{
var dto = new CausaleContabileDTO
{
ID = causale.ID,
Codice = causale.Codice,
Descrizione = causale.Descrizione,
DescrizioneCompleta = causale.Codice + " - " + causale.Descrizione,
Ordine = causale.Ordine,
PresenzaFornitore = causale.PresenzaFornitore,
UtilizzabileUtente = causale.UtilizzabileUtente
};
var conti = new string[causale.Conti.Count];
var index = 0;
foreach (var conto in causale.Conti)
{
conti[index] = conto.CodiceConto;
index++;
}
dto.Conti = conti;
return dto;
}
/// <summary>
/// Crea un movimento contabile valido.
/// E' relativo al conto patrimoniale relativo alla registrazione di una spesa
/// </summary>
public MovimentoContabile(TestataMovimentoContabile testata, Fornitore fornitore, CausaleContabile causale, int? numeroRiga, Conto conto, decimal? importo, string segno)
{
Causale = causale;
FornitoreRiferimento = fornitore;
NumeroRiga = numeroRiga;
ContoRiferimento = conto;
Testata = testata;
Importo = importo;
Segno = segno;
Stato = StatoMovimentoContabileEnum.Inserito;
IsVisibileGestione = true;
if (Testata != null)
{
Testata.Movimenti.Add(this);
setNumeroRegistrazione();
}
//if (FornitoreRiferimento != null)
// FornitoreRiferimento.MovimentiContabili.Add(this);
}
/// <summary>
/// Crea un movimento contabile valido.
/// E' relativo al conto economico connesso alla registrazione di una spesa
/// </summary>
public MovimentoContabile(TestataMovimentoContabile testata, Spesa spesa, CausaleContabile causale, int? numeroRiga, Conto conto, decimal? importo, string segno)
{
Causale = causale;
Spesa = spesa;
NumeroRiga = numeroRiga;
ContoRiferimento = conto;
Testata = testata;
Importo = importo;
Segno = segno;
Stato = StatoMovimentoContabileEnum.Inserito;
IsVisibileGestione = true;
if (Testata != null)
{
Testata.Movimenti.Add(this);
setNumeroRegistrazione();
}
if (Spesa != null)
Spesa.MovimentiBollette.Add(this);
}
/// <summary>
/// Crea un TipoFornitore valido
/// </summary>
public CausaleContabileConto(CausaleContabile causale, string conto)
{
CodiceConto = conto;
Causale = causale;
}
private RisultatoElaborazioneCBI confermaMovimento(IList<Conto> contiBancari, IList<Conto> contiVersamentiCondomini, CausaleContabile causaleVersamento, LogTransazione logTransazione)
{
RisultatoElaborazioneCBI anomalie = null;
if (_idDettaglioEmissioneRata != null)
{
var dettaglioEmissione = _daoFactory.GetDettaglioEmissioneRateDao().Find(_idDettaglioEmissioneRata.Value, false);
if (dettaglioEmissione != null)
{
if (string.IsNullOrEmpty(dettaglioEmissione.TestataEmissioneRate.Esercizio.CondominioRiferimento.Deleted))
{
var contoBancario = contiBancari.FirstOrDefault(item => item.CondominioRiferimento.ID == dettaglioEmissione.TestataEmissioneRate.Esercizio.CondominioRiferimento.ID);
if (contoBancario == null)
{
contoBancario = _daoFactory.GetContoDao().GetByCodice(dettaglioEmissione.TestataEmissioneRate.Esercizio.ID, dettaglioEmissione.TestataEmissioneRate.Esercizio.CondominioRiferimento.ID, "902");
if(contoBancario != null)
contiBancari.Add(contoBancario);
}
if (contoBancario != null)
{
// Controllo eventuali anomalie
var importoRate = dettaglioEmissione.RateCollegate.Sum(item => item.Importo);
if (importoRate != _importo)
anomalie = new RisultatoElaborazioneCBI { Warning = $"L'importo del versamento non corrisponde all'importo della rata, <strong><i>verificare se si tratta di una rata annullata manualmente</i></strong> senza usare l'apposita funzionalità presente in Sfera - <strong>Condomino: {_nomeDebitore}</strong> - Importo: <strong>{_importo.GetValueOrDefault():c}</strong> - Importo rata: <strong>{importoRate:c}</strong><br/>", Riga = _linea14 };
// Se non presenti anomalie elaboro la conferma
if (anomalie == null)
{
foreach (var rata in dettaglioEmissione.RateCollegate)
{
if (rata != null)
{
if (_causaleRicezione == "07000" || _causaleRicezione == "07011")
{
if (rata.Versamenti.Count > 0)
anomalie = new RisultatoElaborazioneCBI { Anomalie = $"La rata del condomino: <strong>{_nomeDebitore}</strong> <i>({rata.Esercizio.CondominioRiferimento.DisplayName})</i> - Importo: <strong>{_importo.Value}</strong> - Data scadenza: {rata.DataScadenza:d} è già stata <strong>SALDATA</strong>.<br/>", Riga = _linea14 };
if (rata.Esercizio.Stato == StatoEsercizioEnum.Chiuso)
anomalie = new RisultatoElaborazioneCBI { Anomalie = $"La rata del condomino: <strong>{_nomeDebitore}</strong> <i>({rata.Esercizio.CondominioRiferimento.DisplayName})</i> - Importo: <strong>{_importo.Value}</strong> - Data scadenza: {rata.DataScadenza} è relativa ad un <strong>ESERCIZIO CHIUSO</strong>.<br/>",Riga = _linea14 };
// Se non ho trovato la banca di accredito uso la banca principale del condominio
if (_banca == null)
_banca = rata.Esercizio.CondominioRiferimento.DatiBancariPrincipale;
// --------------------------------------------------------------------------------------------
// ATTENZIONE: Non viene usata la data di valuta perchè inaffidabile, nel CBI della BPER
// la data valuta corrisponde, erroneamente, alla data di scadenza
// --------------------------------------------------------------------------------------------
// Data di registrazione
if (_dataVersamento == null)
_dataVersamento = DateTime.Today.AddDays(-2);
var esercizioCompetenza = rata.Esercizio;
// -------------------------------------------------------------------
// Esercizio CHIUSO recupero quello di competenza
// -------------------------------------------------------------------
if (esercizioCompetenza.Stato == StatoEsercizioEnum.Chiuso)
esercizioCompetenza = _daoFactory.GetEsercizioDao().GetEsercizioCompetenza(esercizioCompetenza.CondominioRiferimento, _dataVersamento.GetValueOrDefault());
// -------------------------------------------------------------------
// Validazione KO - Non trovato esercizio di competenza
// -------------------------------------------------------------------
// Anche se sono presenti anomalie elaboro la conferma, i versamenti saranno registrati come: Versamenti fuori piano rateale
if (esercizioCompetenza == null || esercizioCompetenza.Stato == StatoEsercizioEnum.Chiuso)
{
if (anomalie == null)
anomalie = new RisultatoElaborazioneCBI();
anomalie.Fatal += $"Non è stato trovato nessun esercizio aperto per il condominio '{rata.Esercizio.CondominioRiferimento.DisplayName}' per registrare il versamento di {rata.Soggetto.DisplayName} per {rata.Importo:c} in data <b>{_dataVersamento.GetValueOrDefault():d}</b>.<br/>";
}
else
{
TipoVersamentoDopoChiusuraEnum? tipoVersamentoDopoChiusura = null;
if (_dataVersamento.GetValueOrDefault() > esercizioCompetenza.DataChiusura.GetValueOrDefault())
tipoVersamentoDopoChiusura = esercizioCompetenza.CondominioRiferimento.TipoVersamentoDopoChiusura;
TipoVersamentoPrimaAperturaEnum? tipoVersamentoPrimaApertura = null;
if (_dataVersamento.GetValueOrDefault() < esercizioCompetenza.DataApertura.GetValueOrDefault())
tipoVersamentoPrimaApertura = esercizioCompetenza.CondominioRiferimento.TipoVersamentoPrimaApertura;
// Trovo conto versamenti corretto
var contoVersamentoCondomini = contiVersamentiCondomini.FirstOrDefault(item => item.EsercizioRiferimento != null && item.EsercizioRiferimento.ID == rata.Esercizio.ID) ??
contiVersamentiCondomini.FirstOrDefault(item => item.EsercizioRiferimento == null && item.CondominioRiferimento.ID == rata.Esercizio.CondominioRiferimento.ID);
var resultVersamento =
_versamentiCondominiService.InsertVersamentoCondomino(
esercizioCompetenza, rata, _banca, contoBancario, causaleVersamento,
contoVersamentoCondomini, _dataVersamento.GetValueOrDefault(), _file,
logTransazione, tipoVersamentoDopoChiusura, tipoVersamentoPrimaApertura);
if (!string.IsNullOrEmpty(resultVersamento.Message))
{
anomalie = new RisultatoElaborazioneCBI
{
Anomalie = $"La rata del condomino: <strong>{_nomeDebitore}</strong> <i>({rata.Esercizio.CondominioRiferimento.DisplayName})</i> - Importo: <strong>{_importo.Value:c}</strong> - Data scadenza: {rata.DataScadenza:d} <strong>NON è stata registrata</strong>:<br/><strong>{resultVersamento.Message}</strong><br/>",
Riga = _linea14
};
break;
}
switch (_causaleRicezione)
{
case "07000":
rata.Emissione.Stato = StatoMavEnum.Pagato;
break;
case "07011":
rata.Emissione.Stato = StatoMavEnum.PagatoDopoRadiazione;
break;
}
}
}
}
else if (_causaleRicezione == "07008")
{
anomalie = new RisultatoElaborazioneCBI
{
Anomalie = $"La rata del condomino: <strong>{_nomeDebitore}</strong> <i>({rata.Esercizio.CondominioRiferimento.DisplayName})</i> - Importo: <strong>{_importo.Value:c}</strong> - Data scadenza: {rata.DataScadenza:d} è stata <strong>RICHIAMATA</strong><br/>",
Riga = _linea14
};
rata.SetStato(StatoRataEnum.Richiamata);
rata.DaRichiamare = false;
_movimentiContabiliService.SetMovimentiRichiamoRata(rata, logTransazione);
rata.Emissione.Stato = StatoMavEnum.Richiamato;
}
else if (_causaleRicezione == "07010")
{
anomalie = new RisultatoElaborazioneCBI
{
Anomalie = $"La rata del condomino: <strong>{_nomeDebitore}</strong> <i>({rata.Esercizio.CondominioRiferimento.DisplayName})</i> - Importo: <strong>{_importo.Value:c}</strong> - Data scadenza: {rata.DataScadenza:d} è stata <strong>RADIATA</strong> per mancato pagamento del condomino<br/>",
Riga = _linea14
};
rata.Emissione.Stato = StatoMavEnum.Radiato;
}
else if (_causaleRicezione == "07006")
{
anomalie = new RisultatoElaborazioneCBI
{
Anomalie = $"La rata del condomino: <strong>{_nomeDebitore}</strong> <i>({rata.Esercizio.CondominioRiferimento.DisplayName})</i> - Importo: <strong>{_importo.Value:c}</strong> - Data scadenza: {rata.DataScadenza:d} è stata <strong>RESA</strong> perché formalmente irregolare o comunque non idonea al trattamento<br/>",
Riga = _linea14
};
rata.Emissione.Stato = StatoMavEnum.Resa;
}
}
}
}
else
{
anomalie = new RisultatoElaborazioneCBI
{
Anomalie = $"Le rata del condominio: <strong>{dettaglioEmissione.TestataEmissioneRate.Esercizio.CondominioRiferimento.DisplayName}</strong> non possono essere caricate perchè non è stato trovato il conto corrente bancario<br/>",
Riga = _linea14
};
_log.ErrorFormat("Non è stato trovato il conto corrente bancario per il condominio - {0} - condominio:{1} - azienda:{2}", Utility.GetMethodDescription(), dettaglioEmissione.TestataEmissioneRate.Esercizio.CondominioRiferimento.ID, dettaglioEmissione.TestataEmissioneRate.Esercizio.CondominioRiferimento.Azienda.ID);
}
}
else
{
anomalie = new RisultatoElaborazioneCBI
{
Anomalie = $"Le rata del condominio: <strong>{dettaglioEmissione.TestataEmissioneRate.Esercizio.CondominioRiferimento.DisplayName}</strong> non possono essere caricate perchè non è stato trovato il condominio è annullato<br/>",
Riga = _linea14
};
_log.ErrorFormat("Condominio annullato - {0} - condominio:{1} - azienda:{2}", Utility.GetMethodDescription(), dettaglioEmissione.TestataEmissioneRate.Esercizio.CondominioRiferimento.ID, dettaglioEmissione.TestataEmissioneRate.Esercizio.CondominioRiferimento.Azienda.ID);
}
}
else
{
anomalie = new RisultatoElaborazioneCBI
{
Warning = $"Emissione NON trovata - Condomino: <strong>{_nomeDebitore}</strong> - Importo: <strong>{_importo.GetValueOrDefault():c}</strong><br/>",
Riga = _linea14
};
}
}
_idDettaglioEmissioneRata = null;
_importo = null;
_banca = null;
_dataScadenza = null;
_nomeDebitore = null;
return anomalie;
}
private void setMovimentoArrotondamento(TestataMovimentoContabile testata, CausaleContabile causale, LogTransazione logTransazione)
{
var importoDare = 0m;
var importoAvere = 0m;
foreach (var movimento in testata.Movimenti)
{
if (movimento.Segno == "D")
importoDare += movimento.Importo.GetValueOrDefault();
else
importoAvere += movimento.Importo.GetValueOrDefault();
}
var differenza = importoAvere - importoDare;
if (differenza != 0)
{
var numeroRiga = testata.Movimenti.Max(item => item.NumeroRiga.GetValueOrDefault()) + 1;
setMovimentoArrotondamento(importoAvere, importoDare, numeroRiga, null, testata, causale, null);
}
}
public string saveCausaleContabile(Azienda azienda, DettaglioTabellaSempliceDTO elemento, Gipasoft.Sfera.Enums.CRUDOperation operation, IDaoFactory daoFactory)
{
try
{
string message = string.Empty;
if (operation != Gipasoft.Sfera.Enums.CRUDOperation.Delete)
{
if (!string.IsNullOrEmpty(elemento.DescrizioneBreve))
{
if (elemento.DescrizioneBreve.Length > 2)
message = "Il codice della causale NON può essere più lungo di 2 caratteri:" + elemento.DescrizioneBreve;
}
else
message = "E' obbligatorio il codice della causale contabile";
var causali = daoFactory.GetCausaleContabileDao().GetByAzienda(_info.Azienda);
if (causali.Count(item => item.Codice == elemento.DescrizioneBreve && item.ID != elemento.Id) > 0)
message = $"E' già presente una causale col codice {elemento.DescrizioneBreve}";
}
if (string.IsNullOrEmpty(message))
{
CausaleContabile item = null;
if (elemento.Id > 0)
item = daoFactory.GetCausaleContabileDao().Find(elemento.Id, false);
else if(operation != Gipasoft.Sfera.Enums.CRUDOperation.Delete)
{
item = new CausaleContabile(elemento.DescrizioneBreve, elemento.Descrizione, true) {Ordine = elemento.Ordine};
daoFactory.GetCausaleContabileDao().SaveOrUpdate(item);
}
if (item != null)
{
switch (operation)
{
case Gipasoft.Sfera.Enums.CRUDOperation.Update:
item.Descrizione = elemento.Descrizione;
item.Codice = elemento.DescrizioneBreve;
item.Azienda = azienda;
item.Ordine = elemento.Ordine;
break;
case Gipasoft.Sfera.Enums.CRUDOperation.Delete:
daoFactory.GetCausaleContabileDao().Delete(item);
break;
}
}
}
return message;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel salvataggio della causale contabile - {0} - id:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), elemento.Id, _info.Azienda);
throw;
}
}
private void setMovimentoArrotondamento(decimal importoAvere, decimal importoDare, int numeroRiga, Spesa spesa, TestataMovimentoContabile testata, CausaleContabile causale, LogTransazione logTransazione)
{
if (importoAvere != importoDare)
{
var importoArrotondamento = importoAvere - importoDare;
numeroRiga++;
var segno = "D";
if (importoArrotondamento < 0)
{
segno = "A";
importoArrotondamento = importoArrotondamento * -1;
}
var contoArrotondamenti = _pianoContiService.GetContoArrotondamenti(testata.EsercizioRiferimento);
_daoFactory.GetContoDao().SaveOrUpdate(contoArrotondamenti);
var movimentoArrotondamento = new MovimentoContabile(testata, causale, numeroRiga, contoArrotondamenti, importoArrotondamento, segno)
{
Descrizione = spesa != null ? string.Format("Arrotondamento Fatt. n. {0} del {1:d}", spesa.NumeroDocumento, spesa.DataDocumento.GetValueOrDefault()) : string.Format("Arrotondamento per {0}", testata.GetDescrizione())
};
if(logTransazione == null)
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoArrotondamento);
}
}
public List<RisultatoElaborazioneCBI> RicezioneMav(string blocco, FileCBI file, int numeroRiga, IList<DatiBancariCondomini> datiBancari, IList<Conto> contiBancari, IList<Conto> contiVersamentiCondomini, CausaleContabile casualeVersamento, LogTransazione logTransazione)
{
var anomalie = new List<RisultatoElaborazioneCBI>();
_file = file;
try
{
var riga = blocco.Substring(0, 120);
var codiceRiga = riga.Substring(1, 2);
var index = 0;
while (codiceRiga != "EF")
{
try
{
numeroRiga++;
anomalie.AddRange(elabora(riga, numeroRiga, datiBancari, contiBancari, contiVersamentiCondomini, casualeVersamento, logTransazione));
index += 120;
riga = blocco.Substring(index, 120);
codiceRiga = riga.Substring(1, 2);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante l'importazione dei MAV - {0} - blocco:{1}", ex, Utility.GetMethodDescription(), blocco);
throw;
}
}
numeroRiga++;
anomalie.AddRange(elabora(riga, numeroRiga, datiBancari, contiBancari, contiVersamentiCondomini, casualeVersamento, logTransazione));
return formattaMessaggi(anomalie);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante l'importazione dei MAV - {0} - numeroRiga:{1}", ex, Utility.GetMethodDescription(), numeroRiga);
}
return formattaMessaggi(anomalie);
}