/// <summary> /// Crea una rata di pagamento condomino valida. /// </summary> public VersamentiRate(VersamentoSoggetto versamento, RataSoggetto rata, decimal importo) { Versamento = versamento; Rata = rata; Importo = importo; if (Rata != null) Rata.Versamenti.Add(this); if (Versamento != null) Versamento.Rate.Add(this); }
public string CreazioneRateFuoriPreventivo(Esercizio esercizio, Dictionary<DateTime, Dictionary<int, RataSoggettoDTO>> listaRate, bool daSubentro, string descrizione, LogTransazione logTransazione) { var message = string.Empty; var pianoCorrente = _daoFactory.GetPianoRatealeDao().GetByEsercizio(esercizio); if (pianoCorrente == null) { pianoCorrente = new PianoRateale(esercizio, TipoAccorpamentoRateEnum.Nessuno, logTransazione); _daoFactory.GetPianoRatealeDao().SaveOrUpdate(pianoCorrente); } foreach (var kvp in listaRate) { LogTransazione logTransazioneDettaglio = null; if (pianoCorrente.ID > 0) logTransazioneDettaglio = logTransazione; var dettaglio = new PianoRatealeDettaglio(pianoCorrente, kvp.Key, null, 0, daSubentro, logTransazioneDettaglio) { Importo = kvp.Value.Sum(rata => rata.Value.Importo) }; if (pianoCorrente.ID == 0) dettaglio.IsAcconto = true; if (!string.IsNullOrEmpty(descrizione) && descrizione.Length > 50) descrizione = descrizione.Substring(0, 50); dettaglio.Descrizione = descrizione; _daoFactory.GetPianoRatealeDettaglioDao().SaveOrUpdate(dettaglio); var progressivo = 0; foreach (var kvpDett in kvp.Value) { progressivo++; var rata = new RataSoggetto(dettaglio, _daoFactory.GetSoggettoCondominioDao().GetById(kvpDett.Value.IdSoggettoCondominio, false), kvp.Key, kvpDett.Value.Importo.GetValueOrDefault(), logTransazione) { Progressivo = progressivo }; _daoFactory.GetRataSoggettoDao().SaveOrUpdate(rata); } } return message; }
private RataSoggettoDTO setDto(RataSoggetto item) { var dto = new RataSoggettoDTO { Version = item.Version, DataScadenza = item.DataScadenza, DescrizioneUnitaImmobiliare = item.Soggetto.UnitaImmobiliare.Descrizione, ID = item.ID, IdEsercizio = item.Esercizio.ID, DescrizioneEsercizio = item.Esercizio.DisplayName, IdSoggettoCondominio = item.Soggetto.ID, DescrizioneSoggettoCondominio = item.Soggetto.DisplayName, IdUnitaImmobiliare = item.Soggetto.UnitaImmobiliare.ID, OrdineUnitaImmobiliare = item.Soggetto.UnitaImmobiliare.Ordine.GetValueOrDefault(), IdPersona = item.Soggetto.Persona.ID, TipoSoggettoCondominio = item.Soggetto.Tipo, Importo = item.Importo, Progressivo = item.Progressivo, StatoRata = item.Stato, Alert = false }; if (item.PianoRatealeDettaglio != null) { dto.DisplayName = item.PianoRatealeDettaglio.Descrizione; dto.IdPianoDettaglioRatealeRiferimento = item.PianoRatealeDettaglio.ID; } if (item.SoggettoEmissione != null) { dto.IdSoggettoEmissione = item.SoggettoEmissione.ID; dto.DescrizioneSoggettoEmissione = item.SoggettoEmissione.DisplayName; } if (item.Emissione != null) { dto.IdTestataEmissione = item.Emissione.TestataEmissioneRate.ID; dto.IdDettaglioEmissione = item.Emissione.ID; dto.DataEmissione = item.Emissione.TestataEmissioneRate.Data; if (item.Emissione.Stato == StatoMavEnum.Radiato && item.Stato != StatoRataEnum.Pagata && item.Stato != StatoRataEnum.ParzialmentePagata) dto.Alert = true; } return dto; }
public TestataMovimentoContabile SetMovimentiSingolaRata(RataSoggetto rata, decimal importo, SoggettoCondominio soggetto, Esercizio esercizio, TestataMovimentoContabile testata, DateTime dataRegistrazione) { return null; var numeroRiga = 0; var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("ER"); var message = IsAllowDataRegistrazione(new List<int> {esercizio.CondominioRiferimento.ID}, esercizio, dataRegistrazione); if (message.Count > 0) { _log.ErrorFormat("Tentativo di registrazione con data esterno all'intervallo consentito - {0} - rata:{1} - importo:{2} - soggetto:{3} - esercizio:{4}", Utility.GetMethodDescription(), rata.ID, importo, soggetto.ID, esercizio.ID); throw new InvalidDataException(string.Format("Tentativo di registrazione con data esterno all'intervallo consentito - data:{0}", dataRegistrazione.ToShortDateString())); } // ------------------------------------------------ // Testata // ------------------------------------------------ if (testata == null) { testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null); _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata); } else numeroRiga = testata.Movimenti.Max(mov => mov.NumeroRiga.GetValueOrDefault()); // ------------------------------------------------ // Rata // ------------------------------------------------ numeroRiga++; var movimentoPatrimoniale = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoRateCondomini()), importo, "A") {CondominoRiferimento = soggetto}; string descrizioneRata; if (rata != null) descrizioneRata = "Rata n." + rata.PianoRatealeDettaglio.Progressivo; else descrizioneRata = "Rata"; movimentoPatrimoniale.Descrizione = descrizioneRata + " - " + movimentoPatrimoniale.CondominoRiferimento.DisplayName; _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale); // ------------------------------------------------ // Crediti V/S Condomini // ------------------------------------------------ numeroRiga++; var movimentoPatrimonialeCrediti = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoVersamentiCondomini()), importo, "D") { CondominoRiferimento = soggetto, Descrizione = movimentoPatrimoniale.Descrizione }; _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimonialeCrediti); return testata; }
private void addRataDaEmettere(SoggettoCondominio soggetto, Esercizio esercizio, RataSoggetto rata, Dictionary<int, RataSoggettoDTO> listaRate, decimal importo) { RataSoggettoDTO rataDto; if (listaRate.ContainsKey(soggetto.ID)) rataDto = listaRate[soggetto.ID]; else { rataDto = new RataSoggettoDTO { IdSoggettoCondominio = soggetto.ID, DataScadenza = rata.DataScadenza, IdEsercizio = esercizio.ID, DescrizioneEsercizio = esercizio.DisplayName, IdUnitaImmobiliare = soggetto.UnitaImmobiliare.ID, IdPersona = soggetto.Persona.ID, Subalterno = soggetto.UnitaImmobiliare.Subalterno, Importo = 0 }; listaRate.Add(soggetto.ID, rataDto); } rataDto.Importo += importo; }
public void setStatoRataDisplay(RataPersonaDTO dto, RataSoggetto rata) { switch (rata.Stato) { case StatoRataEnum.Pagata: dto.StatoRataDisplay = StatoRataEnumDisplay.Pagata; break; case StatoRataEnum.ParzialmentePagata: dto.StatoRataDisplay = StatoRataEnumDisplay.ParzialmentePagata; break; case StatoRataEnum.Inserita: case StatoRataEnum.Spedita: case StatoRataEnum.ParzialmenteSpedita: if (dto.DataScadenza < DateTime.Today) dto.StatoRataDisplay = StatoRataEnumDisplay.Scaduta; else if (dto.DataScadenza < DateTime.Today.AddDays(7)) dto.StatoRataDisplay = StatoRataEnumDisplay.InScadenza; else dto.StatoRataDisplay = StatoRataEnumDisplay.Inserita; break; } }
private DettaglioEmissioneRateDTO ToEmissioneDTO(RataSoggetto rata) { var dettaglio = new DettaglioEmissioneRateDTO { DataScadenza = rata.DataScadenza, DescrizioneSoggettoCondominio = rata.Soggetto.DisplayName, VersamentoMav = rata.Soggetto.VersamentoMav, IdEsercizio = rata.Esercizio.ID, IdSoggettoCondominio = rata.Soggetto.ID, Importo = rata.Importo, Progressivo = rata.Progressivo, IdRataSingola = rata.ID, StatoRata = rata.Stato, IdUnitaImmobiliare = rata.Soggetto.UnitaImmobiliare.ID, DescrizioneUnitaImmobiliare = rata.Soggetto.UnitaImmobiliare.Descrizione, TipoUnitaImmobiliare = rata.Soggetto.UnitaImmobiliare.TipoUnitaImmobiliare.Descrizione, Rate = new List<DettaglioRataEmissioneRateDTO>(), }; return dettaglio; }
private AuthorizationMessages deleteRata(RataSoggetto rata, bool force, bool cancelIfNotDeleted = false) { try { var fatalMessage = string.Empty; var warnMessage = string.Empty; if (!rata.DaRichiamare && rata.Stato != StatoRataEnum.Richiamata) { var allowDeleteMessage = IsAllowDeleteRata(rata.ID); if (string.IsNullOrEmpty(allowDeleteMessage.FatalMessage)) { // ================================================================= // Se la rata è già stata emessa NON viene eliminata ma annullata // ================================================================= if (rata.Emissione != null) { var messaggeAnnullamento = annullamentoRata(rata); if (!string.IsNullOrEmpty(messaggeAnnullamento.FatalMessage)) fatalMessage += messaggeAnnullamento.FatalMessage + Environment.NewLine; if (!string.IsNullOrEmpty(messaggeAnnullamento.WarnMessage)) { warnMessage += messaggeAnnullamento.WarnMessage + Environment.NewLine; if (force) rata.Emissione = null; } } if(rata.Emissione == null) { if (rata.Esercizio != null) { rata.Esercizio.Rate.Remove(rata); rata.Esercizio = null; } if (rata.PianoRatealeDettaglio != null) { rata.PianoRatealeDettaglio.RateSoggetti.Remove(rata); rata.PianoRatealeDettaglio = null; } if (rata.Soggetto != null) { rata.Soggetto.Rate.Remove(rata); rata.Soggetto = null; } if(rata.SoggettoEmissione != null) { rata.SoggettoEmissione.Rate.Remove(rata); rata.SoggettoEmissione = null; } _daoFactory.GetRataSoggettoDao().Delete(rata); } } else if (cancelIfNotDeleted) { rata.SetStato(StatoRataEnum.Richiamata); rata.MotivoRichiamo = "Annullamento rata"; } else return allowDeleteMessage; } return new AuthorizationMessages(fatalMessage, warnMessage); } catch (Exception ex) { _log.ErrorFormat("Errore nella eliminazione di una rata - {0} - rata: ", ex, Utility.GetMethodDescription(), rata.ID); throw; } }
private void writeMovimento20(RataSoggetto rata, StreamWriter sw, int numeroDisposizione, string intestazioneAzienda) { try { var sb = new StringBuilder(120); // Tipo Record sb.Append(" 20"); // Numero Disposizione sb.Append(numeroDisposizione.ToString().PadLeft(7, '0')); // -------------------------------------------------------------------- // Descrizione del creditore (condominio) // -------------------------------------------------------------------- var descrizioneCondominioLength = 30; var indirizzoCondominioLength = 30; var localitaCondominioLength = 30; if (intestazioneAzienda.Length > 10) { var gap = intestazioneAzienda.Length - 10; descrizioneCondominioLength += gap; indirizzoCondominioLength -= gap / 2; localitaCondominioLength -= (gap - (30 - indirizzoCondominioLength)); } // Descrizione condominio var ragioneSocialeCondominio = Conversione.ToInvioTelematico(rata.Esercizio.CondominioRiferimento.Descrizione); if (!string.IsNullOrEmpty(intestazioneAzienda)) ragioneSocialeCondominio = intestazioneAzienda + " " + ragioneSocialeCondominio; if (ragioneSocialeCondominio.Length > descrizioneCondominioLength) ragioneSocialeCondominio = ragioneSocialeCondominio.Substring(0, descrizioneCondominioLength); sb.Append(ragioneSocialeCondominio.PadRight(descrizioneCondominioLength, ' ')); // Indirizzo var indirizzoCondominio = string.Empty; if (rata.Esercizio.CondominioRiferimento.Indirizzo != null) indirizzoCondominio = Conversione.ToInvioTelematico(rata.Esercizio.CondominioRiferimento.Indirizzo.GetIndirizzoCompleto()); if (indirizzoCondominio.Length > indirizzoCondominioLength) indirizzoCondominio = indirizzoCondominio.Substring(0, indirizzoCondominioLength); sb.Append(indirizzoCondominio.PadRight(indirizzoCondominioLength, ' ')); // Località var localitaCondominio = string.Empty; if (rata.Esercizio.CondominioRiferimento.Indirizzo?.Comune != null) localitaCondominio = Conversione.ToInvioTelematico(rata.Esercizio.CondominioRiferimento.Indirizzo.Comune.Descrizione); if (localitaCondominio.Length > localitaCondominioLength) localitaCondominio = localitaCondominio.Substring(0, localitaCondominioLength); sb.Append(localitaCondominio.PadRight(localitaCondominioLength, ' ')); // Codice Fiscale sb.Append(rata.Esercizio.CondominioRiferimento.CodiceFiscale.PadRight(16, ' ')); // filler sb.Append(string.Empty.PadLeft(4)); sw.WriteLine(sb.ToString()); } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato durante la creazione di una singola riga di MAV - {0} - esercizio:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), rata.Esercizio.ID, rata.Esercizio.CondominioRiferimento.Azienda.ID); throw; } }
// Coordinate ordinante private void writeMovimento16(RataSoggetto rata, DatiBancariCondomini banca, StreamWriter sw, int numeroDisposizione) { try { var sb = new StringBuilder(120); // Tipo Record sb.Append(" 16"); // Numero Disposizione sb.Append(numeroDisposizione.ToString().PadLeft(7, '0')); // -------------------------------------------------------------------- // Coordinate banca ordinante (banca del condominio) // -------------------------------------------------------------------- var coord = new CoordinateBancarie { Abi = banca.Abi, Cab = banca.Cab, ContoCorrente = banca.ContoCorrente }; // Codice Paese sb.Append("IT"); // CheckDigit IBAN sb.Append(coord.CalcolaCheckIBAN()); // CIN sb.Append(coord.CalcolaCin()); // ABI sb.Append(coord.Abi); // CAB sb.Append(coord.Cab); // Conto Corrente sb.Append(coord.ContoCorrente); // filler sb.Append(string.Empty.PadLeft(83)); sw.WriteLine(sb.ToString()); } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato durante la creazione di una singola riga di MAV - {0} - condominio:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), banca.CondominioRiferimento.ID, banca.CondominioRiferimento.Azienda.ID); throw; } }
private void writeMovimentoRichiamo14(RataSoggetto rata, DatiBancariCondomini banca, StreamWriter sw, int numeroDisposizione) { try { var sb = new StringBuilder(120); // Tipo Record sb.Append(" 14"); // Numero Disposizione sb.Append(numeroDisposizione.ToString().PadLeft(7, '0')); // filler sb.Append(string.Empty.PadLeft(12)); // data scadenza sb.Append(convertData(rata.DataScadenza)); // causale sb.Append("07000"); // importo sb.Append((Math.Round(rata.Importo * 100, 0)).ToString().PadLeft(13, '0')); // segno sb.Append("+"); // -------------------------------------------------------------------- // Coordinate banca assuntrice (banca del condominio) // -------------------------------------------------------------------- // ABI sb.Append(banca.Abi); // CAB sb.Append(banca.Cab); // Conto Corrente sb.Append(banca.ContoCorrente.PadLeft(12, '0')); // filler sb.Append(string.Empty.PadLeft(22)); // -------------------------------------------------------------------- // Coordinate azienda creditrice (condominio) // -------------------------------------------------------------------- // Codice SIA sb.Append(rata.Esercizio.CondominioRiferimento.CodiceSIA.Trim().PadLeft(5, ' ')); // Tipo codice (usato il codice fiscale del condominio quindi: '3') sb.Append("3"); // Codice (usato il codice fiscale del condominio) sb.Append(rata.Esercizio.CondominioRiferimento.CodiceFiscale.PadRight(16, ' ')); // filler sb.Append(string.Empty.PadLeft(6)); // divisa sb.Append("E"); sw.WriteLine(sb.ToString()); } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato durante la creazione di una singola riga di MAV - {0} - esercizio:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), rata.Esercizio.ID, rata.Esercizio.CondominioRiferimento.Azienda.ID); throw; } }
private void writeMovimento50(RataSoggetto rata, EmissioneRate testata, StreamWriter sw, int numeroDisposizione) { try { var sb = new StringBuilder(120); // Tipo Record sb.Append(" 50"); // Numero Disposizione sb.Append(numeroDisposizione.ToString().PadLeft(7, '0')); // ----------------------------------------------------------------------------- // Riferimenti al debito (è suddiviso in due segmenti di 40 caratteri ciascuno) // ----------------------------------------------------------------------------- var descrizioneMav = rata.GetDescrizioneMAV(testata.Causale); sb.Append(descrizioneMav[0].PadRight(40, ' ')); sb.Append(descrizioneMav[1].PadRight(40, ' ')); // filler sb.Append(string.Empty.PadLeft(30)); sw.WriteLine(sb.ToString()); } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato durante la creazione di una singola riga di MAV - {0} - esercizio:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), rata?.Esercizio.ID, rata?.Esercizio.CondominioRiferimento.Azienda.ID); throw; } }
private bool insert(RataSoggettoDTO dto, out RataSoggetto item) { item = null; var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda); try { item = new RataSoggetto(daoFactory.GetEsercizioDao().GetById(dto.IdEsercizio, false), daoFactory.GetSoggettoCondominioDao().GetById(dto.IdSoggettoCondominio, false), dto.DataScadenza.GetValueOrDefault(), dto.Importo.GetValueOrDefault(), _logTransazione); if (dto.IdPianoDettaglioRatealeRiferimento > 0) item.PianoRatealeDettaglio = daoFactory.GetPianoRatealeDettaglioDao().GetById(dto.IdPianoDettaglioRatealeRiferimento, false); item.Progressivo = dto.Progressivo; daoFactory.GetRataSoggettoDao().SaveOrUpdate(item); } catch (Exception ex) { _log.ErrorFormat("Errore nell'inserimento delle rate soggetto - {0} - id:{1}", ex, Utility.GetMethodDescription(), dto.ID); throw; } return true; }
private bool update(RataSoggettoDTO dto, out RataSoggetto item) { var result = false; item = null; var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda); try { item = daoFactory.GetRataSoggettoDao().GetById(dto.ID, false); // Condizione necessaria per il controllo del fatto che sul DB ho una versione uguale o più vecchia if (dto.Version == item.Version) { item.DataScadenza = dto.DataScadenza.GetValueOrDefault(); item.Importo = dto.Importo.GetValueOrDefault(); if(dto.IdPianoDettaglioRatealeRiferimento > 0) item.PianoRatealeDettaglio = daoFactory.GetPianoRatealeDettaglioDao().GetById(dto.IdPianoDettaglioRatealeRiferimento, false); item.Progressivo = dto.Progressivo; daoFactory.GetRataSoggettoDao().Update(item); result = true; } else { // Eccezione: Sul db c'è qualche cosa di più nuovo. _log.ErrorFormat("Errore nel salvataggio della rata soggetto - {0} - id:{1}", Utility.GetMethodDescription(), dto.ID); } } catch (Exception ex) { _log.ErrorFormat("Errore nel salvataggio della rata soggetto - {0} - id:{1}", ex, Utility.GetMethodDescription(), dto.ID); throw; } return result; }
public string EliminazioneRataSoggetto(RataSoggetto rata, string descrizione) { var message = string.Empty; if (rata.Stato == StatoRataEnum.Inserita) { // bugid#10127 se la rata ha solleciti non può essere eliminata // per annullarla occorre passare a true il terzo parametro, però attualmente, quando viene visualizzata la lista rate, una store procedure la riporta in stato immesso var resultDelete = deleteRata(rata, false); if (!string.IsNullOrEmpty(resultDelete.FatalMessage)) return resultDelete.FatalMessage; // _daoFactory.GetRataSoggettoDao().Delete(rata); } else if (rata.Emissione != null && (rata.Stato == StatoRataEnum.Spedita || rata.Stato == StatoRataEnum.ParzialmenteSpedita)) { rata.DaRichiamare = true; if (!string.IsNullOrEmpty(descrizione) && descrizione.Length > 50) descrizione = descrizione.Substring(0, 50); rata.MotivoRichiamo = descrizione; } else message = "Non è possibile eliminare una rata che sia già pagata o parzialmente pagata." + Environment.NewLine; return message; }
public string CopiaRate(IList<PianoRatealeDettaglioDTO> dettaglioRate, int idEsercizio, TipoAccorpamentoRateEnum tipoAccorpamento, LogTransazione logTransazione) { try { var message = string.Empty; LogTransazione logTransazioneDettaglio = null; var esercizio = _daoFactory.GetEsercizioDao().GetById(idEsercizio, false); PianoRateale pianoRateale; if (GetPianoRatealeByEsercizio(idEsercizio) != null) { pianoRateale = GetPianoRatealeByEsercizio(idEsercizio); logTransazioneDettaglio = logTransazione; } else pianoRateale = new PianoRateale(esercizio, tipoAccorpamento, logTransazione); int progressivo = 0; if(pianoRateale.Rate.Count > 0) progressivo = pianoRateale.Rate.Max(item => item.Progressivo); foreach (var dettaglioDto in dettaglioRate) { progressivo++; var dettaglio = _daoFactory.GetPianoRatealeDettaglioDao().GetById(dettaglioDto.ID, false); var dettaglioNew = new PianoRatealeDettaglio(pianoRateale, dettaglioDto.DataScadenza, null, progressivo, false, logTransazioneDettaglio) { Descrizione = dettaglioDto.Descrizione, IsAcconto = dettaglioDto.IsAcconto }; foreach (var rata in dettaglio.RateSoggetti.Where(item => !item.DaRichiamare)) { var rataNew = new RataSoggetto(esercizio, _soggettoService.GetSoggettoAttuale(rata.Soggetto, esercizio, esercizio.DataApertura.GetValueOrDefault()), dettaglioDto.DataScadenza, rata.Importo, null) {PianoRatealeDettaglio = dettaglioNew}; dettaglioNew.RateSoggetti.Add(rataNew); } } return message; } catch (Exception ex) { _log.ErrorFormat("Errore nella copia delle rate - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), idEsercizio); throw; } }
private void writeMovimento30(RataSoggetto rata, StreamWriter sw, int numeroDisposizione) { try { var sb = new StringBuilder(120); // Tipo Record sb.Append(" 30"); // Numero Disposizione sb.Append(numeroDisposizione.ToString().PadLeft(7, '0')); // -------------------------------------------------------------------- // Descrizione debitore (condomino - è suddivisa in 2 segmenti alfanumerici di 30 caratteri ciascuno) // -------------------------------------------------------------------- var tipoIndirizzo = TipoIndirizzo.Recapito; if (_impostazioniAzienda != null) tipoIndirizzo = _impostazioniAzienda.TipoIndirizzoComunicazioni; var indirizzoCondomino = _personaService.GetRecapito(rata.Soggetto.Persona, tipoIndirizzo); var nomeCondomino = rata.Soggetto.DisplayName; if (!string.IsNullOrEmpty(indirizzoCondomino.Presso)) nomeCondomino += " c/o " + indirizzoCondomino.Presso; var descrizioneCondomino = Conversione.ToInvioTelematico(nomeCondomino); var descrizione1 = string.Empty; var descrizione2 = string.Empty; if (descrizioneCondomino.Length <= 30) { descrizione1 = descrizioneCondomino.PadRight(30, ' '); descrizione2 = string.Empty.PadLeft(30, ' '); } else if (descrizioneCondomino.Length > 30) { descrizione1 = descrizioneCondomino.Substring(0, 30); descrizione2 = descrizioneCondomino.Substring(30).PadRight(30, ' '); } if (descrizione2.Length > 30) descrizione2 = descrizione2.Substring(0, 30); // Descrizione condomino sb.Append(descrizione1); sb.Append(descrizione2); // Codice Fiscale var codiceFiscale = string.Empty; if (rata.Soggetto.Persona.CodiceFiscale != null) codiceFiscale = rata.Soggetto.Persona.CodiceFiscale; sb.Append(codiceFiscale.PadRight(16, ' ')); // filler sb.Append(string.Empty.PadLeft(34)); sw.WriteLine(sb.ToString()); } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato durante la creazione di una singola riga di MAV - {0} - esercizio:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), rata.Esercizio.ID, rata.Esercizio.CondominioRiferimento.Azienda.ID); throw; } }
private AuthorizationMessages annullamentoRata(RataSoggetto rata) { var fatalMessage = string.Empty; var warnMessage = string.Empty; if (rata.Emissione != null && rata.DataScadenza > DateTime.Today.AddDays(10)) { rata.SetStato(StatoRataEnum.Inserita); rata.DaRichiamare = true; rata.MotivoRichiamo = "Annullamento rata"; return new AuthorizationMessages(null, null); } if (rata.DataScadenza <= DateTime.Today.AddDays(10)) warnMessage += "La rata non è richiamabile perchè già scaduta o perchè la scadenza è troppo vicina" + Environment.NewLine; return new AuthorizationMessages(fatalMessage, warnMessage); }
private void writeMovimento40(RataSoggetto rata, StreamWriter sw, int numeroDisposizione) { try { var sb = new StringBuilder(120); // Tipo Record sb.Append(" 40"); // Numero Disposizione sb.Append(numeroDisposizione.ToString().PadLeft(7, '0')); // -------------------------------------------------------------------- // Indirizzo del debitore (condomino) // -------------------------------------------------------------------- var tipoIndirizzo = TipoIndirizzo.Recapito; if (_impostazioniAzienda != null) tipoIndirizzo = _impostazioniAzienda.TipoIndirizzoComunicazioni; var indirizzoCondomino = _personaService.GetRecapito(rata.Soggetto.Persona, tipoIndirizzo); // via, civico e/o frazione var indirizzo = Conversione.ToInvioTelematico(indirizzoCondomino.Indirizzo + ", " + indirizzoCondomino.Civico + " " + indirizzoCondomino.Localita); string indirizzo1; var indirizzo2 = string.Empty; if (indirizzo.Length <= 30) indirizzo1 = indirizzo; else { indirizzo1 = indirizzo.Substring(0, 30); indirizzo2 = indirizzo.Substring(30); } sb.Append(indirizzo1.PadRight(30, ' ')); // cap var cap = string.Empty; if (indirizzoCondomino.Cap != null) { cap = indirizzoCondomino.Cap.Trim(); if (cap.Length > 5) cap = cap.Substring(0, 5); } sb.Append(cap.PadLeft(5, '0')); // comune e sigla provincia var comune = string.Empty; if(!string.IsNullOrEmpty(indirizzoCondomino.Comune?.Descrizione)) comune = Conversione.ToInvioTelematico(indirizzoCondomino.Comune.Descrizione.Trim()); else if(indirizzoCondomino.Comune != null) _log.ErrorFormat("Trovato comune senza DESCRIZIONE - {0} - comune:{1}", Utility.GetMethodDescription(), indirizzoCondomino.Comune.Codice); else _log.ErrorFormat("Trovato indirizzo CONDOMINO senza COMUNE - {0} - condomino:{1}", Utility.GetMethodDescription(), rata.Soggetto.ID); if (comune.Length > 22) comune = comune.Substring(0, 22); var provincia = string.Empty; if (indirizzoCondomino.Comune?.ProvinciaAppartenenza != null) provincia = indirizzoCondomino.Comune.ProvinciaAppartenenza.Codice; sb.Append((comune + " " + provincia).PadRight(25, ' ')); // seconda parte indirizzo if (indirizzo2.Length > 28) indirizzo2 = indirizzo2.Substring(0, 28); sb.Append(indirizzo2.PadRight(28, ' ')); // codice paese secondo codifica ISO 3166 // TODO: Da gestire la tabella dei codici ISO sb.Append("IT"); // filler sb.Append(string.Empty.PadLeft(20)); sw.WriteLine(sb.ToString()); } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato durante la creazione di una singola riga di MAV - {0} - rata:{1} - esercizio:{2}", ex, Utility.GetMethodDescription(), rata?.ID.ToString() ?? "<NULL>", _testata.Esercizio.ID); throw; } }
private RataSoggettoDTO setDto(RataSoggetto rata) { try { var dto = new RataSoggettoDTO { DisplayName = rata.PianoRatealeDettaglio.Descrizione, DataScadenza = rata.DataScadenza, DescrizioneSoggettoCondominio = rata.Soggetto.DisplayName, DescrizioneUnitaImmobiliare = rata.Soggetto.UnitaImmobiliare.Descrizione + " - " + rata.Soggetto.UnitaImmobiliare.TipoUnitaImmobiliare.Descrizione, ID = rata.ID, IdEsercizio = rata.Esercizio.ID, DescrizioneEsercizio = rata.Esercizio.DisplayName, Importo = rata.Importo, StatoRata = rata.Stato, IdSoggettoCondominio = rata.Soggetto.ID, IdUnitaImmobiliare = rata.Soggetto.UnitaImmobiliare.ID, IdPersona = rata.Soggetto.Persona.ID, Progressivo = rata.Progressivo, ImportoPagato = rata.Versamenti.Sum(vers => vers.Importo), IsDeleteAllow = false, TipoSoggettoCondominio = rata.Soggetto.Tipo, OrdineUnitaImmobiliare = rata.Soggetto.UnitaImmobiliare.Ordine.GetValueOrDefault(), NumeroSolleciti = rata.Solleciti.Count, Subalterno = rata.Soggetto.UnitaImmobiliare.Subalterno, Alert = false }; // E' ammesso il richiamo della rata solo se non è ancora stata pagata e se non vi sono rate collegate a livello di MAV if (rata.Stato != StatoRataEnum.Pagata && rata.Stato != StatoRataEnum.ParzialmentePagata) { if (rata.Emissione == null || rata.Emissione.RateCollegate.Count <= 1) dto.IsDeleteAllow = true; } if (rata.SoggettoEmissione != null) { dto.IdSoggettoEmissione = rata.SoggettoEmissione.ID; dto.DescrizioneSoggettoEmissione = rata.SoggettoEmissione.DisplayName; } if (rata.PianoRatealeDettaglio != null) { dto.IdPianoDettaglioRatealeRiferimento = rata.PianoRatealeDettaglio.ID; dto.DisplayName = rata.PianoRatealeDettaglio.Descrizione; } if (rata.Emissione?.Stato == StatoMavEnum.Radiato && rata.Stato != StatoRataEnum.Pagata && rata.Stato != StatoRataEnum.ParzialmentePagata) dto.Alert = true; return dto; } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato durante la inizializzazione di un elemento DTO di rata - {0} - idRata:{1}", ex, Utility.GetMethodDescription(), rata.ID); throw; } }
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 VersamentiRate setRataVersamentoDopoChiusura(VersamentoSoggetto versamento, Esercizio esercizio, LogTransazione logTransazione) { VersamentiRate rataVersamento = null; LogTransazione logTransazioneRata = null; if (esercizio.Gestione == GestioneEsercizioEnum.Ordinario && esercizio.Stato == StatoEsercizioEnum.Aperto && versamento.TipoVersamentoDopoChiusura == TipoVersamentoDopoChiusuraEnum.RicEsSucc) { var pianoRatealeDettaglio = _daoFactory.GetPianoRatealeDettaglioDao().GetRataVersamentoDopoChiusura(esercizio); if (pianoRatealeDettaglio == null) { var pianoRateale = _daoFactory.GetPianoRatealeDao().GetByEsercizio(esercizio); LogTransazione logTransazioneDettaglio = null; if (pianoRateale == null) pianoRateale = new PianoRateale(esercizio, TipoAccorpamentoRateEnum.Nessuno, logTransazione); else logTransazioneDettaglio = logTransazione; pianoRatealeDettaglio = new PianoRatealeDettaglio(pianoRateale, esercizio.DataApertura, null, 0, false, logTransazioneDettaglio) { Descrizione = "Versamenti eseguiti dopo la chiusura", IsAcconto = true, VersamentiDopoChiusura = true }; } else logTransazioneRata = logTransazione; var rataSoggetto = new RataSoggetto(pianoRatealeDettaglio, versamento.Soggetto, versamento.Data, versamento.Importo, logTransazioneRata); rataVersamento = new VersamentiRate(versamento, rataSoggetto, versamento.Importo); rataSoggetto.SetStato(); } return rataVersamento; }
public void SalvaPianoRateale(PianoRatealeSoggetti pianoRatealeSoggetti, LogTransazione logTransazione) { /* Vecchio Codice per rimozione rendiconti // -------------------------------------------------- // Rimozione rendiconti preesistenti // -------------------------------------------------- Esercizio esercizio =_daoFactory.GetEsercizioDao().GetById(pianoRatealeSoggetti.PianoRateale.IdEsercizio, false); foreach (RendicontoAnnuale rendiconto in esercizio.Rendiconti) { foreach (PianoRateale piano in rendiconto.PianiRateali) { _daoFactory.GetPianoRatealeDao().Delete(piano); piano.Rendiconto = null; foreach (PianoRatealeDettaglio dettaglio in piano.Rate) dettaglio.PianoRatealeRiferimento = null; } rendiconto.PianiRateali.Clear(); } //List<RataSoggetto> rate = new List<RataSoggetto>(esercizio.Rate.Count); foreach (RataSoggetto rata in esercizio.Rate) { rata.Soggetto.Rate.Clear(); if (rata.PianoRatealeDettaglio != null) { rata.PianoRatealeDettaglio.RateSoggetti.Remove(rata); rata.PianoRatealeDettaglio = null; rata.Soggetto.Rate.Clear(); rata.Soggetto = null; } _daoFactory.GetRataSoggettoDao().Delete(rata); rate.Add(rata); } esercizio.Rate.Clear(); foreach (RataSoggetto rata in rate) { esercizio.Rate.Remove(rata); rata.Esercizio = null; } */ try { // ==================================================================================================== // Rimozione piani rateali preesistenti (solo se non è una rata di acconto) // ==================================================================================================== var esercizio = _daoFactory.GetEsercizioDao().Find(pianoRatealeSoggetti.PianoRateale.IdEsercizio, false); // leggo ora le rate da richiamare per evitare successivi problemi di cascade var rateDaRichiamare = _daoFactory.GetRataSoggettoDao().GetDaRichiamareByEsercizio(esercizio); var pianiEliminati = new List<PianoRateale>(); if (esercizio != null) { // ---------------------------------------------------------------------- // Rimozione piani da rendiconti // ---------------------------------------------------------------------- try { foreach (var rendiconto in esercizio.Rendiconti) { var pianiDaRimuovere = rendiconto.PianiRateali.ToList(); foreach (var piano in pianiDaRimuovere) { try { var listaDettaglioRate = piano.Rate.ToList(); foreach (var dettaglioPiano in listaDettaglioRate) { try { if (!dettaglioPiano.IsAcconto) { // Elimino impostazioni report dettaglio deleteImpostazioniReportDettaglioPiano(dettaglioPiano); piano.Rate.Remove(dettaglioPiano); dettaglioPiano.PianoRatealeRiferimento = null; if (dettaglioPiano.LogTransazione != null) { dettaglioPiano.LogTransazione.PianoRateale.Remove(piano); dettaglioPiano.LogTransazione = null; } } } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato durante la rimozione dei piani rateali precedenti - SINGOLO DETTAGLIO PIANO - {0} - dettaglio piano:{1}", ex, Utility.GetMethodDescription(), dettaglioPiano.ID); throw; } } } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato durante la rimozione dei piani rateali precedenti - SINGOlO PIANO - {0} - piano:{1}", ex, Utility.GetMethodDescription(), piano.ID); throw; } if (piano.Rate.Count == 0) { pianiEliminati.Add(piano); rendiconto.PianiRateali.Remove(piano); piano.Rendiconto = null; if (piano.LogTransazione != null) { piano.LogTransazione.PianoRateale.Remove(piano); piano.LogTransazione = null; } } } } } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato durante la rimozione dei piani rateali precedenti - RIMOZIONE PIANI RATEALI DA RENDICONTI - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), esercizio.ID); throw; } // ---------------------------------------------------------------------- // Rimozione singole rate // ---------------------------------------------------------------------- var rateToDelete = new List<PianoRatealeDettaglio>(); var ratePresenti = esercizio.Rate.ToList(); ratePresenti.AddRange(rateDaRichiamare); try { foreach (var rata in ratePresenti) { try { if (rata.PianoRatealeDettaglio != null && !rata.PianoRatealeDettaglio.IsAcconto) { if (!rateToDelete.Contains(rata.PianoRatealeDettaglio)) rateToDelete.Add(rata.PianoRatealeDettaglio); rata.Esercizio?.Rate.Remove(rata); rata.PianoRatealeDettaglio.RateSoggetti.Remove(rata); rata.Esercizio = null; rata.PianoRatealeDettaglio = null; if (rata.Soggetto != null) { rata.Soggetto.Rate.Remove(rata); rata.Soggetto = null; } if (rata.SoggettoEmissione != null) { rata.SoggettoEmissione.Rate.Remove(rata); rata.SoggettoEmissione = null; } if (rata.LogTransazione != null) { rata.LogTransazione.Rate.Remove(rata); rata.LogTransazione = null; } //_daoFactory.GetRataSoggettoDao().Delete(rata); } } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato durante il salvataggio del piano rateale - SINGOlA RATA - {0} - rata:{1}", ex, Utility.GetMethodDescription(), rata.ID); throw; } } } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato durante la rimozione dei piani rateali precedenti - RIMOZIONE SINGOLE RATE SOGGETTI - {0} - rataesercizio:{1}", ex, Utility.GetMethodDescription(), esercizio.ID); throw; } // ---------------------------------------------------------------------- // Rimozione singoli dettaglio rate // ---------------------------------------------------------------------- try { foreach (var dettaglio in rateToDelete) { try { if (dettaglio.PianoRatealeRiferimento != null) { dettaglio.PianoRatealeRiferimento.Rate.Remove(dettaglio); dettaglio.PianoRatealeRiferimento = null; } dettaglio.RateSoggetti.Clear(); } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato durante la rimozione dei piani rateali precedenti - SINGOLO DETTAGLIO - {0} - dettaglio:{1}", ex, Utility.GetMethodDescription(), dettaglio.ID); throw; } } } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato durante la rimozione dei piani rateali precedenti - RIMOZIONE DETTAGLI - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), esercizio.ID); throw; } // ==================================================================================================== // Creazione nuovo piano rateale // ==================================================================================================== // ---------------------------------------------------------------------- // Oggetto PianoRateale // ---------------------------------------------------------------------- LogTransazione logTransazioneDettaglio = null; PianoRateale pianoRateale = null; try { // Non devo considerare piani rateali eliminati nelle elaborazioni precedenti if (pianiEliminati.All(item => item.ID != pianoRatealeSoggetti.PianoRateale.ID)) pianoRateale = _daoFactory.GetPianoRatealeDao().Find(pianoRatealeSoggetti.PianoRateale.ID, false); if (pianoRateale == null) { pianoRateale = new PianoRateale(_daoFactory.GetRendicontoAnnualeDao().GetById(pianoRatealeSoggetti.PianoRateale.IdRendiconto.GetValueOrDefault(), false), pianoRatealeSoggetti.PianoRateale.Tipo, logTransazione); } else { pianoRateale.Rendiconto = _daoFactory.GetRendicontoAnnualeDao().GetById(pianoRatealeSoggetti.PianoRateale.IdRendiconto.GetValueOrDefault(), false); logTransazioneDettaglio = logTransazione; } pianoRateale.Tipo = pianoRatealeSoggetti.PianoRateale.Tipo; pianoRateale.ArrotondamentoImporti = pianoRatealeSoggetti.PianoRateale.ArrontondamentoImporti; } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato durante il salvataggio del piano rateale - CREAZIONE O AGGIORNAMENTO OGGETTO PianoRateale - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), esercizio.ID); throw; } // ---------------------------------------------------------------------- // Dettagli del piano rateale // ---------------------------------------------------------------------- try { foreach (var dettaglioDto in pianoRatealeSoggetti.PianoRateale.Rate) { if (dettaglioDto.ID == 0) { try { if (Conversione.IsSqlSmallDateTime(dettaglioDto.DataScadenza)) { var dettaglio = new PianoRatealeDettaglio(pianoRateale, dettaglioDto.DataScadenza, dettaglioDto.PercentualeRiparto, dettaglioDto.Progressivo, false, logTransazioneDettaglio) { Descrizione = dettaglioDto.Descrizione, Importo = dettaglioDto.Importo, PercentualeSaldoEsercizioPrecedente = dettaglioDto.PercentualeRipartoSaldo }; } else { _log.ErrorFormat("Tentativo di salvare rata con data di scadenza errata - {0} - data:{1} - esercizio:{2}", Utility.GetMethodDescription(), dettaglioDto.DataScadenza, esercizio.ID); } } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato durante il salvataggio del piano rateale - SINGOLO DETTAGLIO DTO - {0} - dettaglio:{1} - esercizio:{2} ", ex, Utility.GetMethodDescription(), dettaglioDto.ID, esercizio.ID); throw; } } } } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato durante il salvataggio del piano rateale - ELABORAZIONE DETTAGLI - {0} - esercizio:{1} ", ex, Utility.GetMethodDescription(), esercizio.ID); throw; } // ---------------------------------------------------------------------- // Singole rate // ---------------------------------------------------------------------- try { foreach (var rataSoggettoDto in pianoRatealeSoggetti.RateSoggetti) { try { if (rataSoggettoDto.ID == 0) { var rata = new RataSoggetto(pianoRateale.Esercizio, _daoFactory.GetSoggettoCondominioDao().GetById(rataSoggettoDto.IdSoggettoCondominio, false), rataSoggettoDto.DataScadenza.GetValueOrDefault(), rataSoggettoDto.Importo.GetValueOrDefault(), null) { Progressivo = rataSoggettoDto.Progressivo }; if (rataSoggettoDto.Progressivo > 0) { PianoRatealeDettaglio dettaglio = null; var dto = rataSoggettoDto; var dettagli = (pianoRateale.Rate.Where(dett => dett.Progressivo == dto.Progressivo)).ToList(); if (dettagli.Any()) { if (dettagli.Count > 1) _log.DebugFormat("Trovata più di una rata con lo stesso progressivo - SINGOLO SOGGETTO - Valorizzazione progressivo - {0} - rata:{1} - soggetto:{2} - esercizio:{3}", Utility.GetMethodDescription(), rataSoggettoDto.ID, rataSoggettoDto.IdSoggettoCondominio, esercizio.ID); dettaglio = dettagli.First(); } if (dettaglio == null) { _log.ErrorFormat("Non trovata la rata di dettaglio - Valorizzazione progressivo - {0} - rata:{1} - soggetto:{2} - esercizio:{3}", Utility.GetMethodDescription(), rataSoggettoDto.ID, rataSoggettoDto.IdSoggettoCondominio, esercizio.ID); } else dettaglio.RateSoggetti.Add(rata); rata.PianoRatealeDettaglio = dettaglio; } if (rata.PianoRatealeDettaglio == null || rata.PianoRatealeDettaglio.ID > 0) rata.LogTransazione = logTransazione; } } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato durante il salvataggio del piano rateale - Valorizzazione progressivo - {0} - rata:{1} - soggetto:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), rataSoggettoDto.ID, rataSoggettoDto.IdSoggettoCondominio, esercizio.ID); throw; } } } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato durante il salvataggio del piano rateale - ELABORAZIONE DETTAGLIO SOGGETTO - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), esercizio.ID); throw; } var rateArrotondamenti = pianoRateale.Rate.Where(dettaglio => dettaglio.Progressivo == pianoRatealeSoggetti.PianoRateale.IdRataArrotondamenti).ToList(); if(rateArrotondamenti.Count > 1) throw new InvalidDataException(string.Format("Errore nel salvataggio del piano rateale.{0}Il valore di progressivo non è corretto.{0}Si prega di contattare l'assistenza.", Environment.NewLine)); pianoRateale.RataArrotondamenti = rateArrotondamenti.SingleOrDefault(); } else { _log.WarnFormat("Esercizio non trovato nel salvataggio del piano rateale - {0} - esercizio:{1}", Utility.GetMethodDescription(), pianoRatealeSoggetti.PianoRateale.IdEsercizio); } } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato durante il salvataggio del piano rateale - {0} - pianoRatealeSoggetti:{1}", ex, Utility.GetMethodDescription(), pianoRatealeSoggetti.PianoRateale.ID); throw; } }
public TestataMovimentoContabile SetMovimentiSingolaRata(RataSoggetto rata, TestataMovimentoContabile testata, DateTime dataRegistrazione) { return null; return SetMovimentiSingolaRata(rata, rata.Importo, rata.Soggetto, rata.Esercizio, testata, dataRegistrazione); }
public string AggiornaImporti(IList<RataSoggettoAggiornamentoDTO> rate, bool rateAcconto, TipoAccorpamentoRateEnum tipo, LogTransazione logTransazione) { try { var message = string.Empty; LogTransazione logTransazioneDettaglio = null; var dettaglioPianoRateale = new Dictionary<DateTime, PianoRatealeDettaglio>(); PianoRateale pianoRateale = null; foreach (var rata in rate) { if (!(rata.Importo < 0)) { if (Conversione.IsSqlSmallDateTime(rata.DataScadenza)) { if (rata.Id > 0) { var rataDaAggiornare = _daoFactory.GetRataSoggettoDao().Find(rata.Id, false); if (rataDaAggiornare != null) { // Se la rata è stata richiamata occorre creare una nuova rata if (rataDaAggiornare.DaRichiamare || rataDaAggiornare.Stato == StatoRataEnum.Richiamata) { var rataNew = new RataSoggetto(rataDaAggiornare.Esercizio, rataDaAggiornare.Soggetto, rataDaAggiornare.DataScadenza, rata.Importo.GetValueOrDefault(), logTransazione) { PianoRatealeDettaglio = rataDaAggiornare.PianoRatealeDettaglio, Progressivo = rataDaAggiornare.Progressivo }; rataNew.SetStato(StatoRataEnum.Inserita); } else { rataDaAggiornare.DataScadenza = rata.DataScadenza; rataDaAggiornare.Importo = rata.Importo.GetValueOrDefault(); } } else { message = "Il piano rateale che si è cercato di aggiornare è obsoleto. Rientrare nella funzione 'Rate' e riproporre l'aggiornamento."; _log.WarnFormat("Nell'aggiornamento manuale del piano rateale si sono verificati i seguenti errori - {0}:{1}{2}", Utility.GetMethodDescription(), Environment.NewLine, message); throw new InvalidDataException(message); } } else { // Trovo la rata NON RICHIAMATA per lo stesso dettaglio, per il soggetto considerato, dovrebbe esserne presente una sola var esercizio = _daoFactory.GetEsercizioDao().GetById(rata.IdEsercizio, false); var pianoRatealeDettaglio = getPianoRatealeDettaglio(dettaglioPianoRateale, pianoRateale, esercizio, rata, rateAcconto, tipo, logTransazione, logTransazioneDettaglio, message); if (pianoRatealeDettaglio != null) { pianoRateale = pianoRatealeDettaglio.PianoRatealeRiferimento; logTransazioneDettaglio = pianoRatealeDettaglio.LogTransazione; var rateDaAggiornare = pianoRatealeDettaglio.RateSoggetti.Where(item => item.Soggetto.ID == rata.IdSoggettoCondominio && !item.DaRichiamare).ToList(); if (!(rateDaAggiornare.Count > 1)) { var rataDaAggiornare = rateDaAggiornare.FirstOrDefault(); if (rataDaAggiornare == null) { var soggetto = _daoFactory.GetSoggettoCondominioDao().Find(rata.IdSoggettoCondominio, false); if (soggetto != null) rataDaAggiornare = new RataSoggetto(pianoRatealeDettaglio, soggetto, rata.DataScadenza, rata.Importo.GetValueOrDefault(), null); } if (rataDaAggiornare != null) rataDaAggiornare.Importo = rata.Importo.GetValueOrDefault(); } } } } else { _log.ErrorFormat("Rata con data non valida - {0} - rata:{1} - data:{2} - soggetto:{3} - importo:{4} - esercizio:{5}", Utility.GetMethodDescription(), rata.Id, rata.DataScadenza, rata.IdSoggettoCondominio, rata.Importo, rata.IdEsercizio); } } } if (!string.IsNullOrEmpty(message)) { _log.WarnFormat("Si sono verificati i seguenti errori - {0} - message:{1}", Utility.GetMethodDescription(), message); } return message; } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato durante l'aggiornamento degli importi delle rate - {0}", ex, Utility.GetMethodDescription()); throw; } }
public void SetMovimentiRichiamoRata(RataSoggetto rata, LogTransazione logTransazione) { // Movimenti Contabili: Non devono essere registrati movimenti contabili all'atto dell'annullamento di una rata bugid#6383 return; var numeroRiga = 0; var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("IR"); // ------------------------------------------------ // Testata // ------------------------------------------------ var testata = new TestataMovimentoContabile(rata.Esercizio, DateTime.Today, TipoTestataMovimentoContabileEnum.Automatica, logTransazione); // controllo data registrazione var message = IsAllowDataRegistrazione(new List<int> { rata.Esercizio.CondominioRiferimento.ID }, rata.Esercizio, testata.DataRegistrazione.GetValueOrDefault()); if (message.Count > 0) { var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", testata.DataRegistrazione.GetValueOrDefault())); _log.ErrorFormat("Data di registrazione non valida - {0} - testata:{1} - data:{2} - rata:{3}", ex, Utility.GetMethodDescription(), testata.ID, testata.DataRegistrazione.GetValueOrDefault(), rata.ID); throw ex; } // ------------------------------------------------ // Crediti V/S Condomini - a Saldo // ------------------------------------------------ numeroRiga++; var movimentoPatrimoniale = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(rata.Esercizio.ID, rata.Esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoVersamentiCondomini()), rata.Importo, "A") { CondominoRiferimento = rata.Soggetto, Descrizione = "Richiamo Rata n. " + rata.PianoRatealeDettaglio.Progressivo + " di " + rata.Soggetto.DisplayName + " - " + rata.MotivoRichiamo }; // ------------------------------------------------ // Storno rate condominiali // ------------------------------------------------ numeroRiga++; var movimentoPatrimonialeAttivo = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(rata.Esercizio.ID, rata.Esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoRateCondomini()), rata.Importo, "D") { CondominoRiferimento = rata.Soggetto, Descrizione = movimentoPatrimoniale.Descrizione }; }
public RataSoggettoDTO GetByDomainEntity(RataSoggetto item) { try { return setDto(item); } catch (Exception ex) { _log.ErrorFormat("Errore nel caricamento delle rate soggetto - {0} - id:{1}", ex, Utility.GetMethodDescription(), item.ID); throw; } }