public RataSoggettoDTO[] GetAllBySoggetto(int? idEsercizio, int idSoggetto) { try { var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda); var soggetto = daoFactory.GetSoggettoCondominioDao().GetById(idSoggetto, false); var esercizi = idEsercizio == null ? daoFactory.GetEsercizioDao().GetApertiByCondominio(soggetto.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.CondominioRiferimento.ID) : new List<Esercizio>{daoFactory.GetEsercizioDao().Find(idEsercizio.GetValueOrDefault(), false)}; var rate = new List<RataSoggetto>(); foreach (var esercizio in esercizi) rate.AddRange(daoFactory.GetRataSoggettoDao().GetByEsercizioSoggetto(esercizio.ID, idSoggetto)); var listaDto = new RataSoggettoDTO[rate.Count]; var index = 0; foreach (var item in rate) { listaDto[index] = setDto(item); index++; } return listaDto; } catch (Exception ex) { _log.ErrorFormat("Errore nel caricamento delle rate soggetto - {0} - esercizio:{1} - soggetto:{2}", ex, Utility.GetMethodDescription(), idEsercizio, idSoggetto); throw; } }
public RataSoggettoDTO[] GetAllByEsercizio(int idEsercizio) { try { var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda); var esercizio = daoFactory.GetEsercizioDao().GetById(idEsercizio, false); var listaDto = new RataSoggettoDTO[esercizio.Rate.Count]; var index = 0; var rate = daoFactory.GetRataSoggettoDao().GetByEsercizio(esercizio); foreach (var item in rate) { listaDto[index] = setDto(item); index++; } return listaDto; } catch (Exception ex) { _log.ErrorFormat("Errore nel caricamento delle rate soggetto - {0} - id:{1}", ex, Utility.GetMethodDescription(), idEsercizio.ToString()); throw; } }
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 IList<RataSoggettoDTO> GetRataVersamentoByEsercizioSoggetto(int idEsercizio, int? idSoggetto, int? idStabile, DateTime? dataLimite, bool soloDaSollecitare) { try { var rate = idSoggetto == null ? _daoFactory.GetRataSoggettoDao().GetByEsercizioLottoStabileScala(idEsercizio, null, idStabile, null) : _daoFactory.GetRataSoggettoDao().GetByEsercizioSoggetto(idEsercizio, idSoggetto.Value); var rateVersamenti = new List<RataSoggettoDTO>(rate.Count); var importi = _daoFactory.GetVersamentiRateDao().GetTotaleVersamentiRataByEsercizio(idEsercizio); var esercizio = _daoFactory.GetEsercizioDao().GetById(idEsercizio, false); SoggettoCondominio soggetto = null; if (idSoggetto.GetValueOrDefault() > 0) soggetto = _daoFactory.GetSoggettoCondominioDao().Find(idSoggetto.GetValueOrDefault(), false); // ============================================== // Leggo tutte rate // ============================================== foreach (var rata in rate) { if (rata.DataScadenza <= dataLimite) { var rataVersamento = new RataSoggettoDTO { DataScadenza = rata.DataScadenza, DescrizioneUnitaImmobiliare = rata.Soggetto.UnitaImmobiliare.Descrizione, ID = rata.ID, IdEsercizio = idEsercizio, DescrizioneEsercizio = esercizio.DisplayName, IdSoggettoCondominio = rata.Soggetto.ID, DescrizioneSoggettoCondominio = rata.Soggetto.DisplayName, IdUnitaImmobiliare = rata.Soggetto.UnitaImmobiliare.ID, IdPersona = rata.Soggetto.Persona.ID, Importo = rata.Importo, Progressivo = rata.Progressivo, StatoRata = rata.Stato, TipoSoggettoCondominio = rata.Soggetto.Tipo, OrdineUnitaImmobiliare = rata.Soggetto.UnitaImmobiliare.Ordine.GetValueOrDefault(), NumeroSolleciti = rata.Solleciti.Count, Subalterno = rata.Soggetto.UnitaImmobiliare.Subalterno, Alert = false }; if (rata.SoggettoEmissione != null) { rataVersamento.IdSoggettoEmissione = rata.SoggettoEmissione.ID; rataVersamento.DescrizioneSoggettoEmissione = rata.SoggettoEmissione.DisplayName; } if (rata.PianoRatealeDettaglio != null) { rataVersamento.DisplayName = rata.PianoRatealeDettaglio.Descrizione; rataVersamento.IdPianoDettaglioRatealeRiferimento = rata.PianoRatealeDettaglio.ID; } if (rata.Emissione?.Stato == StatoMavEnum.Radiato && rata.Stato != StatoRataEnum.Pagata && rata.Stato != StatoRataEnum.ParzialmentePagata) rataVersamento.Alert = true; var rata1 = rata; var importo = (from imp in importi where imp.Id == rata1.ID select imp).SingleOrDefault(); if (importo != null) rataVersamento.ImportoPagato = importo.Importo; rateVersamenti.Add(rataVersamento); } } // ========================================== // Aggiungo i versamenti fuori piano rateale // ========================================== int? idPersona = null; if (soggetto != null) idPersona = soggetto.Persona.ID; var versamenti = _versamentiCondominiService.GetVersamentiSenzaRata(idEsercizio, idPersona); foreach (var versamento in versamenti) { if (idSoggetto == null || versamento.Soggetto.ID == idSoggetto.GetValueOrDefault()) { var dto = new RataSoggettoDTO { ID = 0, IdEsercizio = idEsercizio, DescrizioneEsercizio = esercizio.DisplayName, IdTestataEmissione = null, IdDettaglioEmissione = null, IdPianoDettaglioRatealeRiferimento = 0, Alert = false, DataEmissione = null, DescrizioneUnitaImmobiliare = versamento.Soggetto.UnitaImmobiliare.Descrizione, OrdineUnitaImmobiliare = versamento.Soggetto.UnitaImmobiliare.Ordine.GetValueOrDefault(), TipoSoggettoCondominio = versamento.Soggetto.Tipo, IdUnitaImmobiliare = versamento.Soggetto.UnitaImmobiliare.ID, IdSoggettoCondominio = versamento.Soggetto.ID, IdPersona = versamento.Soggetto.Persona.ID, NumeroSolleciti = 0, ImportoPagato = versamento.Importo - versamento.Rate.Sum(item => item.Importo), Importo = 0, Progressivo = 0, StatoRata = StatoRataEnum.Pagata, DisplayName = "Versamento fuori piano rateale", DescrizioneSoggettoCondominio = versamento.Soggetto.DisplayName, Subalterno = versamento.Soggetto.UnitaImmobiliare.Subalterno }; if (versamento.SoggettoEffettivo != null) { dto.DescrizioneSoggettoEmissione = versamento.SoggettoEffettivo.DisplayName; dto.IdSoggettoEmissione = versamento.SoggettoEffettivo.ID; } rateVersamenti.Add(dto); } } // ========================================== // Se richiesto rimuovo le rate delle unità da NON sollecitare // ========================================== if (soloDaSollecitare) { var ratePerUnita = from item in rateVersamenti group item by item.IdUnitaImmobiliare into rateUnitaGroup select rateUnitaGroup; foreach (var itemGroup in ratePerUnita) { if (itemGroup.Sum(item => item.ImportoPagato) >= itemGroup.Sum(item => item.Importo)) rateVersamenti.RemoveAll(item => item.IdUnitaImmobiliare == itemGroup.Key); } } return rateVersamenti.OrderBy(rata => rata.OrdineUnitaImmobiliare).ToList(); } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato durante la lettura di Rate e Versamento per esercizio e soggetto - {0} - esercizio:{1} - soggetto:{2} - stabile:{3} - dataLimite:{4:d} - daSollecitare:{5}", ex, Utility.GetMethodDescription(), idEsercizio, idSoggetto, idStabile, dataLimite, soloDaSollecitare); 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 PianoRatealeDTO CreatePianoRateale(PianoRatealeDTO testataPianoRateale, int numeroRate, IList<RiepilogoRipartoDTO> riepilogoRiparto) { var esercizio =_daoFactory.GetEsercizioDao().GetById(testataPianoRateale.IdEsercizio, false); var impostazioni = _daoFactory.GetImpostazioniAziendaDao().GetByAzienda(esercizio.CondominioRiferimento.Azienda.ID); var arrotondamenti = new Dictionary<int, decimal>(); var rendiconto = _daoFactory.GetRendicontoAnnualeDao().Find(testataPianoRateale.IdRendiconto.GetValueOrDefault(), false) ?? _bilancioService.GetPreventivoCorrente(testataPianoRateale.IdEsercizio); testataPianoRateale.IdRendiconto = rendiconto.ID; // Se non è stato definito nessun arrotondamento, arrotondo comunque a .01 var arrotondamentoImporti = 0.01m; if (testataPianoRateale.ArrontondamentoImporti > 0) arrotondamentoImporti = testataPianoRateale.ArrontondamentoImporti; // -------------------------------------------------------------------- // Leggo eventuali rate di acconto presenti // -------------------------------------------------------------------- var pianoAcconto = _daoFactory.GetPianoRatealeDao().GetByEsercizio(esercizio); IList<PianoRatealeDettaglio> listaDettaglioPianoAcconto = null; if (pianoAcconto != null) { testataPianoRateale.ID = pianoAcconto.ID; listaDettaglioPianoAcconto = (pianoAcconto.Rate.Where(item => item.IsAcconto)).ToList(); } // -------------------------------------------------------------------- // Creazione Piano Rateale // -------------------------------------------------------------------- var startIndex = 1; var numeroRateAcconto = 0; DateTime? dataIniziale = null; if (listaDettaglioPianoAcconto != null) { startIndex = listaDettaglioPianoAcconto.Count + 1; numeroRateAcconto = listaDettaglioPianoAcconto.Count(item => item.IsAcconto); var ultimaRata = listaDettaglioPianoAcconto.OrderBy(item => item.DataScadenza).LastOrDefault(); if (ultimaRata?.DataScadenza != null) dataIniziale = ultimaRata.DataScadenza.GetValueOrDefault(); } numeroRate += numeroRateAcconto; if (testataPianoRateale.Rate == null || testataPianoRateale.Rate.Count != numeroRate) { testataPianoRateale.Rate = new List<PianoRatealeDettaglioDTO>(); // Calcolo la distanza proposto, in numero di mesi, tra una rata e quella successiva var denominatore = numeroRate - startIndex + 1; var numeroMesi = DivideRoundingUp(numeroRate, 12)*12; var monthGap = numeroMesi/12; if (dataIniziale == null && esercizio.DataApertura != null) dataIniziale = esercizio.DataApertura.GetValueOrDefault(); if (dataIniziale == null) dataIniziale = new DateTime(DateTime.Today.Year, 2, 1); if(esercizio.DataChiusura != null && esercizio.Gestione == GestioneEsercizioEnum.Ordinario && numeroMesi <= 12) numeroMesi = Convert.ToInt32(Math.Round((esercizio.DataChiusura.GetValueOrDefault() - dataIniziale.GetValueOrDefault()).TotalDays / 30)); if(denominatore > 0) monthGap = numeroMesi / denominatore; var scadenza = new DateTime(dataIniziale.GetValueOrDefault().AddMonths(1).Year, dataIniziale.GetValueOrDefault().AddMonths(1).Month, 1); var rataIndex = 0; for (var i = startIndex; i <= numeroRate; i++) { var dettaglio = new PianoRatealeDettaglioDTO {DataScadenza = scadenza, Progressivo = i}; if (i == startIndex) dettaglio.PercentualeRipartoSaldo = 1m; dettaglio.PercentualeRiparto = Math.Round(1m / Convert.ToDecimal(numeroRate - startIndex + 1), 4); rataIndex++; dettaglio.Descrizione = $"Rata n. {rataIndex} del {scadenza:d}"; scadenza = scadenza.AddMonths(monthGap); testataPianoRateale.Rate.Add(dettaglio); } } // -------------------------------------------------------------------- // Calcolo importi piano rateale // -------------------------------------------------------------------- if (riepilogoRiparto == null) riepilogoRiparto = GetRiepilogoRiparto(testataPianoRateale.IdEsercizio, null, null, testataPianoRateale.Tipo); // Se arriva dal client cambio segno agli importi. else if (impostazioni.InversioneSaldiRate) { foreach (var item in riepilogoRiparto) item.Importo = item.Importo * -1; } var importiNegativi = new Dictionary<int, decimal>(); var importiMinimi = new Dictionary<int, decimal>(); _rateCreate = new List<RataSoggettoDTO>(); foreach (var dettaglio in testataPianoRateale.Rate) { if (dettaglio.ID == 0) { dettaglio.Importo = 0; // =========================================================================== // Creazione delle rate // =========================================================================== foreach (var itemRiepilogo in riepilogoRiparto) { var idSoggettoCondominio = getSoggettoCondominioPrincipale(itemRiepilogo.IdPersona, itemRiepilogo.IdSoggettoCondominio, null, riepilogoRiparto, testataPianoRateale); RataSoggettoDTO rata; if (!_rateCreate.Any(item => item.IdSoggettoCondominio == idSoggettoCondominio && item.DataScadenza == dettaglio.DataScadenza)) { rata = new RataSoggettoDTO { IdEsercizio = esercizio.ID, DescrizioneEsercizio = esercizio.DisplayName, DataScadenza = dettaglio.DataScadenza, Progressivo = dettaglio.Progressivo, IdPianoDettaglioRatealeRiferimento = dettaglio.ID, IdSoggettoCondominio = idSoggettoCondominio, DisplayName = itemRiepilogo.Nominativo, DescrizioneUnitaImmobiliare = itemRiepilogo.DescrizioneUnitaImmobiliare, IdPersona = itemRiepilogo.IdPersona, DescrizioneSoggettoCondominio = itemRiepilogo.Nominativo, OrdineUnitaImmobiliare = itemRiepilogo.OrdineUnitaImmobiliare, TipoSoggettoCondominio = itemRiepilogo.TipoSoggettoCondominio, Subalterno = itemRiepilogo.Subalterno }; _rateCreate.Add(rata); } else { var dettaglio2 = dettaglio; rata = (from item in _rateCreate where idSoggettoCondominio == item.IdSoggettoCondominio && item.DataScadenza == dettaglio2.DataScadenza select item).SingleOrDefault(); } // =========================================================================== // Calcolo Importo // =========================================================================== // Importo preventivo // ------------------------------ var importoPreventivo = getImportoNettoAcconti(itemRiepilogo, listaDettaglioPianoAcconto) * dettaglio.PercentualeRiparto.GetValueOrDefault(); // Importo saldo // ------------------------------ var importoSaldo = itemRiepilogo.SaldoEsercizioPrecedente * dettaglio.PercentualeRipartoSaldo.GetValueOrDefault(); if (impostazioni.InversioneSaldiRate) importoSaldo = importoSaldo*-1; // Rata totale // ------------------------------ if (rata != null) { var importoRata = rata.Importo.GetValueOrDefault() + importoSaldo + importoPreventivo; rata.Importo = importoRata; } } // =========================================================================== // Rilettura delle rate la gestione degli importi minimi // =========================================================================== var dettaglio1 = dettaglio; var ratePerDettaglio = from item in _rateCreate where dettaglio1 != null && item.DataScadenza == dettaglio1.DataScadenza select item; foreach (var rata in ratePerDettaglio) { var importoRata = rata.Importo.GetValueOrDefault(); // Se presenti importi minimi devo aggiungerli alla rata if (importiNegativi.ContainsKey(rata.IdSoggettoCondominio)) { var importoNegativo = importiNegativi[rata.IdSoggettoCondominio]; importoRata += importoNegativo; importiNegativi.Remove(rata.IdSoggettoCondominio); } // Creo rata solo se importo è maggiore dell'importo minimo, se è inferiore al minimo lo memorizzo per utilizzarlo nelle rate successive if (importoRata > testataPianoRateale.ImportoMinimo) { rata.Importo = Convert.ToDecimal(Arrotonda.Round(Convert.ToDouble(importoRata), Convert.ToDouble(arrotondamentoImporti))); // memorizzo eventuali arrotondamenti decimal importoArrontondamento = 0; if (arrotondamenti.ContainsKey(rata.IdSoggettoCondominio)) { importoArrontondamento = arrotondamenti[rata.IdSoggettoCondominio]; arrotondamenti.Remove(rata.IdSoggettoCondominio); } importoArrontondamento += importoRata - rata.Importo.GetValueOrDefault(); arrotondamenti.Add(rata.IdSoggettoCondominio, importoArrontondamento); } else { rata.Importo = 0; if (importoRata < 0) { decimal importo = 0; if (importiNegativi.ContainsKey(rata.IdSoggettoCondominio)) { importo = importiNegativi[rata.IdSoggettoCondominio]; importiNegativi.Remove(rata.IdSoggettoCondominio); } importo += importoRata; importiNegativi.Add(rata.IdSoggettoCondominio, importo); } else { decimal importo = 0; if (importiMinimi.ContainsKey(rata.IdSoggettoCondominio)) { importo = importiMinimi[rata.IdSoggettoCondominio]; importiMinimi.Remove(rata.IdSoggettoCondominio); } importo += importoRata; importiMinimi.Add(rata.IdSoggettoCondominio, importo); } } // ------------------------------- // Aggiorno dettaglio rata // ------------------------------- dettaglio.Importo += rata.Importo.GetValueOrDefault(); } } } // --------------------------------------------------------------------------------- // Aggiungo le rate di acconto // --------------------------------------------------------------------------------- int index = 0; if (listaDettaglioPianoAcconto != null) { foreach (PianoRatealeDettaglio dettaglioPianoAcconto in listaDettaglioPianoAcconto) { if (testataPianoRateale.Rate.All(item => item.ID != dettaglioPianoAcconto.ID)) { index++; var dettaglioAccontoDto = new PianoRatealeDettaglioDTO { ID = dettaglioPianoAcconto.ID, IsAcconto = true, DataScadenza = dettaglioPianoAcconto.DataScadenza.GetValueOrDefault(), Descrizione = dettaglioPianoAcconto.Descrizione, IsDeleteAllow = false, IdPianoRatealeRiferimento = dettaglioPianoAcconto.PianoRatealeRiferimento.ID, StatoRata = dettaglioPianoAcconto.Stato, Version = dettaglioPianoAcconto.Version, Progressivo = index, Importo = dettaglioPianoAcconto.RateSoggetti.Where(item => !item.DaRichiamare && item.Stato != StatoRataEnum.Richiamata).Sum(item => item.Importo) }; testataPianoRateale.Rate.Add(dettaglioAccontoDto); } foreach (RataSoggetto rataAcconto in dettaglioPianoAcconto.RateSoggetti.Where(item => !item.DaRichiamare && item.Stato != StatoRataEnum.Richiamata)) { var rataAccontoDto = new RataSoggettoDTO { ID = rataAcconto.ID, DataScadenza = rataAcconto.DataScadenza, DescrizioneSoggettoCondominio = rataAcconto.Soggetto.DisplayName, DescrizioneUnitaImmobiliare = rataAcconto.Soggetto.UnitaImmobiliare.Descrizione, IdEsercizio = rataAcconto.PianoRatealeDettaglio.PianoRatealeRiferimento.Esercizio.ID, DescrizioneEsercizio = rataAcconto.PianoRatealeDettaglio.PianoRatealeRiferimento.Esercizio.DisplayName, IdPianoDettaglioRatealeRiferimento = rataAcconto.PianoRatealeDettaglio.ID, IdUnitaImmobiliare = rataAcconto.Soggetto.UnitaImmobiliare.ID, Subalterno = rataAcconto.Soggetto.UnitaImmobiliare.Subalterno, Importo = rataAcconto.Importo, ImportoPagato = rataAcconto.GetImportoVersato(null), OrdineUnitaImmobiliare = rataAcconto.Soggetto.UnitaImmobiliare.Ordine.GetValueOrDefault(), StatoRata = rataAcconto.Stato, TipoSoggettoCondominio = rataAcconto.Soggetto.Tipo, Version = rataAcconto.Version, IsDeleteAllow = false, Progressivo = rataAcconto.Progressivo, IdPersona = rataAcconto.Soggetto.Persona.ID, IdSoggettoCondominio = getSoggettoCondominioPrincipale(rataAcconto.Soggetto.Persona.ID, rataAcconto.Soggetto.ID, rataAcconto.Soggetto.SoggettoPrincipale, riepilogoRiparto, testataPianoRateale) }; _rateCreate.Insert(0, rataAccontoDto); } } } testataPianoRateale.Rate = testataPianoRateale.Rate.OrderBy(item => item.Progressivo).ToList(); // --------------------------------------------------------------------------------- // Se ho ancora importi minimi li addebito alla prima rata ancora a 0 // Può capitare, ad esempio, se abbiamo definito una rata che comprende il solo saldo // --------------------------------------------------------------------------------- foreach (var kvp in importiMinimi) { var kvp1 = kvp; var ratePerImporto = from item in _rateCreate where item.IdSoggettoCondominio == kvp1.Key orderby item.Importo, item.Progressivo select item; if (ratePerImporto.Any()) { var importoArrotondato = Convert.ToDecimal(Arrotonda.Round(Convert.ToDouble(kvp.Value), Convert.ToDouble(arrotondamentoImporti))); var rata = ratePerImporto.FirstOrDefault(); if(rata != null) rata.Importo += importoArrotondato; // Aggiungo il residuo alla lista degli arrontondamenti if (kvp.Value != importoArrotondato) { if (arrotondamenti.ContainsKey(kvp.Key)) arrotondamenti[kvp.Key] += (kvp.Value - importoArrotondato); else arrotondamenti.Add(kvp.Key, kvp.Value - importoArrotondato); } } else { _log.WarnFormat("Non trovata nessun rata a cui addebitare l'importo minimo di {0} - {1} - id:{2}", kvp.Value.ToString("c"), Utility.GetMethodDescription(), kvp.Key); } } // --------------------------------------------------------------------------------- // Calcolo residui - Solo se presente rata di arrotondamento // --------------------------------------------------------------------------------- if (testataPianoRateale.IdRataArrotondamenti > 0) { decimal residuoTotale = 0; foreach (RiepilogoRipartoDTO itemRiepilogo in riepilogoRiparto) { if (arrotondamenti.ContainsKey(itemRiepilogo.IdSoggettoCondominio)) { decimal importoResiduo = arrotondamenti[itemRiepilogo.IdSoggettoCondominio]; var riepilogo = itemRiepilogo; RataSoggettoDTO rataResiduo = (from rata in _rateCreate where rata.Progressivo == testataPianoRateale.IdRataArrotondamenti && rata.IdSoggettoCondominio == riepilogo.IdSoggettoCondominio && rata.Importo > 0 select rata).SingleOrDefault(); if (rataResiduo != null) { rataResiduo.Importo += importoResiduo; residuoTotale += importoResiduo; arrotondamenti.Remove(itemRiepilogo.IdSoggettoCondominio); } } } // --------------------------------------------------------------------------------- // Se ho ancora residui di arrotondamento li addebito alla prima rata disponibile > 0 // --------------------------------------------------------------------------------- foreach (var kvp in arrotondamenti) { var importoResiduo = kvp.Value; var kvp1 = kvp; var rateResiduo = from item in _rateCreate where item.IdSoggettoCondominio == kvp1.Key && item.Importo > 0 orderby item.Progressivo select item; if (rateResiduo.Any()) { foreach (var rataResiduo in rateResiduo) { if (rataResiduo.Importo + importoResiduo >= 0) { rataResiduo.Importo += importoResiduo; residuoTotale += importoResiduo; break; } } } } // --------------------------------------------------------------------------------- // Aggiorno col residuo la rata di dettaglio // --------------------------------------------------------------------------------- var dettaglioResiduo = (from dettaglio in testataPianoRateale.Rate where dettaglio.Progressivo == testataPianoRateale.IdRataArrotondamenti select dettaglio).SingleOrDefault(); if (dettaglioResiduo != null) dettaglioResiduo.Importo += residuoTotale; } // --------------------------------------------------------------------------------- // Se ho ancora importi negativi verifico se riesco a sottrarli da qualche rata: // Può capitare, ad esempio, se abbiamo definito una rata che comprende il solo saldo // --------------------------------------------------------------------------------- var importiNegativiDaSottrarre = importiNegativi.Select(kvp => new ImportiDTO { Id = kvp.Key, Importo = kvp.Value*-1 }).ToList(); foreach (var importoDto in importiNegativiDaSottrarre) { var dto = importoDto; var rateSoggetto = from item in _rateCreate where item.IdSoggettoCondominio == dto.Id select item; foreach (var rata in rateSoggetto) { // Solo per le rate nuove if (rata.ID == 0) { decimal importoOriginale = rata.Importo.GetValueOrDefault(); if (rata.Importo >= importoDto.Importo) rata.Importo -= importoDto.Importo; else if (rata.Importo < importoDto.Importo) rata.Importo = 0; importoDto.Importo -= importoOriginale - rata.Importo.GetValueOrDefault(); } } } return testataPianoRateale; }
public IList<RataSoggettoDTO> GetRataByEsercizio(int idEsercizio) { try { // ============================================================================================= // Aggiorno stato della rata // ============================================================================================= try { _daoFactory.GetMovimentoContabileDao().ExecuteQuery("AggiornamentoStatoRataSoggetto", new QueryParam("idEsercizio", idEsercizio)); } catch (Exception ex) { _log.ErrorFormat("Errore nella esecuzione dell'aggiornamento della rata - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), idEsercizio); } var rateDto = new List<RataSoggettoDTO>(); var esercizio = _daoFactory.GetEsercizioDao().GetById(idEsercizio, false); // =================================================== // Carico tutte le rate già presenti // =================================================== var rate = _daoFactory.GetRataSoggettoDao().GetByEsercizio(esercizio); // --------------------------------------------------------------------------------- // Se sono presenti solo rate per versamenti dopo la chiusura non visualizzo nulla // --------------------------------------------------------------------------------- if (rate.Any(item => !item.PianoRatealeDettaglio.VersamentiDopoChiusura)) { var soggettiPresenti = new Dictionary<DateTime, List<int>>(); var tipo = TipoAccorpamentoRateEnum.Nessuno; if (rate.Count > 0) tipo = rate[0].PianoRatealeDettaglio.PianoRatealeRiferimento.Tipo; foreach (var rata in rate) { try { rata.SetStato(); if (rata.DaRichiamare) { const string hql = "FROM RataSoggetto R WHERE R.Stato <> :stato AND R.DataScadenza = :data AND R.Soggetto.ID = :soggetto AND R.PianoRatealeDettaglio.PianoRatealeRiferimento.Esercizio = :esercizio"; var listaRate = _daoFactory.GetRataSoggettoDao().GetByQuery(hql, new QueryParam("stato", Conversione.ToHQLParameter(StatoRataEnum.Richiamata)), new QueryParam("data", rata.DataScadenza), new QueryParam("soggetto", rata.Soggetto.ID), new QueryParam("esercizio", idEsercizio)); if (listaRate.Count > 0) continue; } var dto = new RataSoggettoDTO { DataScadenza = rata.DataScadenza, DataUltimoVersamento = rata.Versamenti.Count > 0 ? (DateTime?)rata.Versamenti.Max(item => item.Versamento.Data) : null, DescrizioneSoggettoCondominio = rata.Soggetto.DisplayName, // TODO: Probabilmente questa assegnazione, in caso di molte unità immobiliari, rallenta la funzione DescrizioneUnitaImmobiliare = rata.Soggetto.UnitaImmobiliare.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), NumeroSolleciti = rata.Solleciti.Count, IsDeleteAllow = false, TipoSoggettoCondominio = rata.Soggetto.Tipo, OrdineUnitaImmobiliare = rata.Soggetto.UnitaImmobiliare.Ordine.GetValueOrDefault(), Version = rata.Version, Subalterno = rata.Soggetto.UnitaImmobiliare.Subalterno, Alert = false }; if (rata.PianoRatealeDettaglio.VersamentiDopoChiusura) { dto.DataScadenza = rata.PianoRatealeDettaglio.DataScadenza.GetValueOrDefault(); dto.VersamentiDopoChiusura = true; } // Se la rata è da richiamare la considero (solo DTO) come già richiamata per visualizzarla come le rate richiamate if (rata.DaRichiamare) dto.StatoRata = StatoRataEnum.Richiamata; // 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.PianoRatealeDettaglio != null) { dto.IdPianoDettaglioRatealeRiferimento = rata.PianoRatealeDettaglio.ID; dto.DisplayName = rata.PianoRatealeDettaglio.Descrizione; } if (rata.Emissione != null) { dto.IdTestataEmissione = rata.Emissione.TestataEmissioneRate.ID; dto.IdDettaglioEmissione = rata.Emissione.ID; dto.DataEmissione = rata.Emissione.TestataEmissioneRate.Data; if (rata.Emissione.Stato == StatoMavEnum.Radiato && rata.Stato != StatoRataEnum.Pagata && rata.Stato != StatoRataEnum.ParzialmentePagata) dto.Alert = true; } if (rata.SoggettoEmissione != null) { dto.IdSoggettoEmissione = rata.SoggettoEmissione.ID; dto.DescrizioneSoggettoEmissione = rata.SoggettoEmissione.DisplayName; } List<int> soggettiPerData; if (soggettiPresenti.Keys.Contains(dto.DataScadenza.GetValueOrDefault())) soggettiPerData = soggettiPresenti[dto.DataScadenza.GetValueOrDefault()]; else { soggettiPerData = new List<int>(); soggettiPresenti.Add(dto.DataScadenza.GetValueOrDefault(), soggettiPerData); } if (!soggettiPerData.Contains(dto.IdSoggettoCondominio)) soggettiPerData.Add(dto.IdSoggettoCondominio); rateDto.Add(dto); } catch (Exception ex) { _log.ErrorFormat("Errore nella lettura delle rate - SINGOLA RATA - {0} - rata:{1} - esercizio:{2}", ex, Utility.GetMethodDescription(), rata.ID, idEsercizio); throw; } } // --------------------------------------------------- // Aggiungo eventuali soggetti non presenti // --------------------------------------------------- foreach (var kvp in soggettiPresenti) { var soggettiCondominio = _daoFactory.GetSoggettoCondominioDao().GetAttiviByCondominioData(esercizio.CondominioRiferimento.ID, null, null, esercizio.DataApertura.GetValueOrDefault()); // var soggettiCondominio = esercizio.CondominioRiferimento.GetSoggetti(esercizio.DataApertura.GetValueOrDefault(), null, null); foreach (var soggetto in soggettiCondominio) { var soggettoPrincipale = getSoggettoCondominioPrincipale(soggetto, soggettiCondominio.ToList(), tipo); if (!kvp.Value.Contains(soggettoPrincipale.ID)) { var dto = new RataSoggettoDTO { DataScadenza = kvp.Key, DescrizioneSoggettoCondominio = soggettoPrincipale.DisplayName, DescrizioneUnitaImmobiliare = soggettoPrincipale.UnitaImmobiliare.Descrizione, ID = 0, IdEsercizio = idEsercizio, DescrizioneEsercizio = esercizio.DisplayName, Importo = null, StatoRata = StatoRataEnum.Inserita, IdSoggettoCondominio = soggettoPrincipale.ID, IdUnitaImmobiliare = soggettoPrincipale.UnitaImmobiliare.ID, IdPersona = soggettoPrincipale.Persona.ID, Progressivo = 0, ImportoPagato = 0, NumeroSolleciti = 0, IsDeleteAllow = false, TipoSoggettoCondominio = soggettoPrincipale.Tipo, OrdineUnitaImmobiliare = soggettoPrincipale.UnitaImmobiliare.Ordine.GetValueOrDefault(), Subalterno = soggettoPrincipale.UnitaImmobiliare.Subalterno }; rateDto.Add(dto); } } } } return rateDto.OrderBy(rata => rata.DataScadenza).ThenBy(rata => rata.OrdineUnitaImmobiliare).ToList(); } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato durante la lettura delle rate per esercizio - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), idEsercizio); throw; } }
public DataTable AddDataToPivot(EsercizioDTO esercizio, DataTable tb, IList<RataSoggettoDTO> rate, DateTime data, decimal importo, ContoDTO conto, IList<SoggettoCondominioDTO> soggetti, TipoAccorpamentoRateEnum tipo) { var dateColumn = new List<DataColumn>(); List<ImportiDTO> riparto = null; if (conto != null) riparto = GetServiceClient().GetRipartoImporto(esercizio.ID, conto.ID, importo, data, GetUserInfo()); // Se non sono presenti righe devo caricare tutte le righe per i condomini presenti if (tb.Rows.Count == 0) { if(soggetti == null || !soggetti.Any()) soggetti = GetPartecipanti(esercizio.ID, tipo); if (soggetti != null) { foreach (var soggetto in soggetti) { var row = tb.NewRow(); row["IdSoggetto"] = soggetto.ID; row["Nominativo"] = soggetto.DisplayNominativo; row["DescrizioneUnitaImmobiliare"] = soggetto.DescrizioneUnitaImmobiliare; row["OrdineUnitaImmobiliare"] = soggetto.OrdineUnitaImmobiliare; // Data dateColumn = addColumnByData(data, tb, dateColumn); decimal importoRata = importo; if (riparto != null) { var importoItem = riparto.SingleOrDefault(item => item.Id == soggetto.ID); importoRata = importoItem?.Importo ?? 0; } row["Decimal_Data_" + data.ToShortDateString()] = importoRata; row["Stato_" + data.ToShortDateString()] = StatoRataEnum.Inserita.ToString(); row["NumeroSolleciti_" + data.ToShortDateString()] = 0; row["Alert_" + data.ToShortDateString()] = false; tb.Rows.Add(row); // Aggiorno lista rate editabili var rata = (rate.Where(item => item.DataScadenza == data && item.IdSoggettoCondominio == soggetto.ID)).FirstOrDefault(); if (rata == null) { var rataDto = new RataSoggettoDTO { ID = 0, DataScadenza = data, DescrizioneSoggettoCondominio = soggetto.DisplayNominativo, DescrizioneUnitaImmobiliare = soggetto.DescrizioneUnitaImmobiliare, IdEsercizio = esercizio.ID, IdSoggettoCondominio = soggetto.ID, StatoRata = StatoRataEnum.Inserita, IdUnitaImmobiliare = soggetto.IdUnitaImmobiliare, OrdineUnitaImmobiliare = soggetto.OrdineUnitaImmobiliare, TipoSoggettoCondominio = soggetto.Tipo, Importo = importoRata }; rate.Add(rataDto); } } } } else { dateColumn.AddRange(tb.Columns.Cast<DataColumn>().Where(column => column.ColumnName.StartsWith("Decimal_Data_"))); addColumnByData(data, tb, dateColumn); foreach (DataRow row in tb.Rows) { var importoRata = importo; if (riparto != null) { var importoItem = (from item in riparto where item.Id == (int)row["IdSoggetto"] select item).SingleOrDefault(); importoRata = importoItem?.Importo ?? 0; } row["Decimal_Data_" + data.ToShortDateString()] = importoRata; // Aggiorno lista rate editabili var rata = (from item in rate where item.DataScadenza == data && item.IdSoggettoCondominio == (int)row["IdSoggetto"] select item).FirstOrDefault(); if (rata == null) { var descrizioneUnitaImmobiliare = string.Empty; var nominativo = string.Empty; if (row["DescrizioneUnitaImmobiliare"] != null && row["DescrizioneUnitaImmobiliare"] != DBNull.Value) descrizioneUnitaImmobiliare = (string)row["DescrizioneUnitaImmobiliare"]; if (row["Nominativo"] != null && row["Nominativo"] != DBNull.Value) nominativo = (string)row["Nominativo"]; var rataDto = new RataSoggettoDTO { ID = 0, DataScadenza = data, DescrizioneSoggettoCondominio = nominativo, DescrizioneUnitaImmobiliare = descrizioneUnitaImmobiliare, IdEsercizio = esercizio.ID, IdSoggettoCondominio = (int)row["IdSoggetto"], StatoRata = StatoRataEnum.Inserita, OrdineUnitaImmobiliare = (int)row["OrdineUnitaImmobiliare"], TipoSoggettoCondominio = TipoSoggetto.Soggetto, Importo = importoRata }; rate.Add(rataDto); } } } CloseService(); return tb; }
private RataSoggetto manage(RataSoggettoDTO dto) { RataSoggetto item = null; bool result; // Controllo sullo stato U, I switch (dto.Stato.ToUpper()) { case "U": result = update(dto, out item); if (!result) { //Il dato sul database è più recente di quello utilizzato //refer.ID = 0; item = null; } break; case "I": result = insert(dto, out item); if (!result) throw new Exception("Impossibile scrivere sul database"); break; } return item; }
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; }
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 int? ManageDomainEntity(RataSoggettoDTO dto) { try { return manage(dto).ID; } catch (Exception ex) { _log.ErrorFormat("Errore nel caricamento delle rate soggetto - {0} - id:{1}", ex, Utility.GetMethodDescription(), dto.ID); throw; } }