/// <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); }