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