/// <summary>
/// Crea un Versamento Condomino valido.
/// </summary>
public VersamentoSoggetto(Esercizio esercizio, SoggettoCondominio soggetto, Conto conto, DateTime data, decimal importo, FileCBI file, DatiBancariCondomini contoBancario, LogTransazione logTransazione, TipoVersamentoDopoChiusuraEnum? tipoVersamentoDopoChiusura = null, TipoVersamentoPrimaAperturaEnum? tipoVersamentoPrimaApertura = null)
: this(esercizio, soggetto, conto, data, importo, 0, TipoVersamentoSoggettoEnum.CBI, logTransazione, tipoVersamentoDopoChiusura, tipoVersamentoPrimaApertura)
{
ContoBancario = contoBancario;
File = file;
if (File != null)
File.Versamenti.Add(this);
}
/// <summary>
/// Crea una Testata di movimento contabile valida
/// </summary>
public SaldoBancario(string abi, string cab, string contoCorrente, decimal? importoContabile, decimal? importoLiquido, DateTime? data, FileCBI file)
{
Abi = abi;
Cab = cab;
ContoCorrente = contoCorrente;
ImportoContabile = importoContabile;
ImportoLiquido = importoLiquido;
Data = data;
File = file;
if (File != null)
File.SaldiBancari.Add(this);
}
/// <summary>
/// Crea una Testata di movimento contabile valida
/// </summary>
public MovimentoBancario(string abi, string cab, string contoCorrente, decimal? importo, string segno, DateTime? dataValuta, DateTime? dataContabile, string causale, FileCBI file)
{
Abi = abi;
Cab = cab;
ContoCorrente = contoCorrente;
Importo = importo;
DataValuta = dataValuta;
DataContabile = dataContabile;
Causale = causale;
Segno = segno;
File = file;
Stato = StatoMovimentoBancarioEnum.Inserito;
if (File != null)
File.MovimentiBancari.Add(this);
}
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> elaboraRendicontazioneMovimenti(string blocco, FileCBI file, IList<MovimentiBancariControlloDuplicatiDTO> listaMovimentiBancari, int numeroRiga)
{
return _movimentiBancariService.ImportazioneMovimentiBancari(blocco, file, _fornitori, _personeAzienda, listaMovimentiBancari, numeroRiga);
}
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> elaboraEsitoPagamento(string blocco, FileCBI file, int numeroRiga)
{
var result = new List<RisultatoElaborazioneCBI>();
try
{
// -------------------------------------------------------
// Testata
// -------------------------------------------------------
var testata = blocco.Substring(0, 120);
var abiBanca = testata.Substring(3, 5);
var codiceSiaAzienda = testata.Substring(8, 5);
var dataCreazioneFlusso = convertToData(testata.Substring(13, 6));
var nomeSupporto = testata.Substring(19, 20);
// -------------------------------------------------------
// Esito
// -------------------------------------------------------
var index = 120;
var riga = blocco.Substring(index, 120);
var codiceRiga = riga.Substring(1, 2);
while (codiceRiga != "EF")
{
// Riga 10 riconcilazione
if (codiceRiga == "10")
{
try
{
string riga10 = riga;
// Pagamento
string idPagamentoStr = riga10.Substring(10, 30).Trim();
if (!string.IsNullOrEmpty(idPagamentoStr))
{
int idPagamento;
if (int.TryParse(idPagamentoStr, out idPagamento))
{
var importo = decimal.Parse(riga10.Substring(40, 13)) / 100;
var modalitaPagamento = riga10.Substring(100, 1);
// Condominio
string codiceSiaCondominio = riga10.Substring(53, 5);
// CRO
var tipoCodice = riga10.Substring(58, 1);
var codice = riga10.Substring(59, 35);
// Causale
var causale = riga10.Substring(94, 5);
// Anomalia
string anomalia = riga10.Substring(99, 1);
// Aggiornamento stato pagamento
var pag = _pagamentoService.ConfermaPagamento(idPagamento, tipoCodice, codice);
if (pag != null)
pag.File = file;
else
{
_log.WarnFormat("Errore inaspettato durante la conferma del pagamento. Probabilmente non è stato trovato il pagamento. - {0} - idPagamento:{1} - file:{2}", Utility.GetMethodDescription(), idPagamento, file.ID);
result.Add(new RisultatoElaborazioneCBI { Tipo = "Esito Pagamento", Anomalie = "Probabilmente non è stato trovato il pagamento con id: <strong>" + idPagamento + "</strong>. Si prega di verificare.<br/>" });
}
}
else
{
_log.WarnFormat("Avvertenza durante la conferma del pagamento - {0} - codice:10 - riga10:{1} - azienda:{2} - blocco:{3} - fileCbi:{4} - numeroRiga:{5}", Utility.GetMethodDescription(), riga, Security.Login.Instance.CurrentLogin().Azienda, blocco, file.ID, numeroRiga);
result.Add(new RisultatoElaborazioneCBI { Tipo = "Esito Pagamento", Anomalie = "Avvertimento relativo ad un pagamento. Questa è la riga arrivata dalla banca: <i>" + riga.Trim() + "</i>. Si prega di verificare.<br/>" });
}
}
else
{
_log.DebugFormat("Avvertenza durante la conferma del pagamento - ID PAGAMENTO A NULL - {0} - codice:10 - riga10:{1} - azienda:{2} - blocco:{3} - fileCbi:{4} - numeroRiga:{5}", Utility.GetMethodDescription(), riga, Security.Login.Instance.CurrentLogin().Azienda, blocco, file.ID, numeroRiga);
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la conferma del pagamento - {0} - codice:10 - riga10:{1} - azienda:{2} - blocco:{3} - fileCbi:{4} - numeroRiga:{5}", ex, Utility.GetMethodDescription(), riga, Security.Login.Instance.CurrentLogin().Azienda, blocco, file.ID, numeroRiga);
result.Add(new RisultatoElaborazioneCBI { Tipo = "Esito Pagamento", Anomalie = "Errore inaspettato nella conferma del pagamento. Questa è la riga arrivata dalla banca: <i>" + riga.Trim() + "</i>. Si prega di verificare.<br/>" });
}
}
// Riga 20 - Informazioni aggiuntive circa le modalità di esecuzione ed addebito della disposizione originaria.
// 11-16 f n Valuta ordinante
// 17-22 f n Valuta beneficiario
// 23-28 f n Data ordine
// 29-34 f n Data contabile di addebito
// 35-40 f n Data esecuzione
if (codiceRiga == "20")
{
}
// Lettura altra riga
index += 120;
riga = blocco.Substring(index, 120);
codiceRiga = riga.Substring(1, 2);
numeroRiga++;
}
}
catch (Exception ex)
{
_log.FatalFormat("Errore inaspettato durante la conferma del pagamento - {0} - azienda:{1} - blocco:{2} - numeroRiga:{3}", ex, Utility.GetMethodDescription(), file.Azienda.ID, blocco, numeroRiga);
result.Add(new RisultatoElaborazioneCBI { Tipo = "Esito Pagamento", Anomalie = "Errore inaspettato nella conferma del pagamento. - Questa è la riga arrivata dalla banca: <i>" + blocco.Trim() + "</i>. Si prega di verificare.<br/>" });
}
return result;
}
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 FileCBIDTO ImportaFile(DocumentInfo doc, int idAzienda, LogTransazione logTransazione)
{
var anomalie = new List<RisultatoElaborazioneCBI>();
FileCBI file;
var fileGiaCaricato = false;
StreamReader objReader = null;
try
{
byte[] b;
using (var streamDecompress = new MemoryStream())
{
using (var gZipStream = new GZipStream(new MemoryStream(doc.Body), CompressionMode.Decompress))
{
b = new byte[doc.Length];
while (true)
{
var n = gZipStream.Read(b, 0, b.Length);
if (n > 0)
streamDecompress.Write(b, 0, n);
else
break;
}
}
}
// ------------------------------------------------------
// Controlli
// ------------------------------------------------------
var checkSum = Utility.GetFileChecksum(b);
var fileEsistente = _daoFactory.GetFileCBIDao().GetByChecksum(checkSum);
if (fileEsistente != null)
{
anomalie.Add(new RisultatoElaborazioneCBI { Tipo="Generico", Anomalie = "<strong>Il file è già stato caricato.</strong>" });
file = fileEsistente;
fileGiaCaricato = true;
}
else
{
// ------------------------------------------------------
// Creo file
// ------------------------------------------------------
const string extension = ".cbi";
var fileName = string.Format("CBI_{0:s}_{1}{2}", DateTime.Now, idAzienda.ToString(CultureInfo.InvariantCulture).PadRight(5, '0'), extension);
_documentService.SaveDocument(b, fileName, extension, checkSum, idAzienda);
file = new FileCBI(checkSum, _daoFactory.GetAziendaDao().GetById(idAzienda, false), logTransazione);
// ------------------------------------------------------
// Leggo file
// ------------------------------------------------------
var fileInfo = _documentService.GetFileInfo(checkSum, idAzienda);
objReader = new StreamReader(fileInfo.FullName);
// ------------------------------------------------------
// Carico l'elenco dei fornitori
// ------------------------------------------------------
var db = new FornitoreDataContext(_daoFactory.GetFornitoreDao().GetConnection().ConnectionString);
_fornitori = db.GetAll_Fornitori(idAzienda).ToList();
// ------------------------------------------------------
// Carico l'elenco delle persone relative all'azienda
// ------------------------------------------------------
_personeAzienda = PreLoadedCollection.Instance.GetPersone(idAzienda);
// ------------------------------------------------------
// Carico tutti i movimenti bancari caricati per l'azienda
// ------------------------------------------------------
// Per ora nessun controllo per movimenti bancari duplicati bugid#4010
//var listaMovimentiBancari = _daoFactory.GetMovimentoBancarioDao().GetMovimentiCaricatiByAzienda(idAzienda);
var listaMovimentiBancari = new List<MovimentiBancariControlloDuplicatiDTO>();
// ------------------------------------------------------
// Carico l'elenco dei dati bancari dei condomini
// ------------------------------------------------------
var datiBancari = _daoFactory.GetDatiBancariCondominiDao().GetByAzienda(idAzienda);
var contiBancari = _daoFactory.GetContoDao().GetAllByAziendaCodice(idAzienda, _pianoContiService.GetCodiceContoBancario());
var contiVersamentoCondomini = _daoFactory.GetContoDao().GetAllByAziendaCodice(idAzienda, _pianoContiService.GetCodiceContoVersamentiCondomini());
var causaleVersamento = _daoFactory.GetCausaleContabileDao().GetByCodice("RR");
// ------------------------------------------------------
// Elaboro il contenuto
// ------------------------------------------------------
var sLine = string.Empty;
var index = 0;
while (sLine != null)
{
try
{
index++;
sLine = objReader.ReadLine();
if (sLine != null)
{
// Controllo la prima riga
if (index == 1)
{
var risultatoCheck = checkFile(sLine);
if (risultatoCheck != null)
anomalie.Add(risultatoCheck);
if(anomalie.Count > 0)
return new FileCBIDTO { ID = 0, Risultato = anomalie };
}
// Individuo un blocco che inizia con un codice riconosciuto e finisce con "EF"
var blocco = string.Empty;
while ((string.IsNullOrEmpty(sLine) || sLine.Length < 3 || sLine.Substring(0, 3) != " EF") && !objReader.EndOfStream)
{
if (sLine != null)
{
blocco += sLine;
sLine = objReader.ReadLine();
}
}
blocco += sLine;
if(!string.IsNullOrEmpty(blocco))
anomalie.AddRange(elaboraBlocco(blocco, file, index, datiBancari, contiBancari, contiVersamentoCondomini, listaMovimentiBancari, causaleVersamento, logTransazione));
}
}
catch (Exception ex)
{
_log.FatalFormat("Errore inaspettato durante l'elaborazione della riga - {0} - sLine:{1}", ex, Utility.GetMethodDescription(), sLine);
throw;
}
}
_daoFactory.GetFileCBIDao().SaveOrUpdate(file);
//foreach (var testataContabile in file.TestateContabili)
// _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testataContabile);
}
}
catch (Exception ex)
{
_log.FatalFormat("Errore inaspettato durante l'importazione del file CBI - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), idAzienda);
throw;
}
finally
{
if (objReader != null)
objReader.Close();
}
var risultato = (from ris in anomalie
where ris != null
select ris).ToList();
if (risultato.Count > 0)
{
var messaggioFormattatoWarning = formattaMessaggiWarning(risultato);
if (!string.IsNullOrEmpty(messaggioFormattatoWarning))
{
var warnMessage = messaggioFormattatoWarning;
if (warnMessage.Length > 3500)
warnMessage = warnMessage.Substring(0, 3500);
_log.WarnFormat("Importazione File CBI - Warning verificatisi:{0}", warnMessage);
}
string messaggioFormattatoAnomalie = formattaMessaggiAnomalie(risultato);
if (!string.IsNullOrEmpty(messaggioFormattatoAnomalie))
{
var warnMessage = messaggioFormattatoAnomalie;
if (warnMessage.Length > 3500)
warnMessage = warnMessage.Substring(0, 3500);
_log.WarnFormat("Importazione File CBI - Anomalie verificatisi:{0}", warnMessage);
}
if (!fileGiaCaricato)
{
file.Messaggi = messaggioFormattatoWarning;
file.Anomalie = messaggioFormattatoAnomalie;
}
if(risultato.Any(item => !string.IsNullOrEmpty(item.Fatal)))
_persistenceContext.RollbackAndCloseSession(Security.Login.Instance.CurrentLogin().LoginName);
}
return new FileCBIDTO { ID = file.ID, Risultato = risultato };
}
/// <summary>
/// Crea una Testata di movimento contabile valida
/// </summary>
public TestataMovimentoContabile(Esercizio esercizio, DateTime? dataRegistrazione, TipoTestataMovimentoContabileEnum tipo, FileCBI file, LogTransazione logTransazione) : this(esercizio, dataRegistrazione, tipo, logTransazione)
{
File = file;
if (File != null)
File.TestateContabili.Add(this);
}
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);
}
public List<RisultatoElaborazioneCBI> ImportazioneMovimentiBancari(string blocco, FileCBI file, IList<FornitoreListaDTO> fornitori, IList<PersonaListaDTO> personeAzienda, IList<MovimentiBancariControlloDuplicatiDTO> listaMovimentiBancari, int numeroRiga)
{
_file = file;
_fornitori = fornitori;
_personeAzienda = personeAzienda;
var anomalie = new List<RisultatoElaborazioneCBI>();
try
{
var riga = blocco.Substring(0, 120);
var codiceRiga = riga.Substring(1, 2);
var index = 0;
while (codiceRiga != "EF")
{
try
{
anomalie.AddRange(elabora(riga, listaMovimentiBancari));
index += 120;
riga = blocco.Substring(index, 120);
codiceRiga = riga.Substring(1, 2);
}
catch (ArgumentOutOfRangeException ex)
{
_log.ErrorFormat("Errore inaspettato durante l'importazione dei movimenti bancari - SINGOLA RIGA - {0} - index:{1} - codiceRiga:{2} - riga:{3} - numeroRiga:{4} - blocco:{5}", ex, Utility.GetMethodDescription(), index, codiceRiga, riga, numeroRiga, blocco);
throw new InvalidDataException("Il formato della riga CBI non è corretto");
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante l'importazione dei movimenti bancari - SINGOLA RIGA - {0} - index:{1} - codiceRiga:{2} - riga:{3} - numeroRiga:{4} - blocco:{5}", ex, Utility.GetMethodDescription(), index, codiceRiga, riga, numeroRiga, blocco);
throw;
}
}
elabora(riga, listaMovimentiBancari);
return formattaMessaggi(anomalie);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante l'importazione dei movimenti bancari - {0} - numeroRiga:{1} - blocco:{2}", ex, Utility.GetMethodDescription(), numeroRiga, blocco);
throw;
}
}
public int ImportazioneMovimentiBancari(byte[] array, long length, int idAzienda, int numeroRiga, IList<MovimentiBancariControlloDuplicatiDTO> listaMovimentiBancari, LogTransazione logTransazione)
{
StreamReader objReader = null;
try
{
var streamDecompress = new MemoryStream();
var gZipStream = new GZipStream(new MemoryStream(array), CompressionMode.Decompress);
var b = new byte[length];
while (true)
{
int n = gZipStream.Read(b, 0, b.Length);
if (n > 0)
streamDecompress.Write(b, 0, n);
else
break;
}
//return stream.ToArray();
//FileInfo fileInfo = new FileInfo(fileName);
//int step = Convert.ToInt32(fileInfo.Length * 0.000081910045f);
var step = length;
_personeAzienda = PreLoadedCollection.Instance.GetPersone(idAzienda);
_file = new FileCBI(Utility.GetFileChecksum(b), _daoFactory.GetAziendaDao().GetById(idAzienda, false), logTransazione);
streamDecompress.Seek(0, SeekOrigin.Begin);
objReader = new StreamReader(streamDecompress);
var sLine = string.Empty;
var index = 0;
while (sLine != null)
{
index++;
numeroRiga++;
sLine = objReader.ReadLine();
if (sLine != null)
{
elabora(sLine, listaMovimentiBancari);
if(index % step == 0)
onLoadedItem(new LoadedItemEventArgs(index));
}
}
_daoFactory.GetFileCBIDao().SaveOrUpdate(_file);
return _file.ID;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante l'importazione dei movimenti bancari - {0}", ex, Utility.GetMethodDescription());
}
finally
{
if(objReader != null)
objReader.Close();
}
return -1;
}
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);
}