public PianoRateale(Esercizio esercizio, TipoAccorpamentoRateEnum tipo, LogTransazione logTransazione)
{
Tipo = tipo;
Esercizio = esercizio;
LogTransazione = logTransazione;
if (LogTransazione != null)
LogTransazione.PianoRateale.Add(this);
}
public ListaSelezioneRateUC(CondominioDTO condominio, EsercizioDTO esercizio, TipoAccorpamentoRateEnum tipoAccorpamento)
{
InitializeComponent();
inizializza();
_condominio = condominio;
_esercizio = esercizio;
_tipoAccorpamento = tipoAccorpamento;
}
public CreazionePianoRatealeUC(CondominioDTO condominio, EsercizioDTO esercizio, TipoAccorpamentoRateEnum tipo)
{
InitializeComponent();
_condominio = condominio;
_esercizio = esercizio;
_tipo = tipo;
inizializza();
}
/// <summary>
/// Crea una Testata di movimento contabile valida
/// </summary>
public PianoRateale(RendicontoAnnuale rendiconto, TipoAccorpamentoRateEnum tipo, LogTransazione logTransazione)
{
Rendiconto = rendiconto;
Tipo = tipo;
if(Rendiconto != null)
Esercizio = rendiconto.Esercizio;
LogTransazione = logTransazione;
if (LogTransazione != null)
LogTransazione.PianoRateale.Add(this);
}
public override IEnumerable<ReportRipartizioneBilancioDTO> GetDataSourceRipartizioneBilancioConsuntivo(int? idEsercizio, int? idCondominio, int? anno, int? detrazione, IList<int> idSpese, int? idStabile, int? idScala, bool ripartizioneProprietarioConduttore, bool accorpamentoUnita, TipoAccorpamentoRateEnum tipoAccorpamento, bool inversioneSaldi, bool calcoloPerSubentro, bool addebitiCondominio, bool addebitiDirettiStabileScala, IList<int> idSoggetti, bool dettaglioSottoConto = false)
{
try
{
var lista = new Dictionary<string, ReportRipartizioneBilancioDTO>();
Esercizio esercizio = null;
Condominio condominio = null;
// =============================================================================================
// Allineo flag di ripartizione personalizzata
// =============================================================================================
if (idEsercizio != null)
{
try
{
_daoFactory.GetMovimentoContabileDao().ExecuteQuery("AllineamentoRipartoPersonalizzato", new QueryParam("idEsercizio", idEsercizio.GetValueOrDefault()));
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella esecuzione dell'allineamento personalizzato - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), idEsercizio.GetValueOrDefault());
}
}
var detrazioneRicerca = _ripartizioneService.GetDetrazioneRicerca(detrazione.GetValueOrDefault());
IList<Conto> contiChiusuraStraordinario = new List<Conto>();
if (idEsercizio != null)
{
esercizio = _daoFactory.GetEsercizioDao().Find(idEsercizio.Value, false);
if (esercizio == null)
{
_log.WarnFormat("Esercizio non più presente - {0} - esercizio:{1}", Utility.GetMethodDescription(), idEsercizio.GetValueOrDefault());
return new BindingList<ReportRipartizioneBilancioDTO>();
}
condominio = esercizio.CondominioRiferimento;
contiChiusuraStraordinario = getContiEconomiciChiusuraStraordinario(condominio.ID);
}
// =============================================================================================
// Per gli esercizi chiusi deve essere proposto, se possibile, lo storico
// =============================================================================================
if (esercizio != null && esercizio.Stato == StatoEsercizioEnum.Chiuso)
{
var listaStorico = getStoricoRiparto(esercizio.ID, idStabile, idScala, false, TipoRendiconto.Consuntivo);
if (listaStorico.Any())
{
if (!inversioneSaldi)
{
foreach (var reportRipartizioneBilancioDTO in listaStorico)
{
if (reportRipartizioneBilancioDTO.OrdineConto == 9993 || reportRipartizioneBilancioDTO.OrdineConto == 9994)
reportRipartizioneBilancioDTO.Importo = reportRipartizioneBilancioDTO.Importo * -1;
}
}
listaStorico = elaboraAccorpamento(listaStorico, tipoAccorpamento, condominio.GetSoggetti(esercizio.DataApertura.GetValueOrDefault(), null, null).ToList(), new Dictionary<int, IList<MillesimoDTO>>(), esercizio, null, null);
return elaboraRigheContiVuoti(listaStorico);
}
}
// =============================================================================================
// Ricalcolo i saldi solo se ho un esercizio precedente aperto
// =============================================================================================
if (esercizio != null)
{
var esercizioPrecedente = esercizio.GetEsercizioPrecedente();
if (esercizioPrecedente != null && esercizioPrecedente.Stato == StatoEsercizioEnum.Aperto)
_saldoContabileService.TrasferimentoSaldiNuovoEsercizio(esercizio.ID, this, calcoloPerSubentro);
}
if (idCondominio != null)
condominio = _daoFactory.GetCondominioDao().GetById(idCondominio.Value, false);
ImpostazioniAzienda impostazioni = null;
IList<SoggettoCondominio> soggettiEsercizio = null;
if (condominio != null)
{
impostazioni = _daoFactory.GetImpostazioniAziendaDao().GetByAzienda(condominio.Azienda.ID);
soggettiEsercizio = esercizio != null ? _daoFactory.GetSoggettoCondominioDao().GetAttiviByEsercizio(esercizio, null) : _daoFactory.GetSoggettoCondominioDao().GetAttiviByCondominioAnno(condominio.ID, anno.GetValueOrDefault());
}
var conti = _daoFactory.GetContoDao().GetByCondominio(condominio.ID).ToDictionary(item => item.ID);
// -------------------------------------------------------------------------------------------
// TODO: Da eliminare quando saranno riscritti i subentri - bugid#8425
var soggettiEsercizioNoSubentri = new List<SoggettoCondominio>(soggettiEsercizio.Count);
foreach (var soggettoCondominio in soggettiEsercizio)
{
try
{
if (soggettoCondominio != null && soggettoCondominio.Tipo == TipoSoggetto.Proprietario || soggettoCondominio.DataInizio == null || (esercizio != null && soggettoCondominio.DataInizio.GetValueOrDefault() <= esercizio.DataApertura.GetValueOrDefault()) || (anno != null && soggettoCondominio.DataInizio.GetValueOrDefault().Year <= anno.Value))
soggettiEsercizioNoSubentri.Add(soggettoCondominio);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella lettura dei soggetti per subentro - {0} - soggetto:{1} - esercizio:{2}", ex, Utility.GetMethodDescription(), soggettoCondominio?.ID, esercizio?.ID);
}
}
// -------------------------------------------------------------------------------------------
IDictionary<int, IList<SoggettoCondominio>> soggettiAttivi = new Dictionary<int, IList<SoggettoCondominio>>();
foreach (var soggettoCondominioUnita in soggettiEsercizioNoSubentri.GroupBy(item => item.UnitaImmobiliare))
{
soggettiAttivi.Add(soggettoCondominioUnita.Key.ID, soggettoCondominioUnita.ToList());
}
IDictionary<int, SoggettoCondominio> soggettiAttiviIndex = new Dictionary<int, SoggettoCondominio>();
foreach (var soggettoCondominio in soggettiEsercizioNoSubentri)
{
soggettiAttiviIndex.Add(soggettoCondominio.ID, soggettoCondominio);
}
//====================================================================================
// Raggruppo gli importi dei movimenti per Conto, Sottoconto, Lotto, Stabile e Scala
//====================================================================================
var importiConto = new List<ImportiContoSottocontoDTO>();
IList<IRipartizioneSpesa> movimenti;
if (esercizio != null)
{
movimenti = _daoFactory.GetMovimentoContabileDao().GetByEsercizioEconomiciBilancio(esercizio).Cast<IRipartizioneSpesa>().ToList();
movimenti = movimenti.Where(item => item.Causale.Codice != "ST" || contiChiusuraStraordinario.Contains(item.ContoRiferimento)).ToList();
}
else
{
var whereSpese = string.Empty;
var parameters = new List<QueryParam>(3)
{
new QueryParam("condominio", condominio),
new QueryParam("anno", anno),
new QueryParam("detrazione", detrazioneRicerca)
};
if (idSpese != null && idSpese.Count > 0)
{
whereSpese += " AND SPE in(:spese) ";
parameters.Add(new QueryParam("spese", idSpese));
}
const string hql = "FROM MovimentoContabile MOV LEFT JOIN FETCH MOV.FornitoreRiferimento FOR LEFT JOIN FETCH FOR.PersonaRiferimento PERS LEFT JOIN FETCH PERS.IndirizzoResidenza.Comune COM LEFT JOIN FETCH MOV.ContoRiferimento CON JOIN FETCH MOV.DettaglioRiferimento DETT JOIN FETCH DETT.SpesaRiferimento SPE LEFT JOIN FETCH SPE.RipartizioneSpesa RIPSPE LEFT JOIN FETCH SPE.Scadenze SCA LEFT JOIN FETCH SCA.Pagamenti PAG LEFT JOIN FETCH SPE.Riscossioni RISC LEFT JOIN FETCH RISC.MovimentoContabile MOVRISC LEFT JOIN FETCH MOVRISC.Testata TESRISC WHERE RIPSPE IS NULL AND MOV.Importo is not null AND MOV.Testata.EsercizioRiferimento.CondominioRiferimento = :condominio AND SPE.Detrazione = :detrazione AND (year(PAG.Data) = :anno OR year(TESRISC.DataRegistrazione) = :anno) {0}";
movimenti = _daoFactory.GetMovimentoContabileDao().GetByQuery(string.Format(hql, whereSpese), parameters.ToArray()).Cast<IRipartizioneSpesa>().ToList();
// Aggiungo le ripartizione relative a spese inserite solo fiscalmente
if (detrazione != null)
{
const string hqlRipartzioni = "FROM RipartizioneSpesa RIPSPE LEFT JOIN FETCH RIPSPE.ContoRiferimento CON JOIN FETCH RIPSPE.Spesa SPE LEFT JOIN FETCH SPE.Scadenze SCA LEFT JOIN FETCH SCA.Pagamenti PAG WHERE RIPSPE.Importo is not null AND SPE.EsercizioRiferimento.CondominioRiferimento = :condominio AND SPE.Detrazione = :detrazione AND year(PAG.Data) = :anno {0}";
var ripartizioni = _daoFactory.GetRipartizioneSpesaDao().GetByQuery(string.Format(hqlRipartzioni, whereSpese), parameters.ToArray()).Cast<IRipartizioneSpesa>().ToList();
foreach (var ripartizioneSpesa in ripartizioni)
{
movimenti.Add(ripartizioneSpesa);
}
}
}
// NON considero le spese personali (NON sono soggette a riparto), le spese ripartite tramite letture del contatore (NON riparto lineare) e le spese con riparto personalizzato
// ------------------------------------------------------------------------------------------------------------------------------------------------------
// TODO: Intevenire qui per poter gestire un riparto in cui a livello di modello sono mescolati addebiti a singoli stabili, scale e unità immobiliari
// Per ogni scala, stabile e unità aggiungere un ImportiContoSottocontoDTO specifico ... fare molti test!
// ------------------------------------------------------------------------------------------------------------------------------------------------------
foreach (var movimentoContabile in movimenti.Where(item => !item.GetContoRiferimento(detrazione != null).IsSpesePersonali && !item.IsRipartoPersonalizzato && (!item.RipartoTramiteLetture || item.DettaglioRipartizione.Count == 0) && (item.Spesa == null || item.Spesa.Utenza == null || !item.Spesa.Utenza.IsAllowRipartoLetture())))
{
if (addebitiDirettiStabileScala)
{
if (idStabile != null && !isAddebitatoStabile(movimentoContabile, idStabile.Value))
continue;
if (idScala != null && !isAddebitatoScala(movimentoContabile, idScala.Value))
continue;
}
else if (addebitiCondominio)
{
if (!string.IsNullOrEmpty(movimentoContabile.StabiliAddebito) || !string.IsNullOrEmpty(movimentoContabile.GruppiAddebito))
continue;
}
var contoRiferimento = movimentoContabile.GetContoRiferimento(detrazione != null);
var sottoContoRiferimento = movimentoContabile.SottoContoRiferimento;
int? idSottoConto = null;
if (sottoContoRiferimento != null)
idSottoConto = sottoContoRiferimento.ID;
else if(dettaglioSottoConto)
idSottoConto = movimentoContabile.ID*-1;
int? idContatoreRiferimento = null;
if (contoRiferimento.ContatoreRiferimento != null)
idContatoreRiferimento = contoRiferimento.ContatoreRiferimento.ID;
var stabili = new List<int>();
var scale = new List<int>();
if (!string.IsNullOrEmpty(movimentoContabile.StabiliAddebito))
stabili.AddRange(movimentoContabile.StabiliAddebito.Split('&').Select(int.Parse));
else if (!string.IsNullOrEmpty(movimentoContabile.GruppiAddebito))
scale.AddRange(movimentoContabile.GruppiAddebito.Split('&').Select(int.Parse));
if (stabili.Count > 0)
{
foreach (var id in stabili)
{
var importoConto = new ImportiContoSottocontoDTO
{
Conto = contoRiferimento.ID,
SottoConto = idSottoConto,
Stabile = id,
ContatoreRiferimento = idContatoreRiferimento,
ImportoProprieta = _ripartizioneService.GetImportoCompetenza(null, _daoFactory.GetPalazzinaDao().Find(id, false), movimentoContabile, null, null, TipoSoggetto.Proprietario, anno, detrazione),
ImportoConduzione = _ripartizioneService.GetImportoCompetenza(null, _daoFactory.GetPalazzinaDao().Find(id, false), movimentoContabile, null, null, TipoSoggetto.Conduttore, anno, detrazione)
};
addImporto(importoConto, importiConto);
}
}
else if (scale.Count > 0)
{
foreach (var id in scale)
{
var importoConto = new ImportiContoSottocontoDTO
{
Conto = contoRiferimento.ID,
SottoConto = idSottoConto,
Scala = id,
ContatoreRiferimento = idContatoreRiferimento,
ImportoProprieta = _ripartizioneService.GetImportoCompetenza(null, _daoFactory.GetGruppoStabileDao().Find(id, false), movimentoContabile, null, null, TipoSoggetto.Proprietario, anno, detrazione),
ImportoConduzione = _ripartizioneService.GetImportoCompetenza(null, _daoFactory.GetGruppoStabileDao().Find(id, false), movimentoContabile, null, null, TipoSoggetto.Conduttore, anno, detrazione)
};
addImporto(importoConto, importiConto);
}
}
else
{
var importoConto = new ImportiContoSottocontoDTO
{
Conto = contoRiferimento.ID,
SottoConto = idSottoConto,
ContatoreRiferimento = idContatoreRiferimento,
ImportoProprieta = _ripartizioneService.GetImportoCompetenza(movimentoContabile.GetImportoConSegno(detrazione != null).GetValueOrDefault(), movimentoContabile, TipoSoggetto.Proprietario, anno, detrazione),
ImportoConduzione = _ripartizioneService.GetImportoCompetenza(movimentoContabile.GetImportoConSegno(detrazione != null).GetValueOrDefault(), movimentoContabile, TipoSoggetto.Conduttore, anno, detrazione)
};
addImporto(importoConto, importiConto);
}
}
//====================================================================================
// Eseguo il riparto
//====================================================================================
var listaMillesimi = _daoFactory.GetMillesimoDao().GetByCondominio(condominio.ID);
var millesimiGroupByUnita = listaMillesimi.GroupBy(item => item.UnitaRiferimento.ID).ToList();
var millesimiGroupByConto = listaMillesimi.GroupBy(item => item.ContoRiferimento.ID).ToList();
var riparto = new Dictionary<string, SpeseUnitaRipartoDTO>();
var millesimiAttivi = new Dictionary<int, IList<MillesimoDTO>>();
foreach (var importiContoSottocontoDTO in importiConto)
{
if (importiContoSottocontoDTO.ContatoreRiferimento == null)
{
if (!listaMillesimi.Any() || listaMillesimi.Sum(item => item.Valore) == 0)
continue;
var spese = getRiparto(importiContoSottocontoDTO, millesimiGroupByConto, null, esercizio, dettaglioSottoConto);
addSpeseToRiparto(spese, riparto, dettaglioSottoConto);
}
else
{
var conto = _daoFactory.GetContoDao().GetById(importiContoSottocontoDTO.Conto, false);
List<int> stabili = null;
if (importiContoSottocontoDTO.Stabile != null)
stabili = new List<int> { importiContoSottocontoDTO.Stabile.GetValueOrDefault() };
List<int> scale = null;
if (importiContoSottocontoDTO.Scala != null)
scale = new List<int> { importiContoSottocontoDTO.Scala.GetValueOrDefault() };
IList<MillesimoDTO> millesimi;
if (millesimiAttivi.ContainsKey(conto.ID))
millesimi = millesimiAttivi[conto.ID];
else
{
millesimi = _millesimiService.GetByConto(conto, stabili, scale, esercizio);
millesimiAttivi.Add(conto.ID, millesimi);
}
var spese = getRiparto(conto, importiContoSottocontoDTO, millesimi, calcoloPerSubentro);
addSpeseToRiparto(spese, riparto, dettaglioSottoConto);
}
}
// Eseguo il riparto per le spese con riparto personalizzato ma che NON siano spese personali o spese ripartite tramite letture del contatore NON lineare (queste saranno considerate nel loop successivo)
foreach (var movimentoContabile in movimenti.Where(item => item.IsRipartoPersonalizzato && !item.RipartoTramiteLetture && !item.GetContoRiferimento(detrazione != null).IsSpesePersonali && (item.Spesa?.Utenza == null || !item.Spesa.Utenza.IsAllowRipartoLetture())))
{
var spese = getRiparto(movimentoContabile, millesimiGroupByConto, anno, detrazione, esercizio, dettaglioSottoConto);
addSpeseToRiparto(spese, riparto, dettaglioSottoConto);
}
// Aggiungo le spese personali (NON sono soggette a riparto) e le spese ripartite tramite letture del contatore
foreach (var movimentoContabile in movimenti.Where(item => (item.DettaglioRipartizione.Count > 0) && (item.GetContoRiferimento(detrazione != null).IsSpesePersonali || item.RipartoTramiteLetture || (item.Spesa?.Utenza != null && item.Spesa.Utenza.IsAllowRipartoLetture()))))
{
var contabile = movimentoContabile;
var spese = movimentoContabile.DettaglioRipartizione.Select(spesa => new SpeseUnitaRipartoDTO
{
ID = spesa.ID,
IdConto = contabile.GetContoRiferimento(detrazione != null).ID,
IdSottoConto = contabile.SottoContoRiferimento?.ID ?? contabile.ID * -1,
IdUnita = spesa.UnitaRiferimento?.ID,
IdSoggettoCondominio = spesa.SoggettoCondominio?.ID,
UnitaMisuraMillesimo = "PC",
ImportoConduttore = _ripartizioneService.GetImportoCompetenza(spesa, TipoSoggetto.Conduttore, anno, detrazione),
ImportoProprietario = _ripartizioneService.GetImportoCompetenza(spesa, TipoSoggetto.Proprietario, anno, detrazione)
});
addSpeseToRiparto(spese, riparto, dettaglioSottoConto);
}
//=====================================================================================================
// Elaborazione delle ripartizioni
//=====================================================================================================
foreach (var spesaAggregata in riparto.ToList())
{
try
{
var spesa = spesaAggregata.Value;
var conto = conti.ContainsKey(spesa.IdConto) ? conti[spesa.IdConto] : _daoFactory.GetContoDao().GetById(spesa.IdConto, false);
SottoConto sottoconto = null;
if (dettaglioSottoConto && spesa.IdSottoConto > 0)
sottoconto = conto.SottoConti.FirstOrDefault(item => item.ID == spesa.IdSottoConto.Value);
UnitaImmobiliare unita = null;
SoggettoCondominio soggetto = null;
if (spesa.IdUnita != null)
unita = findUnitaImmobiliare(spesa.IdUnita.GetValueOrDefault(), soggettiAttivi);
if (spesa.IdSoggettoCondominio != null)
soggetto = findSoggettoCondominio(spesa.IdSoggettoCondominio.GetValueOrDefault(), soggettiAttiviIndex);
// -------------------------------------------------------
// Verifica se appartiene a scala e/o stabile selezionato
// -------------------------------------------------------
SoggettoCondominio proprietarioPrincipale = null;
SoggettoCondominio conduttorePrincipale = null;
// Se il soggetto è diverso da null individuo immediatamente il proprietario o il conduttore principale
if (soggetto != null)
{
unita = soggetto.UnitaImmobiliare;
if (!accorpamentoUnita)
{
switch (soggetto.Tipo)
{
case TipoSoggetto.Proprietario:
proprietarioPrincipale = soggetto;
break;
case TipoSoggetto.Conduttore:
conduttorePrincipale = soggetto;
break;
}
}
}
if (idStabile != null)
{
if (unita.GruppoStabileRiferimento.PalazzinaRiferimento.ID != idStabile.Value)
continue;
}
if (idScala != null)
{
if (unita.GruppoStabileRiferimento.ID != idScala.Value)
continue;
}
// -------------------------
// Proprietario
// -------------------------
if (proprietarioPrincipale == null)
{
try
{
if (soggettiAttivi.ContainsKey(unita.ID))
{
var proprietariPrincipali = (soggettiAttivi[unita.ID].Where(item =>
item.Tipo == TipoSoggetto.Proprietario &&
item.Principale.GetValueOrDefault())).ToList();
if (proprietariPrincipali.Count > 1)
{
if (proprietariPrincipali.All(item => item.DataInizio == null) || proprietariPrincipali.All(item => item.DataFine == null))
_log.DebugFormat("Trovato più di un PROPRIETARIO principale - {0} - unità:{1} - esercizio:{2}", Utility.GetMethodDescription(), spesa.IdUnita, idEsercizio);
}
proprietarioPrincipale = proprietariPrincipali.OrderByDescending(item => item.DataInizio.GetValueOrDefault()).FirstOrDefault(item => item.DataFine == null);
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella ricerca del proprietario principale - {0} - unita:{1}", ex, Utility.GetMethodDescription(), unita.ID);
throw;
}
}
if (conduttorePrincipale == null)
{
if (soggettiAttivi.ContainsKey(unita.ID))
{
var conduttoriPrincipale = (soggettiAttivi[unita.ID].Where(item =>
item.Tipo == TipoSoggetto.Conduttore &&
item.Principale.GetValueOrDefault())).ToList();
if (conduttoriPrincipale.Count > 1)
_log.WarnFormat("Trovato più di un CONDUTTORE principale - {0} - idUnita:{1} - esercizio:{2}", Utility.GetMethodDescription(), spesa.IdUnita, idEsercizio);
conduttorePrincipale = conduttoriPrincipale.FirstOrDefault();
}
}
// Se il proprietario non è presente lo cerco tra tutti i proprietari
if (proprietarioPrincipale == null)
{
var dataLimite = DateTime.Today;
if (esercizio != null)
dataLimite = esercizio.DataChiusura.GetValueOrDefault();
else if (anno != null)
dataLimite = new DateTime(anno.GetValueOrDefault(), 12, 31);
proprietarioPrincipale = (unita.Proprietari.Where(item =>
item.DataInizio == null || item.DataInizio.Value < dataLimite)
.OrderByDescending(item => item.DataInizio.GetValueOrDefault())).FirstOrDefault();
if (proprietarioPrincipale != null && !soggettiAttiviIndex.ContainsKey(proprietarioPrincipale.ID))
{
if (soggettiAttivi.ContainsKey(proprietarioPrincipale.UnitaImmobiliare.ID))
soggettiAttivi[proprietarioPrincipale.UnitaImmobiliare.ID].Add(proprietarioPrincipale);
else
soggettiAttivi.Add(proprietarioPrincipale.UnitaImmobiliare.ID, new List<SoggettoCondominio>() { proprietarioPrincipale });
}
}
var importoProprieta = spesa.ImportoProprietario;
if (importoProprieta == null)
{
_log.ErrorFormat("ATTENZIONE: Importo a null - {0} - id:{1} - conto:{2} - soggetto:{3} - unità:{4}", Utility.GetMethodDescription(), spesa.ID, spesa.IdConto, spesa.IdSoggettoCondominio, spesa.IdUnita);
throw new InvalidDataException(
$"Per il conto '{conto.Descrizione}' la ripartizione personalizzata dell'unità immobiliare '{unita.Ordine} - {unita.Descrizione}' non è corretta.");
}
if (importoProprieta.GetValueOrDefault() != 0)
{
var soggProp = new List<ImportiDTO>();
if (spesa.IdUnita != null)
{
if (!accorpamentoUnita)
{
// --------------------------------------------------------------------
// Individuo tutti i soggetti tra cui ripartire l'importo
// --------------------------------------------------------------------
var soggPropRip = (conto.SoggettiRipartizione.Where(itemSogg =>
itemSogg.Soggetto.Tipo == TipoSoggetto.Proprietario &&
itemSogg.Soggetto.UnitaImmobiliare.ID == spesa.IdUnita)).ToList();
// In presenza di ripartizioni personalizzate occorre dividere l'importo addebito alla proprietà tra i diversi proprietari
if (soggPropRip.Count > 0)
{
var totaleSoggPropRip = soggPropRip.Sum(item => item.PercentualeRipartizione);
soggProp.AddRange(from sogg in soggPropRip
let soggettoRipartizione = sogg.Soggetto
select new ImportiDTO
{
Id = soggettoRipartizione.ID,
Importo = (importoProprieta.GetValueOrDefault() * sogg.PercentualeRipartizione) / totaleSoggPropRip
});
}
else if (soggPropRip.Count == 0)
{
var spesa1 = spesa;
IList<SoggettoCondominio> proprietariAttivi = new List<SoggettoCondominio>();
if (soggettiAttivi.ContainsKey(spesa1.IdUnita.GetValueOrDefault()))
proprietariAttivi = soggettiAttivi[spesa1.IdUnita.GetValueOrDefault()].Where(item => item.Tipo == TipoSoggetto.Proprietario).ToList();
else
_log.WarnFormat("Non trovato nessun condomino per l'unità immobiliare - {0} - unità:{1} - condominio:{2} - azienda:{3}", Utility.GetMethodDescription(), spesa1.IdUnita, idCondominio, condominio.Azienda.ID);
if (proprietariAttivi.Count == 0 && proprietarioPrincipale != null)
proprietariAttivi.Add(proprietarioPrincipale);
if (proprietariAttivi.Sum(item => item.PercentualeRiferimento) != 100)
{
if (proprietariAttivi.All(item => item.DataInizio == null) || proprietariAttivi.All(item => item.DataFine == null))
_log.WarnFormat("ATTENZIONE: La somma della percentuale di riparto non è 100 - SPESE PROPRIETARI - {0} - unità:{1} - spesa:{2} - esercizio:{3}", Utility.GetMethodDescription(), spesa.IdUnita, spesa.ID, idEsercizio);
if (proprietariAttivi.Count == 1)
proprietariAttivi[0].PercentualeRiferimento = 100m;
}
soggProp.AddRange(proprietariAttivi.Select(soggAttivo => new ImportiDTO { Id = soggAttivo.ID, Importo = (importoProprieta.GetValueOrDefault() * soggAttivo.PercentualeRiferimento.GetValueOrDefault()) / 100 }));
}
}
else
soggProp.Add(new ImportiDTO(proprietarioPrincipale.ID, importoProprieta.GetValueOrDefault()));
}
else
soggProp.Add(new ImportiDTO(proprietarioPrincipale.ID, importoProprieta.GetValueOrDefault()));
foreach (var idSogg in soggProp)
{
try
{
if (idSogg.Importo != 0 && proprietarioPrincipale != null)
{
var key = getKey(spesa.IdConto, spesa.IdSottoConto, proprietarioPrincipale.UnitaImmobiliare.ID, idSogg.Id, accorpamentoUnita, TipoSoggetto.Proprietario, dettaglioSottoConto);
ReportRipartizioneBilancioDTO item;
if (lista.ContainsKey(key))
item = lista[key];
else
{
item = new ReportRipartizioneBilancioDTO();
lista.Add(key, item);
item.Importo = 0;
item.IdConto = spesa.IdConto;
item.DisabilitaStampaMillesimi = conto.IsSpesePersonali || conto.DisabilitaMillesimiRiparto;
var codice = string.Empty;
if (conto.Codice != null)
codice = conto.Codice;
item.CodiceConto = codice;
if (dettaglioSottoConto)
{
var codiceSottoConto = string.Empty;
var descrizioneSottoConto = string.Empty;
if (sottoconto != null)
{
if (!string.IsNullOrEmpty(sottoconto.Codice))
codiceSottoConto = sottoconto.Codice;
descrizioneSottoConto = sottoconto.Descrizione;
}
else if (spesa.IdSottoConto < 0)
{
var movimento = _daoFactory.GetMovimentoContabileDao().Find(spesa.IdSottoConto.GetValueOrDefault() * -1, false);
if (movimento != null)
descrizioneSottoConto = movimento.GetDescrizione();
}
item.IdSottoConto = spesa.IdSottoConto;
item.CodiceSottoConto = codiceSottoConto;
item.DescrizioneSottoConto = descrizioneSottoConto;
}
item.DescrizioneConto = !string.IsNullOrEmpty(conto.DescrizioneBilancio) && !dettaglioSottoConto
? conto.DescrizioneBilancio
: conto.Descrizione;
item.OrdineConto = conto.Ordine;
item.IdUnitaImmobiliare = proprietarioPrincipale.UnitaImmobiliare.ID;
item.TipoUnitaImmobiliare = unita.TipoUnitaImmobiliare.Descrizione;
item.IdGruppoStabile = unita.GruppoStabileRiferimento.ID;
item.DescrizioneGruppoStabile = unita.GruppoStabileRiferimento.Descrizione;
item.OrdineGruppoStabile = unita.GruppoStabileRiferimento.Ordine;
item.IdStabile = unita.GruppoStabileRiferimento.PalazzinaRiferimento.ID;
item.DescrizioneStabile = unita.GruppoStabileRiferimento.PalazzinaRiferimento.Descrizione;
item.OrdineStabile = unita.GruppoStabileRiferimento.PalazzinaRiferimento.Ordine;
item.OrdineUnitaImmobiliare = unita.Ordine.GetValueOrDefault();
item.SubalternoUnitaImmobiliare = unita.Subalterno;
item.PianoUnitaImmobiliare = unita.Piano;
item.InternoUnitaImmobiliare = getInternoUnitaImmobiliare(unita);
item.Millesimi = spesa.ValoreMillesimo;
item.UnitaMisuraMillesimi = spesa.UnitaMisuraMillesimo;
item.MillesimiProprieta = getUnitaMillProp(unita, millesimiGroupByUnita);
if (!accorpamentoUnita)
{
var sogg = findSoggettoCondominio(idSogg.Id, soggettiAttiviIndex);
item.Nominativo = sogg.DisplayName;
item.IdPartecipante = sogg.ID;
item.IdPersona = sogg.Persona.ID;
}
else
{
item.Nominativo = proprietarioPrincipale.UnitaImmobiliare.Descrizione;
item.IdPartecipante = proprietarioPrincipale.ID;
item.IdPersona = proprietarioPrincipale.Persona.ID;
}
item.DataUscitaPartecipante = getDataUscita(proprietarioPrincipale);
item.OrdinePartecipante = 10;
item.TipoNominativo = "PROP";
item.TipoNominativoEffettivo = findSoggettoCondominio(item.IdPartecipante, soggettiAttiviIndex).Tipo.ToString().Substring(0, 1);
item.NumeroColonne = 1;
}
item.Importo += idSogg.Importo;
}
else
{
if (proprietarioPrincipale == null)
{
throw new InvalidDataException($"Per l'unità immobiliare {unita.Ordine} non è presente un proprietario principale");
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la lettura del datasource per il riparto del consuntivo - (SPESE - PROPRIETARI) - {0} - idSogg:{1} - idSpesa:{2} - idEsercizio:{3}", ex, Utility.GetMethodDescription(), idSogg.Id, spesa.ID, idEsercizio);
throw;
}
}
}
// -------------------------
// Conduttore
// -------------------------
if (spesa.ImportoConduttore.GetValueOrDefault() != 0)
{
var soggCond = new List<ImportiDTO>();
int idUnita;
if (spesa.IdUnita != null)
{
idUnita = spesa.IdUnita.GetValueOrDefault();
if (!accorpamentoUnita)
{
var soggCondRip = (conto.SoggettiRipartizione.Where(itemSogg =>
itemSogg.Soggetto.Tipo == TipoSoggetto.Conduttore &&
itemSogg.Soggetto.UnitaImmobiliare.ID == spesa.IdUnita)).ToList();
if (soggCondRip.Count > 0)
{
var totaleSoggCondRip = soggCondRip.Sum(item => item.PercentualeRipartizione);
soggCond.AddRange(soggCondRip.Select(sogg => new ImportiDTO
{
Id = sogg.Soggetto.ID,
Importo = (spesa.ImportoConduttore.GetValueOrDefault() * sogg.PercentualeRipartizione) / totaleSoggCondRip
}));
}
else if (soggCondRip.Count == 0)
{
var conduttoriAttivi = (soggettiAttivi[spesa.IdUnita.GetValueOrDefault()].Where(item =>
item.Tipo == TipoSoggetto.Conduttore &&
item.PercentualeRiferimento > 0)).ToList();
if (!conduttoriAttivi.Any())
{
var spesa1 = spesa;
conduttoriAttivi = (soggettiAttivi[spesa1.IdUnita.GetValueOrDefault()].Where(item =>
item.Tipo == TipoSoggetto.Proprietario)).ToList();
}
if (conduttoriAttivi.Sum(item => item.PercentualeRiferimento) != 100)
{
_log.WarnFormat("ATTENZIONE: La somma della percentuale di riparto non è 100 - SPESE CONDUTTORI - {0} - unità:{1} - spesa:{2} - esercizio:{3}", Utility.GetMethodDescription(), spesa.IdUnita, spesa.ID, idEsercizio);
}
soggCond.AddRange(conduttoriAttivi.Select(soggAttivo => new ImportiDTO { Id = soggAttivo.ID, Importo = (spesa.ImportoConduttore.GetValueOrDefault() * soggAttivo.PercentualeRiferimento.GetValueOrDefault()) / 100 }));
}
}
else if (proprietarioPrincipale != null)
soggCond.Add(new ImportiDTO(proprietarioPrincipale.ID, spesa.ImportoConduttore.GetValueOrDefault()));
}
else
{
if (conduttorePrincipale == null)
{
conduttorePrincipale =
soggettiEsercizio.Where(
item =>
item.UnitaImmobiliare.ID ==
proprietarioPrincipale.UnitaImmobiliare.ID &&
item.Tipo == TipoSoggetto.Conduttore)
.OrderByDescending(item => item.Principale)
.FirstOrDefault();
}
if (conduttorePrincipale == null)
conduttorePrincipale = _daoFactory.GetSoggettoCondominioDao().Find(spesa.IdSoggettoCondominio.GetValueOrDefault(), false);
if (conduttorePrincipale != null)
{
soggCond.Add(new ImportiDTO(conduttorePrincipale.ID, spesa.ImportoConduttore.GetValueOrDefault()));
idUnita = conduttorePrincipale.UnitaImmobiliare.ID;
}
else
throw new InvalidDataException($"Per l'unità immobiliare {unita.Descrizione} il conduttore non è configurato correttamente.{Environment.NewLine}Si prega di verificare e rilanciare l'esecuzione.");
}
foreach (var idSogg in soggCond)
{
try
{
if (idSogg.Importo != 0)
{
var key = getKey(spesa.IdConto, spesa.IdSottoConto, idUnita, idSogg.Id, accorpamentoUnita, TipoSoggetto.Conduttore, dettaglioSottoConto);
ReportRipartizioneBilancioDTO item;
if (lista.ContainsKey(key))
item = lista[key];
else
{
item = new ReportRipartizioneBilancioDTO();
lista.Add(key, item);
item.Importo = 0;
item.IdConto = spesa.IdConto;
item.DisabilitaStampaMillesimi = conto.IsSpesePersonali || conto.DisabilitaMillesimiRiparto;
var codice = string.Empty;
if (conto.Codice != null)
codice = conto.Codice;
item.CodiceConto = codice;
item.DescrizioneConto = !string.IsNullOrEmpty(conto.DescrizioneBilancio) && !dettaglioSottoConto ? conto.DescrizioneBilancio : conto.Descrizione;
item.OrdineConto = conto.Ordine;
if (dettaglioSottoConto)
{
var codiceSottoConto = string.Empty;
var descrizioneSottoConto = string.Empty;
if (sottoconto != null)
{
if (!string.IsNullOrEmpty(sottoconto.Codice))
codiceSottoConto = sottoconto.Codice;
descrizioneSottoConto = sottoconto.Descrizione;
}
else if (spesa.IdSottoConto < 0)
{
var movimento = _daoFactory.GetMovimentoContabileDao().Find(spesa.IdSottoConto.GetValueOrDefault()*-1, false);
if (movimento != null)
descrizioneSottoConto = movimento.GetDescrizione();
}
item.IdSottoConto = spesa.IdSottoConto;
item.CodiceSottoConto = codiceSottoConto;
item.DescrizioneSottoConto = descrizioneSottoConto;
}
item.IdUnitaImmobiliare = idUnita;
item.TipoUnitaImmobiliare = unita.TipoUnitaImmobiliare.Descrizione;
item.IdGruppoStabile = unita.GruppoStabileRiferimento.ID;
item.DescrizioneGruppoStabile = unita.GruppoStabileRiferimento.Descrizione;
item.IdStabile = unita.GruppoStabileRiferimento.PalazzinaRiferimento.ID;
item.DescrizioneStabile = unita.GruppoStabileRiferimento.PalazzinaRiferimento.Descrizione;
item.OrdineGruppoStabile = unita.GruppoStabileRiferimento.Ordine;
item.OrdineStabile = unita.GruppoStabileRiferimento.PalazzinaRiferimento.Ordine;
item.OrdineUnitaImmobiliare = unita.Ordine.GetValueOrDefault();
item.InternoUnitaImmobiliare = getInternoUnitaImmobiliare(unita);
item.SubalternoUnitaImmobiliare = unita.Subalterno;
item.PianoUnitaImmobiliare = unita.Piano;
item.Millesimi = spesa.ValoreMillesimo;
item.UnitaMisuraMillesimi = spesa.UnitaMisuraMillesimo;
item.MillesimiProprieta = getUnitaMillProp(unita, millesimiGroupByUnita);
if (!accorpamentoUnita)
{
var sogg = findSoggettoCondominio(idSogg.Id, soggettiAttiviIndex);
item.DataUscitaPartecipante = getDataUscita(sogg);
item.Nominativo = sogg.DisplayName;
item.IdPartecipante = sogg.ID;
item.IdPersona = sogg.Persona.ID;
}
else
{
item.DataUscitaPartecipante = getDataUscita(proprietarioPrincipale);
item.Nominativo = proprietarioPrincipale.UnitaImmobiliare.Descrizione;
item.IdPartecipante = proprietarioPrincipale.ID;
item.IdPersona = proprietarioPrincipale.Persona.ID;
}
item.OrdinePartecipante = 20;
item.TipoNominativo = "COND";
item.TipoNominativoEffettivo = ripartizioneProprietarioConduttore ? "C" : findSoggettoCondominio(item.IdPartecipante, soggettiAttiviIndex).Tipo.ToString().Substring(0, 1);
item.NumeroColonne = 1;
}
item.Importo += idSogg.Importo;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la lettura del datasource per il riparto del consuntivo - SPESE CONDUTTORI - {0} - soggetto:{1} - spesa:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), idSogg.Id, spesa.ID, idEsercizio);
throw;
}
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la lettura del datasource per il riparto del consuntivo - (SPESE) - {0} - idSpesa:{1} - esercizio:{2} - anno:{3} - detrazione:{4}", ex, Utility.GetMethodDescription(), spesaAggregata.Value.ID, idEsercizio.GetValueOrDefault(), anno.GetValueOrDefault(), detrazione.GetValueOrDefault());
throw;
}
}
//==============================================================================================================
// Elaborazione SUBENTRI per avere una riga per ogni soggetto
//==============================================================================================================
elaboraSubentri(esercizio, accorpamentoUnita, lista, soggettiAttivi, conti, dettaglioSottoConto);
//==============================================================================================================
// Calcolo totali spese
//==============================================================================================================
var totali = new Dictionary<string, ReportRipartizioneBilancioDTO>();
foreach (var itemGroup in lista.Values.GroupBy(item => item.IdPartecipante.ToString().PadLeft(10, '0') + "&" + item.TipoNominativo))
{
try
{
var itemSpesa = itemGroup.FirstOrDefault();
var totaleKey = getKey(0, null, itemSpesa.IdUnitaImmobiliare, itemSpesa.IdPartecipante, accorpamentoUnita, itemSpesa.TipoNominativo == "PROP" ? TipoSoggetto.Proprietario : TipoSoggetto.Conduttore, dettaglioSottoConto);
// Somma gli importi raggruppati per conto perchè deve arrotondare l'importo a livello di conto
var groupConto = itemGroup.GroupBy(item => item.IdConto);
var importoTotale = groupConto.Sum(itemGroupConto => Math.Round(itemGroupConto.Sum(item => item.Importo.GetValueOrDefault()), 2));
if (!totali.ContainsKey(totaleKey))
{
var itemTotale = getItemTotale(itemSpesa);
itemTotale.Importo = importoTotale;
totali.Add(totaleKey, itemTotale);
}
else
{
var itemTotale = totali[totaleKey];
itemTotale.Importo += importoTotale;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel calcolo dei totali - SINGOLO TOTALE - {0} - key:{1}", ex, Utility.GetMethodDescription(), itemGroup.Key);
throw;
}
}
//==============================================================================================================
// SOLO se NON si tratta di un riparto per DETRAZIONE
//==============================================================================================================
if (esercizio != null)
{
var versamenti = _versamentiCondominiService.GetImportoMovimentiVersatoByEsercizio(esercizio, idStabile, idScala);
//==============================================================================================================
// Ripartizione delle differenze tra Rendiconto e Riparto
//==============================================================================================================
// Merge
var saldi = _daoFactory.GetSaldoSoggettoDao().GetByEsercizioStabileScala(esercizio, idStabile, idScala);
var saldiCalcolati = new Dictionary<int, ReportRipartizioneBilancioDTO>();
var versamentiCalcolati = new List<int>();
var totaliCalcolati = new List<ReportRipartizioneBilancioDTO>();
// Se il soggetto non è presente nei totali (quindi non ha nessuna spesa addebitata) lo aggiungo con un elemento FAKE (666), che poi
// provvederò a cancellare, per permettere l'inserimento degli elementi di saldo e versamenti
// ----------------------------------------------------------------------------------------------------------------------------------
// Saldi
foreach (var saldo in saldi)
{
try
{
totali = elaboraSoggetto(saldo.Soggetto, soggettiAttivi, totali, esercizio, accorpamentoUnita);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la lettura del datasource per il riparto del consuntivo (SALDI FAKE) - {0} - saldo:{1} - esercizio:{2}", ex, Utility.GetMethodDescription(), saldo.ID, idEsercizio);
throw;
}
}
// Versamenti
foreach (var item in versamenti)
{
try
{
var soggetto = findSoggettoCondominio(item.Id, soggettiAttiviIndex);
if (soggetto != null)
{
if (idStabile != null)
{
if (soggetto.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.ID != idStabile.Value)
continue;
}
if (idScala != null)
{
if (soggetto.UnitaImmobiliare.GruppoStabileRiferimento.ID != idScala.Value)
continue;
}
totali = elaboraSoggetto(soggetto, soggettiAttivi, totali, esercizio, accorpamentoUnita);
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la lettura del datasource per il riparto del consuntivo (VERSAMENTI FAKE) - {0} - soggetto:{1} - importo:{2:c} - esercizio:{3}", ex, Utility.GetMethodDescription(), item.Id, item.Importo, idEsercizio);
throw;
}
}
//==============================================================================================================
// Elaborazione dei totali + saldi e versamenti
//==============================================================================================================
var partecipantiElaborati = new List<int>();
// Leggo i versamenti successivi alla chiusura solo per gli esercizi ordinari
PianoRatealeDettaglio pianoRatealeDettaglio = null;
if (esercizio.Gestione == GestioneEsercizioEnum.Ordinario)
{
var esercizioSuccessivo = _daoFactory.GetEsercizioDao().GetEsercizioCompetenza(esercizio.CondominioRiferimento, esercizio.DataChiusura.GetValueOrDefault().AddDays(1));
if (esercizioSuccessivo != null)
pianoRatealeDettaglio = _daoFactory.GetPianoRatealeDettaglioDao().GetRataVersamentoDopoChiusura(esercizioSuccessivo);
}
foreach (var kvp in totali)
{
try
{
var soggetto = findSoggettoCondominio(kvp.Value.IdPartecipante, soggettiAttiviIndex);
// Può capitare in caso di subentro senza trasferimento di saldi e versamenti
lista.Add(kvp.Key, kvp.Value);
// ---------------------------------------------------------
// Saldo Anno Precedente
// ---------------------------------------------------------
var itemRiporto = new ReportRipartizioneBilancioDTO();
if (!saldiCalcolati.ContainsKey(kvp.Value.IdPartecipante))
{
// Inserisco il saldo solo se diverso da 0, oppure se è relativo al proprietario principale. (bugid#999)
// La riga del proprietario deve essere sempre presente anche se tutti gli importi sono a 0, il conduttore
// invece non deve essere presente se gli importi sono a 0
int? idPartecipante = kvp.Value.IdPartecipante;
int? idUnitaImmobiliare = null;
if (accorpamentoUnita)
{
idPartecipante = null;
idUnitaImmobiliare = kvp.Value.IdUnitaImmobiliare;
}
var saldo = getSaldoBySoggettoUnita(saldi, idPartecipante, idUnitaImmobiliare);
if ((saldo != null && saldo != 0) || (kvp.Value.TipoNominativo == "PROP" && soggetto.Principale.GetValueOrDefault()))
{
itemRiporto = cloneItem(kvp.Value);
itemRiporto.DescrizioneConto = "Saldo Esercizio Precedente";
itemRiporto.OrdineConto = 9991;
itemRiporto.CodiceConto = null;
itemRiporto.DisabilitaStampaMillesimi = true;
if (accorpamentoUnita)
{
var propPrincipale = (from item in soggettiAttivi[kvp.Value.IdUnitaImmobiliare]
where item.Tipo == TipoSoggetto.Proprietario && item.Principale.GetValueOrDefault()
orderby item.DataInizio.GetValueOrDefault() descending
select item).FirstOrDefault();
// Se il proprietario non è presente lo cerco tra tutti i proprietari
if (propPrincipale == null)
{
propPrincipale = (from item in soggetto.UnitaImmobiliare.Proprietari
where item.DataInizio == null || item.DataInizio.Value < esercizio.DataChiusura
orderby item.DataInizio.GetValueOrDefault() descending
select item).FirstOrDefault();
_log.DebugFormat("Non trovato proprietario principale - {0} - unità:{1} - esercizio:{2}", Utility.GetMethodDescription(), soggetto.UnitaImmobiliare.ID, idEsercizio.ToString());
}
itemRiporto.IdPartecipante = propPrincipale.ID;
itemRiporto.IdPersona = propPrincipale.Persona.ID;
itemRiporto.Nominativo = propPrincipale.UnitaImmobiliare.Descrizione;
}
itemRiporto.Importo = saldo != null ? saldo.Value : 0;
var sogg = _daoFactory.GetSoggettoCondominioDao().GetById(itemRiporto.IdPartecipante, false);
itemRiporto.TipoNominativo = (sogg.Tipo == TipoSoggetto.Proprietario) ? "PROP" : "COND";
itemRiporto.TipoNominativoEffettivo = sogg.Tipo.ToString().Substring(0, 1);
lista.Add(kvp.Key + "_RIPORTO", itemRiporto);
saldiCalcolati.Add(kvp.Value.IdPartecipante, itemRiporto);
}
}
// ---------------------------------------------------------
// Versamenti
// ---------------------------------------------------------
var itemVersato = new ReportRipartizioneBilancioDTO();
if (!versamentiCalcolati.Contains(kvp.Value.IdPartecipante))
{
decimal versamento;
if (!accorpamentoUnita)
{
var kvp1 = kvp;
versamento = (versamenti.Where(item => item.Id == kvp1.Value.IdPartecipante)).Sum(item => item.Importo);
}
else
{
var kvp1 = kvp;
var soggettiUnita = soggettiAttivi[kvp1.Value.IdUnitaImmobiliare].Select(item => item.ID);
versamento = (versamenti.Where(item => soggettiUnita.Contains(item.Id))).Sum(item => item.Importo);
}
// Inserisco il versamento solo se diverso da 0, oppure se è relativo al proprietario. (bugid#999)
// La riga del proprietario deve essere sempre presente anche se tutti gli importi sono a 0, il conduttore
// invece non deve essere presente se gli importi sono a 0
if (versamento != 0 || (kvp.Value.TipoNominativo == "PROP" && soggetto != null && soggetto.Principale.GetValueOrDefault()))
{
itemVersato = cloneItem(kvp.Value);
itemVersato.DescrizioneConto = "Versato";
itemVersato.OrdineConto = 9992;
itemVersato.CodiceConto = null;
itemVersato.DisabilitaStampaMillesimi = true;
if (accorpamentoUnita)
{
var propPrincipale = findProprietarioPrincipale(kvp.Value.IdUnitaImmobiliare, soggettiAttivi, soggetto.UnitaImmobiliare, esercizio);
// Se il proprietario non è presente lo cerco tra tutti i proprietari
if (propPrincipale == null)
{
propPrincipale = (soggetto.UnitaImmobiliare.Proprietari.Where(
item => item.DataInizio == null || item.DataInizio.Value < esercizio.DataChiusura)
.OrderByDescending(item => item.DataInizio.GetValueOrDefault())).FirstOrDefault();
_log.DebugFormat("Non trovato proprietario principale - {0} - unità:{1} - esercizio:{2}", Utility.GetMethodDescription(), soggetto.UnitaImmobiliare.ID, idEsercizio.ToString());
}
itemVersato.IdPartecipante = propPrincipale.ID;
itemVersato.IdPersona = propPrincipale.Persona.ID;
itemVersato.Nominativo = propPrincipale.UnitaImmobiliare.Descrizione;
}
var sogg = _daoFactory.GetSoggettoCondominioDao().GetById(itemVersato.IdPartecipante, false);
itemVersato.TipoNominativo = (sogg.Tipo == TipoSoggetto.Proprietario) ? "PROP" : "COND";
itemVersato.TipoNominativoEffettivo = sogg.Tipo.ToString().Substring(0, 1);
itemVersato.Importo = versamento;
lista.Add(kvp.Key + "_VERSATO", itemVersato);
versamentiCalcolati.Add(kvp.Value.IdPartecipante);
}
}
//----------------------------------------------------------
// Versamenti dopo la chiusura
//----------------------------------------------------------
if (pianoRatealeDettaglio != null && pianoRatealeDettaglio.RateSoggetti.Count > 0 && !partecipantiElaborati.Contains(kvp.Value.IdPartecipante))
{
var kvp1 = kvp;
partecipantiElaborati.Add(kvp.Value.IdPartecipante);
var itemVersamentoDopoChiusura = cloneItem(kvp.Value);
itemVersamentoDopoChiusura.DescrizioneConto = "Di cui Versamenti dopo la Chiusura";
itemVersamentoDopoChiusura.OrdineConto = 9995;
itemVersamentoDopoChiusura.CodiceConto = null;
itemVersamentoDopoChiusura.DisabilitaStampaMillesimi = true;
if (accorpamentoUnita)
{
var propPrincipale = findProprietarioPrincipale(kvp.Value.IdUnitaImmobiliare, soggettiAttivi, soggetto.UnitaImmobiliare, esercizio);
// Se il proprietario non è presente lo cerco tra tutti i proprietari
if (propPrincipale == null)
{
propPrincipale = (soggetto.UnitaImmobiliare.Proprietari.Where(
item => item.DataInizio == null || item.DataInizio.Value < esercizio.DataChiusura)
.OrderByDescending(item => item.DataInizio.GetValueOrDefault())).FirstOrDefault();
_log.WarnFormat("Non trovato proprietario principale - {0} - unità:{1} - esercizio:{2}", Utility.GetMethodDescription(), soggetto.UnitaImmobiliare.ID, idEsercizio);
}
itemVersamentoDopoChiusura.IdPartecipante = propPrincipale.ID;
itemVersamentoDopoChiusura.IdPersona = propPrincipale.Persona.ID;
itemVersamentoDopoChiusura.Nominativo = propPrincipale.UnitaImmobiliare.Descrizione;
}
var sogg = _daoFactory.GetSoggettoCondominioDao().GetById(itemVersamentoDopoChiusura.IdPartecipante, false);
itemVersamentoDopoChiusura.TipoNominativo = (sogg.Tipo == TipoSoggetto.Proprietario) ? "PROP" : "COND";
itemVersamentoDopoChiusura.TipoNominativoEffettivo = sogg.Tipo.ToString().Substring(0, 1);
itemVersamentoDopoChiusura.Importo = pianoRatealeDettaglio.RateSoggetti.Where(item => item.Soggetto.ID == kvp1.Value.IdPartecipante).Sum(item => item.Importo);
lista.Add(kvp.Key + "_VERSATODOPOCHIUSURA", itemVersamentoDopoChiusura);
}
// ---------------------------------------------------------
// Importi a Debito e a Credito
// ---------------------------------------------------------
var importoTotale = kvp.Value.Importo.Value + itemRiporto.Importo.GetValueOrDefault() - itemVersato.Importo.GetValueOrDefault();
// Solo se l'importo è <> 0 oppure se la riga è relativa al proprietario principale
if (importoTotale != 0 || (kvp.Value.TipoNominativo == "PROP" && soggetto != null && soggetto.Principale.GetValueOrDefault()))
{
var idSoggettoTotali = kvp.Value.IdPartecipante;
if (accorpamentoUnita)
{
var propPrincipale = findProprietarioPrincipale(kvp.Value.IdUnitaImmobiliare, soggettiAttivi, soggetto.UnitaImmobiliare, esercizio);
// Se il proprietario non è presente lo cerco tra tutti i proprietari
if (propPrincipale == null)
{
propPrincipale = (soggetto.UnitaImmobiliare.Proprietari.Where(
item => item.DataInizio == null || item.DataInizio.Value < esercizio.DataChiusura)
.OrderByDescending(item => item.DataInizio.GetValueOrDefault())).FirstOrDefault();
_log.DebugFormat("Non trovato proprietario principale - {0} - unità:{1} - esercizio:{2}", Utility.GetMethodDescription(), soggetto.UnitaImmobiliare.ID, idEsercizio.ToString());
}
idSoggettoTotali = propPrincipale.ID;
}
var importoDto = totaliCalcolati.SingleOrDefault(item => item.IdPartecipante == idSoggettoTotali);
if (importoDto == null)
{
importoDto = cloneItem(kvp.Value);
importoDto.Importo = importoTotale;
totaliCalcolati.Add(importoDto);
}
else
importoDto.Importo += importoTotale;
}
// se necessario inverto i saldi
if (impostazioni != null && impostazioni.InversioneSaldiRate)
itemRiporto.Importo = itemRiporto.Importo.GetValueOrDefault() * -1;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la lettura del datasource per il riparto del consuntivo - SALDI E VERSAMENTI - {0} - unità:{1} - soggetto:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), kvp.Value.IdUnitaImmobiliare, kvp.Value.IdPartecipante, idEsercizio);
throw;
}
}
// ===================================================================
// Rielaboro i totali calcolati
// ===================================================================
foreach (var itemTotale in totaliCalcolati)
{
var sogg = _daoFactory.GetSoggettoCondominioDao().GetById(itemTotale.IdPartecipante, false);
// Debito
var itemDebitoCredito = cloneItem(itemTotale);
itemDebitoCredito.CodiceConto = null;
itemDebitoCredito.Importo = itemTotale.Importo;
itemDebitoCredito.TipoNominativo = (sogg.Tipo == TipoSoggetto.Proprietario) ? "PROP" : "COND";
itemDebitoCredito.TipoNominativoEffettivo = sogg.Tipo.ToString().Substring(0, 1);
if (itemTotale.Importo > 0)
{
itemDebitoCredito.DescrizioneConto = "a Debito";
itemDebitoCredito.OrdineConto = 9993;
}
else
{
itemDebitoCredito.DescrizioneConto = "a Credito";
itemDebitoCredito.OrdineConto = 9994;
}
if (inversioneSaldi)
itemDebitoCredito.Importo = itemDebitoCredito.Importo * -1;
lista.Add(itemDebitoCredito.IdPartecipante + "_DEBITOCREDITO", itemDebitoCredito);
}
}
else
{
//==============================================================================================================
// Stampa detrazioni devo rielaborare i totali
//==============================================================================================================
foreach (var kvp in totali)
{
try
{
lista.Add(kvp.Key, kvp.Value);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la lettura del datasource per il riparto del consuntivo - TOTALI IN STAMPA DETRAZIONI - {0} - unità:{1} - soggetto:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), kvp.Value.IdUnitaImmobiliare, kvp.Value.IdPartecipante, idEsercizio);
throw;
}
}
}
//==============================================================================================================
// Rielaboro lista finale
//==============================================================================================================
IList<ReportRipartizioneBilancioDTO> listaRiparto;
try
{
// Tolgo gli elementi FAKE aggiunti per permettere l'inserimento di tutti i saldi e versamenti
listaRiparto = lista.Values.Where(item => item.CodiceConto != "666").ToList();
// I Millesimi deve comparire solo sul primo soggetto per una stessa unità immmobiliare (bugid#1002)
var listaContoGroup = listaRiparto.GroupBy(item => item.IdConto).Select(contoGroup => contoGroup);
foreach (var itemGroup in listaContoGroup)
{
var listaUnitaGroup = itemGroup.GroupBy(item => item.IdUnitaImmobiliare).Select(unitaGroup => unitaGroup);
foreach (var unitaGroup in listaUnitaGroup)
{
var first = true;
foreach (var item in unitaGroup.OrderByDescending(item2 => item2.TipoNominativo).ThenBy(item2 => item2.Nominativo))
{
if (!first)
item.Millesimi = null;
first = false;
}
}
}
//==============================================================================================================
// Applico eventuali accorpamenti
//==============================================================================================================
if (!accorpamentoUnita)
{
var soggetti = new List<SoggettoCondominio>();
foreach (var kvp in soggettiAttivi)
soggetti.AddRange(kvp.Value.ToList());
listaRiparto = elaboraAccorpamento(listaRiparto, tipoAccorpamento, soggetti, millesimiAttivi, esercizio, null, null);
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la lettura del datasource per il riparto del consuntivo - RIELABORAZIONE LISTA FINALE - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), idEsercizio);
throw;
}
//==============================================================================================================
// Elimino righe per conti vuoti
//==============================================================================================================
listaRiparto = elaboraRigheContiVuoti(listaRiparto);
//==============================================================================================================
// Aggiungo colonna spese conduzione
//==============================================================================================================
var listaConduzione = listaRiparto.Where(item => item.OrdineConto < 9990 && item.TipoNominativo == "COND").GroupBy(item => item.IdPartecipante).ToList();
foreach (var item in listaConduzione)
{
var firstItem = item.FirstOrDefault();
if (firstItem != null)
{
// Debito
var itemConduzione = cloneItem(firstItem);
itemConduzione.IdConto = 0;
itemConduzione.CodiceConto = null;
itemConduzione.IdSottoConto = null;
itemConduzione.CodiceSottoConto = null;
itemConduzione.Importo = item.Sum(itemImporto => itemImporto.Importo);
itemConduzione.TipoNominativo = "COND";
itemConduzione.TipoNominativoEffettivo = firstItem.TipoNominativoEffettivo;
itemConduzione.DescrizioneConto = "Spese Conduzione";
itemConduzione.OrdineConto = 9996;
listaRiparto.Add(itemConduzione);
lista.Add(itemConduzione.IdPartecipante + "_CONDUZIONE", itemConduzione);
}
}
//==============================================================================================================
// ARROTONDAMENTO Importi generazione di una nuova riga di arrotondamenti
//==============================================================================================================
var importiNonArrotondati = new List<ReportRipartizioneBilancioDTO>();
foreach (var reportRipartizioneBilancioDTO in listaRiparto.Where(item => item.OrdineConto < 9990))
{
if (reportRipartizioneBilancioDTO.Importo != null)
{
var importoArrotondato = Math.Round(reportRipartizioneBilancioDTO.Importo.GetValueOrDefault(), 2);
var importoArrotondamento = reportRipartizioneBilancioDTO.Importo.GetValueOrDefault() - importoArrotondato;
var itemImportoArrotondato = importiNonArrotondati.FirstOrDefault(item => item.IdConto == reportRipartizioneBilancioDTO.IdConto && item.DescrizioneConto == reportRipartizioneBilancioDTO.DescrizioneConto);
if (itemImportoArrotondato == null)
{
itemImportoArrotondato = getItemArrotondamenti(reportRipartizioneBilancioDTO);
itemImportoArrotondato.Importo = importoArrotondamento;
importiNonArrotondati.Add(itemImportoArrotondato);
}
else
itemImportoArrotondato.Importo += importoArrotondamento;
reportRipartizioneBilancioDTO.Importo = importoArrotondato;
}
}
// Aggiungo anche il totale degli arrotondamenti
var totaleArrotondamento = 0m;
foreach (var reportRipartizioneBilancioDTO in importiNonArrotondati)
{
reportRipartizioneBilancioDTO.Importo = Math.Round(reportRipartizioneBilancioDTO.Importo.GetValueOrDefault(), 2);
totaleArrotondamento += reportRipartizioneBilancioDTO.Importo.GetValueOrDefault();
}
if (totaleArrotondamento != 0)
{
var itemImportoArrotondato = getItemArrotondamenti(importiNonArrotondati.FirstOrDefault());
itemImportoArrotondato.OrdineConto = 9990;
itemImportoArrotondato.IdConto = 0;
itemImportoArrotondato.DescrizioneConto = "Totale Spese";
itemImportoArrotondato.IdSottoConto = null;
itemImportoArrotondato.Importo = totaleArrotondamento;
importiNonArrotondati.Add(itemImportoArrotondato);
var itemImportoArrotondatoDebitoCredito = getItemArrotondamenti(importiNonArrotondati.FirstOrDefault());
itemImportoArrotondatoDebitoCredito.IdConto = 0;
itemImportoArrotondatoDebitoCredito.IdSottoConto = null;
itemImportoArrotondatoDebitoCredito.Importo = totaleArrotondamento;
if (inversioneSaldi)
itemImportoArrotondatoDebitoCredito.Importo = itemImportoArrotondatoDebitoCredito.Importo * -1;
if (totaleArrotondamento < 0)
{
itemImportoArrotondatoDebitoCredito.OrdineConto = 9994;
itemImportoArrotondatoDebitoCredito.DescrizioneConto = "a Credito";
}
else
{
itemImportoArrotondatoDebitoCredito.OrdineConto = 9993;
itemImportoArrotondatoDebitoCredito.DescrizioneConto = "a Debito";
}
importiNonArrotondati.Add(itemImportoArrotondatoDebitoCredito);
}
foreach (var reportRipartizioneBilancioDTO in importiNonArrotondati)
{
listaRiparto.Add(reportRipartizioneBilancioDTO);
}
// ======================================================
// Add Empty items - Per una corretta visualizzazione
// nel report multicolonna
// ======================================================
if (!ripartizioneProprietarioConduttore && !dettaglioSottoConto)
{
var emptyItems = getEmptyItems(listaRiparto);
foreach (var reportRipartizioneBilancioDTO in emptyItems)
listaRiparto.Add(reportRipartizioneBilancioDTO);
}
// ======================================================
// Rielaborazione millesimi
// ======================================================
elaborazioneMillesimi(listaRiparto);
// ======================================================
// Rielaborazione nominativi
// ======================================================
elaborazioneNominativi(listaRiparto);
// ======================================================
// Ritorno solo le righe dei condomini selezionati
// ======================================================
if (idSoggetti != null)
listaRiparto = listaRiparto.Where(item => (item.OrdineConto < 9990 || item.OrdineConto == 9991 || item.OrdineConto == 9992) && idSoggetti.Contains(item.IdPartecipante)).ToList();
return listaRiparto.OrderBy(item => item.IdGruppoStabile);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la lettura del datasource per il riparto del consuntivo - {0} - esercizio:{1} - condominio:{2} - anno:{3} - detrazione:{4} - stabile:{5} - scala:{6} - ripartizioneProprietarioConduttore:{7} - accorpamentoUnita:{8} - inversioneSaldi:{9}", ex, Utility.GetMethodDescription(), idEsercizio, idCondominio.GetValueOrDefault(), anno.GetValueOrDefault(), detrazione.GetValueOrDefault(), idStabile.GetValueOrDefault(), idScala.GetValueOrDefault(), ripartizioneProprietarioConduttore, tipoAccorpamento, inversioneSaldi);
throw;
}
}
public override IEnumerable<ReportRipartizioneBilancioDTO> GetDataSourceRipartizioneBilancioPreventivo(int idEsercizio, int? idStabile, int? idScala, bool ripartizioneProprietarioConduttore, bool accorpamentoUnita, TipoAccorpamentoRateEnum tipoAccorpamento, bool inversioneSaldi, bool stampaSaldi, bool addebitiCondominio, bool calcoloPerSubentro, bool addebitiDirettiStabileScala, IList<int> idSoggetti, bool dettaglioSottoConto = false)
{
try
{
var esercizio = _daoFactory.GetEsercizioDao().GetById(idEsercizio, false);
var condominio = esercizio.CondominioRiferimento;
var rendicontoDaUsare = getRendicontoPreventivoCorrente(idEsercizio);
if (rendicontoDaUsare != null)
{
ImpostazioniAzienda impostazioni = null;
IList<SoggettoCondominio> soggettiEsercizio = null;
if (condominio != null)
{
impostazioni = _daoFactory.GetImpostazioniAziendaDao().GetByAzienda(condominio.Azienda.ID);
soggettiEsercizio = _daoFactory.GetSoggettoCondominioDao().GetAttiviByEsercizio(esercizio, null);
}
// -------------------------------------------------------------------------------------------
// TODO: Da eliminare quando saranno riscritti i subentri - bugid#8425
var soggettiAttivi = new List<SoggettoCondominio>();
if (soggettiEsercizio != null)
{
foreach (var soggettoCondominio in soggettiEsercizio)
{
if (soggettoCondominio.Tipo == TipoSoggetto.Proprietario || soggettoCondominio.DataInizio == null || soggettoCondominio.DataInizio.GetValueOrDefault() <= esercizio.DataApertura.GetValueOrDefault())
soggettiAttivi.Add(soggettoCondominio);
}
}
// -------------------------------------------------------------------------------------------
//==============================================================================================================
// Lettura elementi report per CONTO
//==============================================================================================================
var lista = getReportItemsPreventivo(esercizio, rendicontoDaUsare, soggettiAttivi, idStabile, idScala, ripartizioneProprietarioConduttore, accorpamentoUnita, inversioneSaldi, calcoloPerSubentro, addebitiCondominio, addebitiDirettiStabileScala, dettaglioSottoConto);
//==============================================================================================================
// Calcolo totali spese
//==============================================================================================================
var totali = new List<ReportRipartizioneBilancioDTO>();
foreach (var itemGroup in lista.GroupBy(item => item.IdPartecipante.ToString(CultureInfo.InvariantCulture).PadLeft(10, '0') + "&" + item.TipoNominativo))
{
var itemSpesa = itemGroup.FirstOrDefault();
var itemTotale = getItemTotale(itemSpesa);
itemTotale.Importo = itemGroup.Sum(item => Math.Round(item.Importo.GetValueOrDefault(), 2));
totali.Add(itemTotale);
}
//==============================================================================================================
// Ripartizione delle differenze tra Rendiconto e Riparto
//==============================================================================================================
var saldi = _daoFactory.GetSaldoSoggettoDao().GetByEsercizioStabileScala(esercizio, idStabile, idScala);
var saldiCalcolati = new Dictionary<int, ReportRipartizioneBilancioDTO>();
var totaliCalcolati = new List<ReportRipartizioneBilancioDTO>();
// Se il soggetto non è presente nei totali (quindi non ha nessuna spesa addebitata) lo aggiungo con un elemento FAKE (666), che poi
// provvederò a cancellare, per permettere l'inserimento degli elementi di saldo e versamenti
// ----------------------------------------------------------------------------------------------------------------------------------
// Saldi
if (stampaSaldi)
{
foreach (var saldo in saldi)
{
try
{
totali = elaboraSoggetto(saldo.Soggetto, soggettiAttivi, totali, esercizio, accorpamentoUnita);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la lettura del datasource per il riparto del consuntivo (SALDI) - {0} - (FAKE) - saldo:{1} - esercizio:{2}", ex, Utility.GetMethodDescription(), saldo.ID, idEsercizio);
throw;
}
}
}
//==============================================================================================================
// Elaborazione dei totali + saldi
//==============================================================================================================
foreach (var kvp in totali.Where(item => item.IdPartecipante > 0))
{
try
{
var soggetto = (soggettiAttivi.Where(item => item.ID == kvp.IdPartecipante)).SingleOrDefault() ??
_daoFactory.GetSoggettoCondominioDao().GetById(kvp.IdPartecipante, false);
// Può capitare in caso di subentro senza trasferimento di saldi e versamenti
lista.Add(kvp);
// ---------------------------------------------------------
// Saldo Anno Precedente
// ---------------------------------------------------------
var itemRiporto = new ReportRipartizioneBilancioDTO();
if (stampaSaldi && !saldiCalcolati.ContainsKey(kvp.IdPartecipante))
{
// Inserisco il saldo solo se diverso da 0, oppure se è relativo al proprietario principale. (bugid#999)
// La riga del proprietario deve essere sempre presente anche se tutti gli importi sono a 0, il conduttore
// invece non deve essere presente se gli importi sono a 0
int? idPartecipante = kvp.IdPartecipante;
int? idUnitaImmobiliare = null;
if (accorpamentoUnita)
{
idPartecipante = null;
idUnitaImmobiliare = kvp.IdUnitaImmobiliare;
}
var saldo = getSaldoBySoggettoUnita(saldi, idPartecipante, idUnitaImmobiliare);
if ((saldo != null && saldo != 0) || (kvp.TipoNominativo == "PROP" && soggetto.Principale.GetValueOrDefault()))
{
itemRiporto = cloneItem(kvp);
itemRiporto.DescrizioneConto = "Saldo Anno Prec";
itemRiporto.OrdineConto = 9991;
itemRiporto.CodiceConto = null;
itemRiporto.DisabilitaStampaMillesimi = true;
if (accorpamentoUnita)
{
var propPrincipale = (soggettiAttivi.Where(
item => item.Tipo == TipoSoggetto.Proprietario &&
item.Principale.GetValueOrDefault() &&
item.UnitaImmobiliare.ID == kvp.IdUnitaImmobiliare)).SingleOrDefault();
// Se il proprietario non è presente lo cerco tra tutti i proprietari
if (propPrincipale == null)
{
propPrincipale = (soggetto.UnitaImmobiliare.Proprietari.Where(item => item.DataInizio == null || item.DataInizio.Value < esercizio.DataChiusura)
.OrderByDescending(item => item.DataInizio.GetValueOrDefault())).FirstOrDefault();
_log.DebugFormat("Non trovato proprietario principale - {0} - unità:{1} - esercizio:{2}", Utility.GetMethodDescription(), soggetto.UnitaImmobiliare.ID, idEsercizio.ToString());
}
itemRiporto.IdPartecipante = propPrincipale.ID;
itemRiporto.IdPersona = propPrincipale.Persona.ID;
itemRiporto.Nominativo = propPrincipale.UnitaImmobiliare.Descrizione;
}
itemRiporto.Importo = saldo ?? 0;
var sogg = _daoFactory.GetSoggettoCondominioDao().GetById(itemRiporto.IdPartecipante, false);
itemRiporto.TipoNominativo = (sogg.Tipo == TipoSoggetto.Proprietario) ? "PROP" : "COND";
itemRiporto.TipoNominativoEffettivo = sogg.Tipo.ToString().Substring(0, 1);
lista.Add(itemRiporto);
saldiCalcolati.Add(kvp.IdPartecipante, itemRiporto);
}
}
// ---------------------------------------------------------
// Importi a Debito e a Credito
// ---------------------------------------------------------
var importoTotale = kvp.Importo.Value + itemRiporto.Importo.GetValueOrDefault();
// Solo se l'importo è <> 0 oppure se la riga è relativa al proprietario principale
if (importoTotale != 0 || (kvp.TipoNominativo == "PROP" && soggetto != null && soggetto.Principale.GetValueOrDefault()))
{
var idSoggettoTotali = kvp.IdPartecipante;
if (accorpamentoUnita)
{
var propPrincipale = (from item in soggettiAttivi
where
item.Tipo == TipoSoggetto.Proprietario &&
item.Principale.GetValueOrDefault() &&
item.UnitaImmobiliare.ID == kvp.IdUnitaImmobiliare
select item).SingleOrDefault();
// Se il proprietario non è presente lo cerco tra tutti i proprietari
if (propPrincipale == null)
{
propPrincipale = (soggetto.UnitaImmobiliare.Proprietari.Where(item => item.DataInizio == null || item.DataInizio.Value < esercizio.DataChiusura)
.OrderByDescending(item => item.DataInizio.GetValueOrDefault())).FirstOrDefault();
_log.DebugFormat("Non trovato proprietario principale - {0} - unità:{1} - esercizio:{2}", Utility.GetMethodDescription(), soggetto.UnitaImmobiliare.ID, idEsercizio.ToString());
}
idSoggettoTotali = propPrincipale.ID;
}
var importoDto = totaliCalcolati.SingleOrDefault(item => item.IdPartecipante == idSoggettoTotali);
if (importoDto == null)
{
importoDto = cloneItem(kvp);
importoDto.Importo = importoTotale;
totaliCalcolati.Add(importoDto);
}
else
importoDto.Importo += importoTotale;
}
// se necessario inverto i saldi
if (impostazioni != null && impostazioni.InversioneSaldiRate)
itemRiporto.Importo = itemRiporto.Importo.GetValueOrDefault() * -1;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la lettura del datasource per il riparto del consuntivo - SALDI E VERSAMENTI - {0} - unità immobiliare:{1} - soggetto:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), kvp.IdUnitaImmobiliare, kvp.IdPartecipante, idEsercizio);
throw;
}
}
// ===================================================================
// Rielaboro i totali calcolati
// ===================================================================
if (stampaSaldi)
{
foreach (var itemTotale in totaliCalcolati)
{
var sogg = _daoFactory.GetSoggettoCondominioDao().GetById(itemTotale.IdPartecipante, false);
// Debito
var itemDebitoCredito = cloneItem(itemTotale);
itemDebitoCredito.CodiceConto = null;
itemDebitoCredito.Importo = itemTotale.Importo;
itemDebitoCredito.TipoNominativo = (sogg.Tipo == TipoSoggetto.Proprietario) ? "PROP" : "COND";
itemDebitoCredito.TipoNominativoEffettivo = sogg.Tipo.ToString().Substring(0, 1);
if (itemTotale.Importo > 0)
{
itemDebitoCredito.DescrizioneConto = "a Debito";
itemDebitoCredito.OrdineConto = 9993;
}
else
{
itemDebitoCredito.DescrizioneConto = "a Credito";
itemDebitoCredito.OrdineConto = 9994;
}
if (inversioneSaldi)
itemDebitoCredito.Importo = itemDebitoCredito.Importo * -1;
lista.Add(itemDebitoCredito);
}
}
//==============================================================================================================
// Rielaboro lista finale
//==============================================================================================================
try
{
// Tolgo gli elementi FAKE aggiunti per permettere l'inserimento di tutti i saldi e versamenti
IList<ReportRipartizioneBilancioDTO> listaRiparto = (lista.Where(item => item.CodiceConto != "666")).ToList();
// I Millesimi deve comparire solo sul primo soggetto per una stessa unità immmobiliare (bugid#1002)
var listaContoGroup = listaRiparto.GroupBy(item => item.IdConto).Select(contoGroup => contoGroup);
foreach (var itemGroup in listaContoGroup)
{
var listaUnitaGroup = itemGroup.GroupBy(item => item.IdUnitaImmobiliare).Select(unitaGroup => unitaGroup);
foreach (var unitaGroup in listaUnitaGroup)
{
var first = true;
foreach (var item in unitaGroup.OrderByDescending(item2 => item2.TipoNominativo).ThenBy(item2 => item2.Nominativo))
{
if (!first)
item.Millesimi = null;
first = false;
}
}
}
//==============================================================================================================
// Applico eventuali accorpamenti
//==============================================================================================================
if (!accorpamentoUnita)
listaRiparto = elaboraAccorpamento(listaRiparto, tipoAccorpamento, soggettiAttivi, null, null, null, null);
//==============================================================================================================
// Elimino righe per conti vuoti
//==============================================================================================================
listaRiparto = elaboraRigheContiVuoti(listaRiparto);
//==============================================================================================================
// Aggiungo colonna spese conduzione
//==============================================================================================================
var listaConduzione = listaRiparto.Where(item => item.OrdineConto < 9990 && item.TipoNominativo == "COND").GroupBy(item => item.IdPartecipante).ToList();
foreach (var item in listaConduzione)
{
var firstItem = item.FirstOrDefault();
if (firstItem != null)
{
// Debito
var itemConduzione = cloneItem(firstItem);
itemConduzione.IdConto = 0;
itemConduzione.CodiceConto = null;
itemConduzione.IdSottoConto = null;
itemConduzione.CodiceSottoConto = null;
itemConduzione.Importo = item.Sum(itemImporto => itemImporto.Importo);
itemConduzione.TipoNominativo = "COND";
itemConduzione.TipoNominativoEffettivo = firstItem.TipoNominativoEffettivo;
itemConduzione.DescrizioneConto = "Spese Conduzione";
itemConduzione.OrdineConto = 9996;
listaRiparto.Add(itemConduzione);
lista.Add(itemConduzione);
}
}
//==============================================================================================================
// ARROTONDAMENTO Importi generazione di una nuova riga di arrotondamenti
//==============================================================================================================
var importiNonArrotondati = new List<ReportRipartizioneBilancioDTO>();
foreach (var reportRipartizioneBilancioDTO in listaRiparto.Where(item => item.OrdineConto < 9990))
{
if (reportRipartizioneBilancioDTO.Importo != null)
{
var importoArrotondato = Math.Round(reportRipartizioneBilancioDTO.Importo.GetValueOrDefault(), 2);
var importoArrotondamento = reportRipartizioneBilancioDTO.Importo.GetValueOrDefault() - importoArrotondato;
var itemImportoArrotondato = importiNonArrotondati.FirstOrDefault(item => item.IdConto == reportRipartizioneBilancioDTO.IdConto && item.DescrizioneConto == reportRipartizioneBilancioDTO.DescrizioneConto);
if (itemImportoArrotondato == null)
{
itemImportoArrotondato = getItemArrotondamenti(reportRipartizioneBilancioDTO);
itemImportoArrotondato.Importo = importoArrotondamento;
importiNonArrotondati.Add(itemImportoArrotondato);
}
else
itemImportoArrotondato.Importo += importoArrotondamento;
// Aggiorno gli importi a due decimali bugid#3091
reportRipartizioneBilancioDTO.Importo = importoArrotondato;
}
}
// Aggiungo anche il totale degli arrotondamenti
var totaleArrotondamento = 0m;
foreach (var reportRipartizioneBilancioDTO in importiNonArrotondati)
{
reportRipartizioneBilancioDTO.Importo = Math.Round(reportRipartizioneBilancioDTO.Importo.GetValueOrDefault(), 2);
totaleArrotondamento += reportRipartizioneBilancioDTO.Importo.GetValueOrDefault();
}
if (totaleArrotondamento != 0)
{
var itemImportoArrotondato = getItemArrotondamenti(importiNonArrotondati.FirstOrDefault());
itemImportoArrotondato.OrdineConto = 9990;
itemImportoArrotondato.IdConto = 0;
itemImportoArrotondato.DescrizioneConto = "Totale Spese";
itemImportoArrotondato.Importo = totaleArrotondamento;
importiNonArrotondati.Add(itemImportoArrotondato);
var itemImportoArrotondatoDebitoCredito = getItemArrotondamenti(importiNonArrotondati.FirstOrDefault());
itemImportoArrotondatoDebitoCredito.IdConto = 0;
itemImportoArrotondatoDebitoCredito.Importo = totaleArrotondamento;
if (inversioneSaldi)
itemImportoArrotondatoDebitoCredito.Importo = itemImportoArrotondatoDebitoCredito.Importo * -1;
if (totaleArrotondamento < 0)
{
itemImportoArrotondatoDebitoCredito.OrdineConto = 9994;
itemImportoArrotondatoDebitoCredito.DescrizioneConto = "a Credito";
}
else
{
itemImportoArrotondatoDebitoCredito.OrdineConto = 9993;
itemImportoArrotondatoDebitoCredito.DescrizioneConto = "a Debito";
}
importiNonArrotondati.Add(itemImportoArrotondatoDebitoCredito);
}
foreach (var reportRipartizioneBilancioDTO in importiNonArrotondati)
{
listaRiparto.Add(reportRipartizioneBilancioDTO);
}
// ======================================================
// Add Empty items - Per una corretta visualizzazione
// nel report multicolonna
// ======================================================
if (!ripartizioneProprietarioConduttore && !dettaglioSottoConto)
{
var emptyItems = getEmptyItems(listaRiparto);
foreach (var reportRipartizioneBilancioDTO in emptyItems)
listaRiparto.Add(reportRipartizioneBilancioDTO);
}
// ======================================================
// Rielaborazione millesimi
// ======================================================
elaborazioneMillesimi(listaRiparto);
// ======================================================
// Ritorno solo le righe dei condomini selezionati
// ======================================================
if (idSoggetti != null)
listaRiparto = listaRiparto.Where(item => idSoggetti.Contains(item.IdPartecipante)).ToList();
return listaRiparto.OrderBy(item => item.IdGruppoStabile);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la lettura del datasource per il riparto del preventivo - RIELABORAZIONE LISTA FINALE - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), idEsercizio);
throw;
}
}
return null;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la lettura del datasource per il riparto del preventivo - {0} - esercizio:{1} - stabile:{2} - scala:{3} - ripartizioneProprietarioConduttore:{4} - accorpamentoUnita:{5} - inversioneSaldi:{6}", ex, Utility.GetMethodDescription(), idEsercizio, idStabile.GetValueOrDefault(), idScala.GetValueOrDefault(), ripartizioneProprietarioConduttore, tipoAccorpamento, inversioneSaldi);
throw;
}
}
private IList<ReportRipartizioneBilancioDTO> elaboraAccorpamento(IList<ReportRipartizioneBilancioDTO> lista, TipoAccorpamentoRateEnum tipoAccorpamento, IList<SoggettoCondominio> soggettiAttivi, Dictionary<int, IList<MillesimoDTO>> millesimiAttivi, Esercizio esercizio, List<int> stabili, List<int> scale)
{
if (tipoAccorpamento == TipoAccorpamentoRateEnum.Personalizzato)
{
var listaAccorpata = new List<ReportRipartizioneBilancioDTO>(lista.Count);
var listaSoggettiAccorpati = new Dictionary<SoggettoCondominio, IList<SoggettoCondominio>>();
foreach (var reportRipartizioneBilancioDTO in lista)
{
var soggetto = _daoFactory.GetSoggettoCondominioDao().Find(reportRipartizioneBilancioDTO.IdPartecipante, false);
if (soggetto?.SoggettoPrincipale != null)
{
IList<MillesimoDTO> millesimi = null;
if (millesimiAttivi != null && reportRipartizioneBilancioDTO.IdConto > 0)
{
if (millesimiAttivi.ContainsKey(reportRipartizioneBilancioDTO.IdConto))
millesimi = millesimiAttivi[reportRipartizioneBilancioDTO.IdConto];
else
{
millesimi = _millesimiService.GetByConto(_daoFactory.GetContoDao().GetById(reportRipartizioneBilancioDTO.IdConto, false), stabili, scale, esercizio);
millesimiAttivi.Add(reportRipartizioneBilancioDTO.IdConto, millesimi);
}
}
reportRipartizioneBilancioDTO.IdGruppoStabile = soggetto.SoggettoPrincipale.UnitaImmobiliare.GruppoStabileRiferimento.ID;
reportRipartizioneBilancioDTO.OrdineGruppoStabile = soggetto.SoggettoPrincipale.UnitaImmobiliare.GruppoStabileRiferimento.Ordine;
reportRipartizioneBilancioDTO.DescrizioneGruppoStabile = soggetto.SoggettoPrincipale.UnitaImmobiliare.GruppoStabileRiferimento.Descrizione;
reportRipartizioneBilancioDTO.IdStabile = soggetto.SoggettoPrincipale.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.ID;
reportRipartizioneBilancioDTO.OrdineStabile = soggetto.SoggettoPrincipale.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.Ordine;
reportRipartizioneBilancioDTO.DescrizioneStabile = soggetto.SoggettoPrincipale.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.Descrizione;
reportRipartizioneBilancioDTO.IdPartecipante = soggetto.SoggettoPrincipale.ID;
reportRipartizioneBilancioDTO.IdPersona = soggetto.SoggettoPrincipale.Persona.ID;
reportRipartizioneBilancioDTO.IdUnitaImmobiliare = soggetto.SoggettoPrincipale.UnitaImmobiliare.ID;
reportRipartizioneBilancioDTO.InternoUnitaImmobiliare = soggetto.SoggettoPrincipale.UnitaImmobiliare.InternoCompleto;
reportRipartizioneBilancioDTO.Nominativo = soggetto.SoggettoPrincipale.DisplayName;
reportRipartizioneBilancioDTO.OrdineUnitaImmobiliare = soggetto.SoggettoPrincipale.UnitaImmobiliare.Ordine.GetValueOrDefault();
reportRipartizioneBilancioDTO.SubalternoUnitaImmobiliare = soggetto.SoggettoPrincipale.UnitaImmobiliare.Subalterno;
reportRipartizioneBilancioDTO.PianoUnitaImmobiliare = soggetto.SoggettoPrincipale.UnitaImmobiliare.Piano;
reportRipartizioneBilancioDTO.TipoUnitaImmobiliare = soggetto.SoggettoPrincipale.UnitaImmobiliare.TipoUnitaImmobiliare.Descrizione;
reportRipartizioneBilancioDTO.Millesimi = reportRipartizioneBilancioDTO.Millesimi.GetValueOrDefault() + (getMillesimoBySoggettoConto(soggetto.SoggettoPrincipale, reportRipartizioneBilancioDTO.IdConto, new List<string>(), millesimi) * soggetto.SoggettoPrincipale.PercentualeRiferimento.GetValueOrDefault()) / 100;
// Creo lista dei soggetti accorpati per permttere l'accorpamento dei millesimi
addListaSoggettiAccorpati(listaSoggettiAccorpati, reportRipartizioneBilancioDTO, soggetto, soggettiAttivi);
}
else if (soggetto == null)
_log.WarnFormat("Soggetto null - {0} - soggetto:{1} - tipoAccorpamento:{1}", Utility.GetMethodDescription(), tipoAccorpamento);
listaAccorpata.Add(reportRipartizioneBilancioDTO);
}
// Accorpamento dei millesimi
var millesimiElaborati = new List<string>();
foreach (var item in listaSoggettiAccorpati.OrderBy(item => item.Key.Tipo.ToString()))
{
var listaAccorpataSoggetto = listaAccorpata.Where(itemReport => itemReport.IdPartecipante == item.Key.ID);
foreach (var reportRipartizioneBilancioDTO in listaAccorpataSoggetto)
{
IList<MillesimoDTO> millesimi = null;
if (millesimiAttivi != null && reportRipartizioneBilancioDTO.IdConto > 0)
{
if (millesimiAttivi.ContainsKey(reportRipartizioneBilancioDTO.IdConto))
millesimi = millesimiAttivi[reportRipartizioneBilancioDTO.IdConto];
else
{
millesimi = _millesimiService.GetByConto(_daoFactory.GetContoDao().GetById(reportRipartizioneBilancioDTO.IdConto, false), stabili, scale, esercizio);
millesimiAttivi.Add(reportRipartizioneBilancioDTO.IdConto, millesimi);
}
}
reportRipartizioneBilancioDTO.Millesimi = getMillesimoBySoggettoConto(item.Key, reportRipartizioneBilancioDTO.IdConto, millesimiElaborati, millesimi) + item.Value.Sum(soggettoValue => getMillesimoBySoggettoConto(soggettoValue, reportRipartizioneBilancioDTO.IdConto, millesimiElaborati, millesimi));
}
}
var listaPersonalizzata = new List<ReportRipartizioneBilancioDTO>(listaAccorpata.Count);
foreach (var reportRipartizioneBilancioDTO in listaAccorpata)
{
if (reportRipartizioneBilancioDTO.OrdineConto == 9993 || reportRipartizioneBilancioDTO.OrdineConto == 9994)
{
var items = listaPersonalizzata.Where(item => item.IdPartecipante == reportRipartizioneBilancioDTO.IdPartecipante && (item.OrdineConto == 9993 || item.OrdineConto == 9994)).ToList();
if (items.Any())
{
var itemPersonalizzato = items.FirstOrDefault();
if (itemPersonalizzato != null)
{
itemPersonalizzato.Importo = itemPersonalizzato.Importo.GetValueOrDefault() + reportRipartizioneBilancioDTO.Importo.GetValueOrDefault();
if (itemPersonalizzato.Importo > 0)
{
itemPersonalizzato.OrdineConto = 9994;
itemPersonalizzato.DescrizioneConto = "a Credito";
}
else
{
itemPersonalizzato.OrdineConto = 9993;
itemPersonalizzato.DescrizioneConto = "a Debito";
}
}
if (items.Count > 1)
_log.WarnFormat("Trovata più di una riga per lo stesso soggetto - {0} - soggetto:{1} - unità immobiliare:{2}", Utility.GetMethodDescription(), reportRipartizioneBilancioDTO.IdPartecipante, reportRipartizioneBilancioDTO.IdUnitaImmobiliare);
continue;
}
listaPersonalizzata.Add(reportRipartizioneBilancioDTO);
}
else
listaPersonalizzata.Add(reportRipartizioneBilancioDTO);
}
return listaPersonalizzata;
}
if (tipoAccorpamento == TipoAccorpamentoRateEnum.Persona)
{
var listaPerPersona = new List<ReportRipartizioneBilancioDTO>(lista.Count);
foreach (var reportRipartizioneBilancioDTO in lista.OrderBy(item => item.OrdineUnitaImmobiliare))
{
var itemPerPersona = listaPerPersona.SingleOrDefault(item => item.IdPersona == reportRipartizioneBilancioDTO.IdPersona && ((item.OrdineConto == reportRipartizioneBilancioDTO.OrdineConto && item.IdSottoConto == reportRipartizioneBilancioDTO.IdSottoConto) || ((item.OrdineConto == 9993 || item.OrdineConto == 9994) && (reportRipartizioneBilancioDTO.OrdineConto == 9993 || reportRipartizioneBilancioDTO.OrdineConto == 9994))));
if (itemPerPersona == null)
{
var soggettoPrincipale = soggettiAttivi.OrderBy(item => item.UnitaImmobiliare.Ordine).FirstOrDefault(item => item.Persona.ID == reportRipartizioneBilancioDTO.IdPersona);
if (soggettoPrincipale != null)
{
reportRipartizioneBilancioDTO.IdPartecipante = soggettoPrincipale.ID;
reportRipartizioneBilancioDTO.IdUnitaImmobiliare = soggettoPrincipale.UnitaImmobiliare.ID;
reportRipartizioneBilancioDTO.TipoUnitaImmobiliare = soggettoPrincipale.UnitaImmobiliare.TipoUnitaImmobiliare.Descrizione;
reportRipartizioneBilancioDTO.IdGruppoStabile = soggettoPrincipale.UnitaImmobiliare.GruppoStabileRiferimento.ID;
reportRipartizioneBilancioDTO.DescrizioneGruppoStabile = soggettoPrincipale.UnitaImmobiliare.GruppoStabileRiferimento.Descrizione;
reportRipartizioneBilancioDTO.OrdineGruppoStabile = soggettoPrincipale.UnitaImmobiliare.GruppoStabileRiferimento.Ordine;
reportRipartizioneBilancioDTO.IdStabile = soggettoPrincipale.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.ID;
reportRipartizioneBilancioDTO.DescrizioneStabile = soggettoPrincipale.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.Descrizione;
reportRipartizioneBilancioDTO.OrdineStabile = soggettoPrincipale.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.Ordine;
reportRipartizioneBilancioDTO.OrdineUnitaImmobiliare = soggettoPrincipale.UnitaImmobiliare.Ordine.GetValueOrDefault();
reportRipartizioneBilancioDTO.SubalternoUnitaImmobiliare = soggettoPrincipale.UnitaImmobiliare.Subalterno;
reportRipartizioneBilancioDTO.PianoUnitaImmobiliare = soggettoPrincipale.UnitaImmobiliare.Piano;
reportRipartizioneBilancioDTO.InternoUnitaImmobiliare = getInternoUnitaImmobiliare(soggettoPrincipale.UnitaImmobiliare);
}
listaPerPersona.Add(reportRipartizioneBilancioDTO);
}
else
{
itemPerPersona.Importo = itemPerPersona.Importo.GetValueOrDefault() + reportRipartizioneBilancioDTO.Importo.GetValueOrDefault();
itemPerPersona.Millesimi = itemPerPersona.Millesimi.GetValueOrDefault() + reportRipartizioneBilancioDTO.Millesimi.GetValueOrDefault();
if (itemPerPersona.OrdineConto == 9993 || itemPerPersona.OrdineConto == 9994)
{
if (itemPerPersona.Importo.GetValueOrDefault() > 0)
{
itemPerPersona.OrdineConto = 9994;
itemPerPersona.DescrizioneConto = "a Credito";
}
else
{
itemPerPersona.OrdineConto = 9993;
itemPerPersona.DescrizioneConto = "a Debito";
}
}
}
}
return listaPerPersona;
}
return lista;
}
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;
}
public List<RiepilogoRipartoDTO> GetRiepilogoRiparto(int idEsercizio, int? idStabile, int? idScala, TipoAccorpamentoRateEnum tipo)
{
try
{
var lista = new List<RiepilogoRipartoDTO>();
var preventivo = _bilancioService.GetDataSourceRipartizioneBilancioPreventivo(idEsercizio, idStabile, idScala, false, false, tipo, false, true, false, false, false, null).ToList();
var esercizio = _daoFactory.GetEsercizioDao().GetById(idEsercizio, false);
//var impostazioni = _daoFactory.GetImpostazioniAziendaDao().GetByAzienda(esercizio.CondominioRiferimento.Azienda.ID);
//IList<SaldoSoggetto> saldi = null;
//if (esercizio.Gestione == GestioneEsercizioEnum.Ordinario)
// saldi = _daoFactory.GetSaldoSoggettoDao().GetByEsercizioStabileScala(esercizio, idStabile, idScala);
//// Se nesessario devo calcolarmi gli importi a partire dal consuntivo dell'esercizio precedente
//if (saldi != null && saldi.Count == 0 && esercizio.AnnoGestionale.AnnoGestionalePrecedente != null && spese == null)
//{
// var esercizioPrecedente = esercizio.GetEsercizioPrecedente();
// if (esercizioPrecedente != null)
// {
// var items = _bilancioService.GetDataSourceRipartizioneBilancioConsuntivo(esercizioPrecedente.ID, null, null, null, null, idStabile, idScala, false, false, tipo, false);
// spese = (from item in items
// where item.OrdineConto == 9993 || item.OrdineConto == 9994
// select item).ToList();
// }
//}
////====================================================================================
//// Calcolo Rendiconto Preventivo
////====================================================================================
//var riparto = preventivo.Where(item => item.OrdineConto == 9990).ToList();
//// Aggiungo i saldi per i soggetti che non hanno importi di preventivo
//if (saldi != null)
//{
// var saldiSenzaPreventivo = saldi.Where(item => !riparto.Select(rip => rip.IdPartecipante).Contains(item.Soggetto.ID));
// riparto.AddRange(saldiSenzaPreventivo.Select(saldoSoggetto => new ReportRipartizioneBilancioDTO
// {
// IdPersona = saldoSoggetto.Soggetto.Persona.ID,
// IdPartecipante = saldoSoggetto.Soggetto.ID,
// Importo = 0
// }));
//}
//var soggettiPrincipali = new Dictionary<int, int>();
//var listaSaldi = (from item in riparto select item.IdPartecipante).Distinct().ToList();
//foreach (var item in riparto.OrderBy(item => item.OrdineUnitaImmobiliare))
//{
// var idSoggettoCondomino = getSoggettoCondominioPrincipale(item.IdPersona, item.IdPartecipante, null, riparto, tipo);
// if (!soggettiPrincipali.ContainsKey(item.IdPartecipante))
// soggettiPrincipali.Add(item.IdPartecipante, idSoggettoCondomino);
// var riepilogo = (from riep in lista
// where riep.IdSoggettoCondominio == idSoggettoCondomino
// select riep).SingleOrDefault();
// if (riepilogo == null)
// {
// var soggetto = _daoFactory.GetSoggettoCondominioDao().GetById(idSoggettoCondomino, false);
// riepilogo = new RiepilogoRipartoDTO
// {
// DescrizioneUnitaImmobiliare = soggetto.UnitaImmobiliare.GetDisplayName(esercizio.DataApertura),
// IdUnitaImmobiliare = soggetto.UnitaImmobiliare.ID,
// IdSoggettoCondominio = soggetto.ID,
// Interno = soggetto.UnitaImmobiliare.InternoCompleto,
// Nominativo = soggetto.DisplayName,
// IdPersona = soggetto.Persona.ID,
// TipoSoggettoCondominio = soggetto.Tipo,
// CodiceTipoUnita = soggetto.UnitaImmobiliare.TipoUnitaImmobiliare.ID,
// DescrizioneTipoUnita = soggetto.UnitaImmobiliare.TipoUnitaImmobiliare.Descrizione
// };
// if (soggetto.UnitaImmobiliare.Ordine != null)
// riepilogo.OrdineUnitaImmobiliare = soggetto.UnitaImmobiliare.Ordine.Value;
// lista.Add(riepilogo);
// }
// if (item.Importo != null)
// {
// var importo = item.Importo.GetValueOrDefault();
// if (impostazioni.InversioneSaldiRate)
// importo = importo*-1;
// riepilogo.Importo += importo;
// }
//}
////======================================================
//// Saldi
////======================================================
//if (saldi != null)
//{
// foreach (var idSoggetto in listaSaldi)
// {
// var soggetto = idSoggetto;
// var riepilogo = (from item in lista
// where item.IdSoggettoCondominio == soggettiPrincipali[soggetto]
// select item).SingleOrDefault();
// var saldo = _saldiCondominiService.GetSaldoBySoggetto(saldi, idSoggetto);
// decimal importoSaldo = 0;
// if (saldo != null && saldo.Importo != null)
// importoSaldo = saldo.Importo.Value;
// // .... lo ricalcolo partendo dal consuntivo dell'anno precedente.
// else if (spese != null)
// importoSaldo = _saldiCondominiService.GetImportoSaldoPrecedenteDaConsuntivo(idSoggetto, spese);
// if (impostazioni.InversioneSaldiRate)
// importoSaldo = importoSaldo * -1;
// if (riepilogo != null)
// riepilogo.SaldoEsercizioPrecedente += importoSaldo;
// }
//}
var totaliPreventivo = preventivo.Where(item => item.OrdineConto == 9990 && item.IdUnitaImmobiliare > 0).ToList();
foreach (var reportRipartizioneBilancioDTO in totaliPreventivo)
{
if (lista.Any(item => item.IdSoggettoCondominio == reportRipartizioneBilancioDTO.IdPartecipante))
{
var riepilogoRipartoDTO = lista.SingleOrDefault(item => item.IdSoggettoCondominio == reportRipartizioneBilancioDTO.IdPartecipante);
if (riepilogoRipartoDTO != null)
riepilogoRipartoDTO.Importo += getImporto(reportRipartizioneBilancioDTO.Importo.GetValueOrDefault(), esercizio);
else
{
_log.WarnFormat("Trovata più di una riga per lo stesso condomino - {0} - condomino:{1}", Utility.GetMethodDescription(), reportRipartizioneBilancioDTO.IdPartecipante);
}
}
else
lista.Add(setRiepilogoRiparto(reportRipartizioneBilancioDTO, esercizio));
}
var saldi = preventivo.Where(item => item.OrdineConto == 9991 && item.IdUnitaImmobiliare > 0).ToList();
foreach (var reportRipartizioneBilancioDTO in saldi)
{
try
{
var riepilogoPreventivo = lista.SingleOrDefault(item => item.IdSoggettoCondominio == reportRipartizioneBilancioDTO.IdPartecipante);
if (riepilogoPreventivo == null)
{
riepilogoPreventivo = setRiepilogoRiparto(reportRipartizioneBilancioDTO, esercizio);
// Se non sono presenti spese ma solo saldi l'importo è comunque a 0
riepilogoPreventivo.Importo = 0;
lista.Add(riepilogoPreventivo);
}
riepilogoPreventivo.SaldoEsercizioPrecedente += reportRipartizioneBilancioDTO.Importo.GetValueOrDefault();
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel calcolo del riepilogo di riparto - SINGOLO CONDOMINO - {0} - condomino:{1}", ex, Utility.GetMethodDescription(), reportRipartizioneBilancioDTO.IdPartecipante);
throw;
}
}
return lista.OrderBy(riep => riep.OrdineUnitaImmobiliare).ThenBy(riep => riep.TipoSoggettoCondominio).ToList();
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante il calcolo del riepilogo del riparto - {0} - esercizio:{1} - stabile:{2} - scala:{3}", ex, Utility.GetMethodDescription(), idEsercizio, idStabile.GetValueOrDefault(), idScala.GetValueOrDefault());
throw;
}
}
public List<ReportRipartizioneBilancioDTO> GetRipartizioneDetrazione(int idCondominio, int anno, int detrazione, IList<SpesaDTO> spese, bool accorpamentoUnita, TipoAccorpamentoRateEnum tipoAccorpamento)
{
var idSpese = new List<int>(spese.Count);
idSpese.AddRange(spese.Select(spesaDTO => spesaDTO.ID));
var result = GetServiceClient().GetRipartizioneDetrazione(idCondominio, anno, detrazione, new List<int>(idSpese), accorpamentoUnita, tipoAccorpamento, GetUserInfo());
CloseService();
return result;
}
public void LoadData(CondominioDTO condominio, EsercizioDTO esercizio, TipoListaRate tipoLista, bool isAllowEmpty, bool rateAcconto, TipoAccorpamentoRateEnum tipo)
{
try
{
Clear();
_condominio = condominio;
_esercizio = esercizio;
_tipo = tipo;
_rateAcconto = rateAcconto;
if (condominio != null && esercizio != null && listaRateSoggetti != null)
{
loadConti();
_pianoRateale = getRateCondominiService().GetPianoRatealeByEsercizio(_esercizio.ID, false);
if (_pianoRateale != null && _pianoRateale.ID > 0)
_tipo = _pianoRateale.Tipo;
var form = new ExecuteLoadDataListAsync<RataSoggettoDTO>("Le rate sono in corso di caricamento ....." + Environment.NewLine + "Si prega di attendere.");
Func<List<RataSoggettoDTO>> loadDati = () => getRateCondominiService().GetByEsercizio(esercizio.ID);
form.LoadData(loadDati);
form.ShowDialog();
if (form.DataSourceObject == null)
{
ParentForm?.Close();
return;
}
_rateSoggetti = form.DataSourceObject;
form.Dispose();
var formSaldi = new ExecuteLoadDataObjectAsync<ResultSaldiCondomini>("I saldi dei condomini sono in corso di caricamento ....." + Environment.NewLine + "Si prega di attendere.");
Func<ResultSaldiCondomini> loadSaldi = () => getRateCondominiService().GetSaldiSoggetti(esercizio.ID, null, null, _tipo);
formSaldi.LoadData(loadSaldi);
formSaldi.ShowDialog();
if ((string.IsNullOrEmpty(formSaldi.DataSourceObject.Message) && formSaldi.DataSourceObject.Saldi != null) || !_isCreazione)
{
_saldiSoggetti = formSaldi.DataSourceObject.Saldi;
formSaldi.Dispose();
if (_rateSoggetti.Count > 0 || isAllowEmpty)
{
btnStampa.Visible = true;
btnConferma.Visible = true;
chkDataEmissione.Visible = true;
sceltaTipoLista.Visible = true;
listaRateSoggetti.Visible = true;
if (_isCreazione)
{
btnStampa.Visible = false;
nuovaDataPanel.Visible = false;
}
else
{
btnStampa.Visible = true;
nuovaDataPanel.Visible = true;
}
// Se è ancora a null carico la lista dei soggetti relativi all'esercizio.
if (_soggetti == null)
_soggetti = getRateCondominiService().GetPartecipanti(esercizio.ID, _tipo);
if (tipoLista == TipoListaRate.Pivot)
{
try
{
var resultMessage = getRateCondominiService().ConvertRateSoggettiToPivot(_rateSoggetti, _saldiSoggetti, null, _allowInvertiSegno, _pianoRateale, _isCreazione);
if (resultMessage.DataTable == null)
{
CommonMessages.DisplayWarning(string.Format("Si sono verificati i seguenti errori:{1}{0}{1}Si prega di riprovare", resultMessage.FatalMessage, Environment.NewLine));
ParentForm?.Close();
return;
}
listaRateSoggetti.DataSource = resultMessage.DataTable;
setGridLayout(tipoLista);
setRowsLayout();
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante il caricamento delle rate - DATA SOURCE - {0} - condominio:{1} - esercizio:{2}", ex, Utility.GetMethodDescription(), _condominio.ID, _esercizio.ID);
}
}
else if (tipoLista == TipoListaRate.Editabile)
{
listaRateSoggetti.DataSource = _rateSoggetti;
listaRateSoggetti.DisplayLayout.ValueLists.Clear();
listaRateSoggetti.DisplayLayout.ValueLists.Add(DataSourceHelper.GetValueList(_soggetti, "ID", "DisplayNominativo", "SoggettiCondominio"));
listaRateSoggetti.DisplayLayout.Bands[0].Columns["IdSoggettoCondominio"].ValueList = listaRateSoggetti.DisplayLayout.ValueLists["SoggettiCondominio"];
setGridLayout(tipoLista);
}
listaRateSoggetti.DisplayLayout.Bands[0].Summaries.Clear();
foreach (var column in listaRateSoggetti.DisplayLayout.Bands[0].Columns)
{
if (column.DataType == typeof (decimal))
DataGridHelper.AddSummary(listaRateSoggetti.DisplayLayout.Bands[0], column.Key, "c");
}
}
else
{
listaRateSoggetti.DataSource = new List<RataSoggettoDTO>();
CommonMessages.DisplayWarning("Non sono presenti rate.");
var parentForm = _parentForm as MainContabilita;
if (parentForm != null)
parentForm.ToClose = true;
else if (ParentForm != null)
((MainContabilita) ParentForm).ToClose = true;
}
listaRateSoggetti.PerformAction(UltraGridAction.FirstRowInBand);
loadPianoRateale();
}
else
{
CommonMessages.DisplayWarning($"Si sono verificati degli errori nel caricamento dei saldi:{Environment.NewLine}{formSaldi.DataSourceObject.Message}");
formSaldi.Dispose();
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante il caricamento dei dati del piano rateale - 1 - {0} - condominio:{1} - esercizio:{2}", ex, Utility.GetMethodDescription(), _condominio.ID, _esercizio.ID);
throw;
}
}
private SoggettoCondominio getSoggettoCondominioPrincipale(SoggettoCondominio soggettoCorrente, IList<SoggettoCondominio> listaSoggetti, TipoAccorpamentoRateEnum tipo)
{
var soggettoPrincipale = soggettoCorrente;
switch (tipo)
{
case TipoAccorpamentoRateEnum.Nessuno:
soggettoPrincipale = soggettoCorrente;
break;
case TipoAccorpamentoRateEnum.Persona:
var foundItem = (from item in listaSoggetti
where item.Persona.ID == soggettoCorrente.Persona.ID && item.UnitaImmobiliare.TipoUnitaImmobiliare.ID == 1
select item).FirstOrDefault() ?? (from item in listaSoggetti
where item.Persona.ID == soggettoCorrente.Persona.ID
select item).FirstOrDefault();
if (foundItem != null)
soggettoPrincipale = foundItem;
break;
case TipoAccorpamentoRateEnum.Personalizzato:
if (soggettoCorrente.SoggettoPrincipale != null)
soggettoPrincipale = soggettoCorrente.SoggettoPrincipale;
else // se non sono presenti accorpamenti personalizzati non viene eseguito nessun accorpamento
goto case TipoAccorpamentoRateEnum.Nessuno;
break;
}
return soggettoPrincipale;
}
public virtual IEnumerable<ReportRipartizioneBilancioDTO> GetDataSourceRipartizioneBilancioPreventivo(int idEsercizio, int? idStabile, int? idScala, bool ripartizioneProprietarioConduttore, bool accorpamentoUnita, TipoAccorpamentoRateEnum tipoAccorpamento, bool inversioneSaldi, bool stampaSaldi, bool addebitiCondominio, bool calcoloPerSubentro, bool addebitiDirettiStabileScala, IList<int> idSoggetti, bool dettaglioSottoConto = false)
{
throw new InvalidOperationException("Deve essere usato il metodo della classe BilancioRipartoAggregatoService");
}
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;
}
}
public IList<ReportRataSoggettoDTO> GetReportByEsercizio(int idEsercizio, int? idLotto, int? idStabile, int? idScala, IList<ImportoSaldoSoggettoDTO> saldi, TipoAccorpamentoRateEnum tipoAccorpamento)
{
var rateReport = new List<ReportRataSoggettoDTO>();
var esercizio = _daoFactory.GetEsercizioDao().GetById(idEsercizio, false);
var impostazioni = _daoFactory.GetImpostazioniAziendaDao().GetByAzienda(esercizio.CondominioRiferimento.Azienda.ID);
var totalePreventivo = new Dictionary<int, decimal>();
var importoPreventivo = _bilancioService.GetImportiPreventivoCorrente(idEsercizio, tipoAccorpamento);
// =====================================================================================
// Piano rateale
// =====================================================================================
var rate = _daoFactory.GetRataSoggettoDao().GetByEsercizioLottoStabileScala(idEsercizio, idLotto, idStabile, idScala);
foreach (var rata in rate)
{
var soggetto = rata.Soggetto;
if (tipoAccorpamento == TipoAccorpamentoRateEnum.Personalizzato && soggetto.SoggettoPrincipale != null)
soggetto = soggetto.SoggettoPrincipale;
var importoRata = rata.Importo;
var rataReport = new ReportRataSoggettoDTO
{
DataScadenza = rata.DataScadenza,
NumeroRata = rata.PianoRatealeDettaglio.Progressivo,
DescrizioneRata = rata.PianoRatealeDettaglio.Descrizione,
IdDettaglioRata = rata.PianoRatealeDettaglio.ID,
DescrizioneSoggettoCondominio = soggetto.DisplayName,
DescrizioneUnitaImmobiliare = soggetto.UnitaImmobiliare.Descrizione,
IdSoggettoCondominio = soggetto.ID,
TipoNominativo = soggetto.Tipo.ToString(),
IdUnitaImmobiliare = soggetto.UnitaImmobiliare.ID,
TipoUnitaImmobiliare = soggetto.UnitaImmobiliare.TipoUnitaImmobiliare.Descrizione,
SubalternoUnitaImmobiliare = soggetto.UnitaImmobiliare.Subalterno,
PianoUnitaImmobiliare = soggetto.UnitaImmobiliare.Piano,
Importo = importoRata,
Progressivo = rata.PianoRatealeDettaglio.Progressivo,
IdGruppoStabile = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.ID,
DescrizioneGruppoStabile = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.Descrizione,
IdStabile = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.ID,
DescrizioneStabile = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.Descrizione,
OrdineGruppoStabile = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.Ordine,
OrdineStabile = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.Ordine,
OrdineUnitaImmobiliare = soggetto.UnitaImmobiliare.Ordine.GetValueOrDefault(),
InternoUnitaImmobiliare = soggetto.UnitaImmobiliare.InternoCompleto,
TipoSoggettoCondominio = soggetto.Tipo.ToString().Substring(0, 1),
IdPersona = soggetto.Persona.ID,
Nominativo = soggetto.DisplayName
};
rateReport.Add(rataReport);
// Aggiorno il totale preventivo
if (totalePreventivo.ContainsKey(rataReport.IdSoggettoCondominio))
totalePreventivo[rataReport.IdSoggettoCondominio] += rataReport.Importo;
else
totalePreventivo.Add(rataReport.IdSoggettoCondominio, rataReport.Importo);
}
// =====================================================================================
// Saldi Inizio Esercizio
// =====================================================================================
foreach (var saldo in saldi)
{
if (saldo.Importo != 0)
{
var soggetto = _daoFactory.GetSoggettoCondominioDao().GetById(saldo.IdSoggettoCondominio, false);
if (tipoAccorpamento == TipoAccorpamentoRateEnum.Personalizzato && soggetto.SoggettoPrincipale != null)
soggetto = soggetto.SoggettoPrincipale;
else if (tipoAccorpamento == TipoAccorpamentoRateEnum.Persona && rate.First().PianoRatealeDettaglio.PianoRatealeRiferimento.Tipo == TipoAccorpamentoRateEnum.Persona)
soggetto = getSoggettoFromRate(rate, soggetto);
if ((idScala == null || soggetto.UnitaImmobiliare.GruppoStabileRiferimento.ID == idScala.Value) && (idStabile == null || soggetto.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.ID == idStabile.Value) && (idLotto == null || soggetto.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.LottoRiferimento.ID == idLotto.Value))
{
var rataReport = new ReportRataSoggettoDTO
{
DataScadenza = null,
NumeroRata = -20,
IdDettaglioRata = -1,
DescrizioneRata = "Saldo Esercizio Precedente",
DescrizioneSoggettoCondominio = soggetto.DisplayName,
DescrizioneUnitaImmobiliare = soggetto.UnitaImmobiliare.Descrizione,
IdSoggettoCondominio = soggetto.ID,
TipoNominativo = soggetto.Tipo.ToString(),
IdUnitaImmobiliare = soggetto.UnitaImmobiliare.ID,
TipoUnitaImmobiliare = soggetto.UnitaImmobiliare.TipoUnitaImmobiliare.Descrizione,
SubalternoUnitaImmobiliare = soggetto.UnitaImmobiliare.Subalterno,
PianoUnitaImmobiliare = soggetto.UnitaImmobiliare.Piano,
Importo = saldo.Importo,
Progressivo = 0,
IdGruppoStabile = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.ID,
DescrizioneGruppoStabile = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.Descrizione,
IdStabile = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.ID,
DescrizioneStabile = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.Descrizione,
OrdineGruppoStabile = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.Ordine,
OrdineStabile = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.Ordine,
OrdineUnitaImmobiliare = soggetto.UnitaImmobiliare.Ordine.GetValueOrDefault(),
InternoUnitaImmobiliare = soggetto.UnitaImmobiliare.InternoCompleto,
TipoSoggettoCondominio = soggetto.Tipo.ToString().Substring(0, 1),
IdPersona = soggetto.Persona.ID,
Nominativo = soggetto.DisplayName
};
rateReport.Add(rataReport);
// Inverto l'importo visualizzato se richiesto
if (impostazioni.InversioneSaldiRate)
rataReport.Importo = rataReport.Importo * -1;
}
}
}
// =====================================================================================
// Totale Preventivo
// =====================================================================================
foreach (var importoDto in importoPreventivo)
{
if (importoDto.Importo != 0)
{
var soggetto = _daoFactory.GetSoggettoCondominioDao().GetById(importoDto.Id, false);
if (tipoAccorpamento == TipoAccorpamentoRateEnum.Personalizzato && soggetto.SoggettoPrincipale != null)
soggetto = soggetto.SoggettoPrincipale;
else if (tipoAccorpamento == TipoAccorpamentoRateEnum.Persona && rate.Any() && rate.First().PianoRatealeDettaglio.PianoRatealeRiferimento.Tipo == TipoAccorpamentoRateEnum.Persona)
soggetto = getSoggettoFromRate(rate, soggetto);
if ((idScala == null || soggetto.UnitaImmobiliare.GruppoStabileRiferimento.ID == idScala.Value) && (idStabile == null || soggetto.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.ID == idStabile.Value) && (idLotto == null || soggetto.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.LottoRiferimento.ID == idLotto.Value))
{
var rataReport = new ReportRataSoggettoDTO
{
DataScadenza = null,
NumeroRata = -30,
IdDettaglioRata = -2,
DescrizioneRata = "Totale Preventivo",
DescrizioneSoggettoCondominio = soggetto.DisplayName,
DescrizioneUnitaImmobiliare = soggetto.UnitaImmobiliare.Descrizione,
IdSoggettoCondominio = soggetto.ID,
TipoNominativo = soggetto.Tipo.ToString(),
IdUnitaImmobiliare = soggetto.UnitaImmobiliare.ID,
TipoUnitaImmobiliare = soggetto.UnitaImmobiliare.TipoUnitaImmobiliare.Descrizione,
SubalternoUnitaImmobiliare = soggetto.UnitaImmobiliare.Subalterno,
PianoUnitaImmobiliare = soggetto.UnitaImmobiliare.Piano,
Importo = importoDto.Importo,
Progressivo = -1,
IdGruppoStabile = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.ID,
DescrizioneGruppoStabile = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.Descrizione,
IdStabile = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.ID,
DescrizioneStabile = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.Descrizione,
OrdineGruppoStabile = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.Ordine,
OrdineStabile = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.Ordine,
OrdineUnitaImmobiliare = soggetto.UnitaImmobiliare.Ordine.GetValueOrDefault(),
InternoUnitaImmobiliare = soggetto.UnitaImmobiliare.InternoCompleto,
TipoSoggettoCondominio = soggetto.Tipo.ToString().Substring(0, 1),
IdPersona = soggetto.Persona.ID,
Nominativo = soggetto.DisplayName
};
rateReport.Add(rataReport);
}
}
}
// =====================================================================================
// Totale da versare
// =====================================================================================
foreach (var kvp in totalePreventivo)
{
var soggetto = _daoFactory.GetSoggettoCondominioDao().GetById(kvp.Key, false);
if (tipoAccorpamento == TipoAccorpamentoRateEnum.Personalizzato && soggetto.SoggettoPrincipale != null)
soggetto = soggetto.SoggettoPrincipale;
if ((idScala == null || soggetto.UnitaImmobiliare.GruppoStabileRiferimento.ID == idScala.Value) && (idStabile == null || soggetto.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.ID == idStabile.Value) && (idLotto == null || soggetto.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.LottoRiferimento.ID == idLotto.Value))
{
var rataReport = new ReportRataSoggettoDTO
{
DataScadenza = null,
IdDettaglioRata = -3,
NumeroRata = -10,
DescrizioneRata = "Totale da Versare",
DescrizioneSoggettoCondominio = soggetto.DisplayName,
DescrizioneUnitaImmobiliare = soggetto.UnitaImmobiliare.Descrizione,
IdSoggettoCondominio = soggetto.ID,
TipoNominativo = soggetto.Tipo.ToString(),
IdUnitaImmobiliare = soggetto.UnitaImmobiliare.ID,
TipoUnitaImmobiliare = soggetto.UnitaImmobiliare.TipoUnitaImmobiliare.Descrizione,
SubalternoUnitaImmobiliare = soggetto.UnitaImmobiliare.Subalterno,
PianoUnitaImmobiliare = soggetto.UnitaImmobiliare.Piano,
Importo = kvp.Value,
Progressivo = 100,
IdGruppoStabile = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.ID,
DescrizioneGruppoStabile = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.Descrizione,
IdStabile = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.ID,
DescrizioneStabile = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.Descrizione,
OrdineGruppoStabile = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.Ordine,
OrdineStabile = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.Ordine,
OrdineUnitaImmobiliare = soggetto.UnitaImmobiliare.Ordine.GetValueOrDefault(),
InternoUnitaImmobiliare = soggetto.UnitaImmobiliare.InternoCompleto,
TipoSoggettoCondominio = soggetto.Tipo.ToString().Substring(0, 1),
IdPersona = soggetto.Persona.ID,
Nominativo = soggetto.DisplayName
};
rateReport.Add(rataReport);
}
}
// =====================================================================================
// Se richiesto inverto l'importo del 'Totale da versare'
// =====================================================================================
if(impostazioni.InversioneSaldiRate)
{
foreach (var reportRataSoggettoDTO in rateReport.Where(item => item.Progressivo == 100))
reportRataSoggettoDTO.Importo = reportRataSoggettoDTO.Importo*-1;
}
// =====================================================================================
// Se richiesto eseguo l'accorpamento per persona
// =====================================================================================
if (tipoAccorpamento == TipoAccorpamentoRateEnum.Persona)
{
var ratePerPersona = new List<ReportRataSoggettoDTO>(rateReport.Count);
foreach (var reportRataSoggettoDTO in rateReport.OrderBy(item => item.OrdineUnitaImmobiliare))
{
var itemPerPersona = ratePerPersona.SingleOrDefault(item => item.IdPersona == reportRataSoggettoDTO.IdPersona && item.IdDettaglioRata == reportRataSoggettoDTO.IdDettaglioRata);
if (itemPerPersona == null)
ratePerPersona.Add(reportRataSoggettoDTO);
else
itemPerPersona.Importo += reportRataSoggettoDTO.Importo;
}
return ratePerPersona;
}
return rateReport.OrderBy(rata => rata.DataScadenza).ThenBy(rata => rata.OrdineUnitaImmobiliare).ThenBy(rata => rata.TipoSoggettoCondominio).ToList();
}
private PianoRatealeDettaglio getPianoRatealeDettaglio(Dictionary<DateTime, PianoRatealeDettaglio> dettagliPianoRateale, PianoRateale pianoRateale, Esercizio esercizio, RataSoggettoAggiornamentoDTO rata, bool rateAcconto, TipoAccorpamentoRateEnum tipo, LogTransazione logTransazione, LogTransazione logTransazioneDettaglio, string message)
{
if (dettagliPianoRateale.ContainsKey(rata.DataScadenza))
return dettagliPianoRateale[rata.DataScadenza];
var listaPianoRateale = _daoFactory.GetPianoRatealeDettaglioDao().GetByDataEsercizio(esercizio, rata.DataScadenza).Where(item => !item.DaSubentro).ToList();
if (listaPianoRateale.Count > 1)
message += $"E' stato trovato più di un piano rateale per la data: {rata.DataScadenza:d} e il soggetto: {rata.IdSoggettoCondominio}{Environment.NewLine}";
else if (listaPianoRateale.Count == 1)
return listaPianoRateale[0];
else if (listaPianoRateale.Count == 0)
{
if (pianoRateale == null)
{
pianoRateale = _daoFactory.GetPianoRatealeDao().GetByEsercizio(esercizio);
if (pianoRateale == null)
pianoRateale = new PianoRateale(esercizio, tipo, logTransazione);
else
logTransazioneDettaglio = logTransazione;
}
if(pianoRateale.LogTransazione == null || pianoRateale.LogTransazione.Identificativo != logTransazione.Identificativo)
logTransazioneDettaglio = logTransazione;
var pianoDettaglio = new PianoRatealeDettaglio(pianoRateale, rata.DataScadenza, null, pianoRateale.Rate.Count + 1, false, logTransazioneDettaglio);
dettagliPianoRateale.Add(rata.DataScadenza, pianoDettaglio);
var descrizione = "Rata manuale del ";
if (rateAcconto)
descrizione = "Rata di acconto del ";
pianoDettaglio.Descrizione = descrizione + rata.DataScadenza.ToShortDateString();
pianoDettaglio.IsAcconto = rateAcconto;
return pianoDettaglio;
}
return null;
}
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 List<ImportoSaldoSoggettoDTO> GetSaldiSoggetti(int idEsercizio, int? idStabile, int? idScala, TipoAccorpamentoRateEnum tipoAccorpamento)
{
return _saldiCondominiService.GetSaldiSoggetti(idEsercizio, idStabile, idScala, tipoAccorpamento);
}
public ResultRiparto GetRipartizioneConsuntivo(int idEsercizio, int? idStabile, int? idScala, bool? ripartizioneProprietarioConduttore, bool accorpamentoUnita, bool addebitiCondominio, bool addebitiDirettiStabileScala, TipoAccorpamentoRateEnum tipoAccorpamento, IList<int> idCondomini)
{
var retryCount = 5;
var success = false;
var result = new ResultRiparto();
var ripartizione = false;
if (ripartizioneProprietarioConduttore != null)
ripartizione = ripartizioneProprietarioConduttore.Value;
while (retryCount >= 0 && !success)
{
try
{
List<int> condomini = null;
if (idCondomini != null)
condomini = idCondomini.ToList();
var info = GetUserInfo();
info.Tentativo = 6 - retryCount;
result = GetServiceClient().GetRipartizioneBilancioConsuntivo(idEsercizio, idStabile, idScala, ripartizione, accorpamentoUnita, tipoAccorpamento, addebitiCondominio, addebitiDirettiStabileScala, condomini, info);
if(result.Riparto != null)
inversioneSaldi(result.Riparto);
CloseService();
success = true;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella lettura del bilancio per sottoconto - TENTATIVO:{0} - {1} - esercizio:{2} - stabile:{3} - scala:{4} - azienda:{5}", ex, (6 - retryCount), Utility.GetMethodDescription(), idEsercizio, idStabile.GetValueOrDefault(), idScala.GetValueOrDefault(), Login.Instance.CurrentLogin().Azienda);
retryCount--;
_log.InfoFormat("Esecuzione della funzione - INIZIO TENTATIVO:{0} - {1} - esercizio:{2} - stabile:{3} - scala:{4} - azienda:{5}", (6 - retryCount), Utility.GetMethodDescription(), idEsercizio, idStabile.GetValueOrDefault(), idScala.GetValueOrDefault(), Login.Instance.CurrentLogin().Azienda);
}
}
return result;
}
public IList<ImportiDTO> GetImportiPreventivoCorrente(int idEsercizio, TipoAccorpamentoRateEnum tipoAccorpamento)
{
var importi = new List<ImportiDTO>();
var ripartizione = GetDataSourceRipartizioneBilancioPreventivo(idEsercizio, null, null, false, false, tipoAccorpamento, false, false, false, false, false, null);
if (ripartizione != null)
{
var ripartizioneFiltered = ripartizione.Where(item => item.OrdineConto == 9990 && item.IdUnitaImmobiliare > 0);
foreach (var itemRipartizione in ripartizioneFiltered)
{
var ripartizione1 = itemRipartizione;
var importoDto = importi.SingleOrDefault(item => item.Id == ripartizione1.IdPartecipante);
if (importoDto == null)
{
importoDto = new ImportiDTO { Id = itemRipartizione.IdPartecipante, Importo = 0 };
importi.Add(importoDto);
}
importoDto.Importo += itemRipartizione.Importo.GetValueOrDefault();
}
}
return importi;
}
public ResultRiparto GetRipartizionePreventivo(int idEsercizio, int? idStabile, int? idScala, bool? ripartizioneProprietarioConduttore, bool accorpamentoUnita, TipoAccorpamentoRateEnum tipoAccorpamento, bool stampaSaldi, bool onlyCondominio, bool addebitoDirettoStabileScala, IList<int> idCondomini)
{
var ripartizione = false;
if (ripartizioneProprietarioConduttore != null)
ripartizione = ripartizioneProprietarioConduttore.Value;
List<int> condomini = null;
if (idCondomini != null)
condomini = idCondomini.ToList();
var result = GetServiceClient().GetRipartizioneBilancioPreventivo(idEsercizio, idStabile, idScala, ripartizione, accorpamentoUnita, tipoAccorpamento, stampaSaldi, onlyCondominio, addebitoDirettoStabileScala, condomini, GetUserInfo());
if (result != null)
inversioneSaldi(result);
CloseService();
return new ResultRiparto { Riparto = result};
}
public string CopiaRate(List<PianoRatealeDettaglioDTO> rate, EsercizioDTO esercizio, TipoAccorpamentoRateEnum tipoAccorpamento)
{
var result = GetServiceClient().CopiaRate(rate, esercizio.ID, tipoAccorpamento, GetUserInfo());
CloseService();
return result;
}
public void GetRipartizioneAsync(int idEsercizio, int? idStabile, int? idScala, bool? ripartizioneProprietarioConduttore, bool addebitiCondominio, bool addebitoDirettoStabileScala, bool accorpamentoUnita, TipoAccorpamentoRateEnum tipoAccorpamento, BilancioConsuntivoReportParameters parameters, INotifier notifier, Image image)
{
var ripartizione = false;
if (ripartizioneProprietarioConduttore != null)
ripartizione = ripartizioneProprietarioConduttore.Value;
var id = Guid.NewGuid().ToString();
_cacheService.AddStampaBatchToCache(new StampaBatchDTO { Id = id, Key = "RipartoAnnuale", IdEsercizio = idEsercizio, DataInizioEsecuzione = DateTime.Now });
if (parameters.TipoRendiconto == TipoRendiconto.Consuntivo)
{
GetServiceClient().GetRipartizioneBilancioConsuntivoCompleted += bilancioWCFServiceGetRipartizioneBilancioConsuntivoCompleted;
GetServiceClient().GetRipartizioneBilancioConsuntivoAsync(idEsercizio, idStabile, idScala, ripartizione, accorpamentoUnita, tipoAccorpamento, addebitiCondominio, addebitoDirettoStabileScala, null, GetUserInfo(), new StampaBatchParameters(id, parameters, notifier, image));
}
else if(parameters.TipoRendiconto == TipoRendiconto.Preventivo)
{
GetServiceClient().GetRipartizioneBilancioPreventivoCompleted += bilancioWCFServiceGetRipartizioneBilancioPreventivoCompleted;
GetServiceClient().GetRipartizioneBilancioPreventivoAsync(idEsercizio, idStabile, idScala, ripartizione, accorpamentoUnita, tipoAccorpamento, parameters.StampaSaldi, addebitiCondominio, addebitoDirettoStabileScala, null, GetUserInfo(), new StampaBatchParameters(id, parameters, notifier, image));
}
}
public ResultSaldiCondomini GetSaldiSoggetti(int idEsercizio, int? idStabile, int? idScala, TipoAccorpamentoRateEnum tipoAccorpamento)
{
var result = GetServiceClient().GetSaldiSoggetti(idEsercizio, idStabile, idScala, tipoAccorpamento, GetUserInfo());
CloseService();
return result;
}
public void LoadData(CondominioDTO condominio, EsercizioDTO esercizio, List<RataSoggettoDTO> rateSoggetti, List<ImportoSaldoSoggettoDTO> saldiSoggetti, IList<RiepilogoRipartoDTO> riepilogoRiparto, TipoListaRate tipoLista, bool isCreazione, TipoAccorpamentoRateEnum tipo)
{
try
{
_tipo = tipo;
_condominio = condominio;
_esercizio = esercizio;
_rateSoggetti = rateSoggetti;
_saldiSoggetti = saldiSoggetti;
_riepilogoRiparto = riepilogoRiparto;
_isCreazione = isCreazione;
loadConti();
_pianoRateale = getRateCondominiService().GetPianoRatealeByEsercizio(_esercizio.ID, false) ?? new PianoRatealeDTO { Tipo = tipo };
_pianoRateale.Tipo = tipo;
if (_isCreazione)
{
btnStampa.Visible = false;
nuovaDataPanel.Visible = false;
}
else
{
btnStampa.Visible = true;
nuovaDataPanel.Visible = true;
}
sceltaTipoLista.Value = tipoLista.ToString().ToLower();
// Se è ancora a null carico la lista dei soggetti relativi al condominio.
if (_soggetti == null)
_soggetti = getRateCondominiService().GetPartecipanti(_condominio.ID, _tipo);
if(tipoLista == TipoListaRate.Pivot)
{
try
{
var resultMessage = getRateCondominiService().ConvertRateSoggettiToPivot(rateSoggetti, _saldiSoggetti, riepilogoRiparto, _allowInvertiSegno, _pianoRateale, _isCreazione);
if (resultMessage.DataTable == null)
{
CommonMessages.DisplayWarning(string.Format("Si sono verificati i seguenti errori:{1}{0}{1}Si prega di riprovare", resultMessage.FatalMessage, Environment.NewLine));
ParentForm?.Close();
return;
}
else
{
listaRateSoggetti.DataSource = resultMessage.DataTable;
setGridLayout(tipoLista);
setRowsLayout();
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante il caricamento dei dati del piano rateale - DataSource di listaRateSoggetti - {0} - condominio:{1} - esercizio:{2}", ex, Utility.GetMethodDescription(), _condominio.ID, _esercizio.ID);
throw;
}
}
else if (tipoLista == TipoListaRate.Editabile)
{
var dataSourceEditabile = rateSoggetti;
if (!_isCreazione)
dataSourceEditabile = new List<RataSoggettoDTO>(dataSourceEditabile.Where(item => item.ID > 0 && item.Importo > 0).ToList());
listaRateSoggetti.DataSource = new System.ComponentModel.BindingList<RataSoggettoDTO>(dataSourceEditabile);
listaRateSoggetti.DisplayLayout.ValueLists.Clear();
listaRateSoggetti.DisplayLayout.ValueLists.Add(DataSourceHelper.GetValueList(_soggetti, "ID", "DisplayNominativo", "SoggettiCondominio"));
listaRateSoggetti.DisplayLayout.Bands[0].Columns["IdSoggettoCondominio"].ValueList = listaRateSoggetti.DisplayLayout.ValueLists["SoggettiCondominio"];
setGridLayout(tipoLista);
}
listaRateSoggetti.DisplayLayout.Bands[0].Summaries.Clear();
foreach (var column in listaRateSoggetti.DisplayLayout.Bands[0].Columns)
{
if(column.DataType == typeof(decimal))
DataGridHelper.AddSummary(listaRateSoggetti.DisplayLayout.Bands[0], column.Key, "c");
}
btnConferma.Visible = false;
listaRateSoggetti.PerformAction(UltraGridAction.FirstRowInBand);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante il caricamento dei dati del piano rateale - 2 - {0} - condominio:{1} - esercizio:{2}", ex, Utility.GetMethodDescription(), _condominio.ID, _esercizio.ID);
throw;
}
}
private ResultRiparto getRipartoDatasource(int idEsercizio, int? idStabile, int? idScala, bool? proprietarioConduttore, bool accorpamentoUnitaValore, TipoAccorpamentoRateEnum tipoAccorpamento, TipoRendiconto tipoRendiconto)
{
try
{
var dataSource = tipoRendiconto == TipoRendiconto.Consuntivo ? getBilancioService().GetRipartizioneConsuntivo(idEsercizio, idStabile, idScala, proprietarioConduttore, accorpamentoUnitaValore, addebitiCondominio.Checked, addebitiDirettiStabileScala.Checked, tipoAccorpamento, null) : getBilancioService().GetRipartizionePreventivo(idEsercizio, idStabile, idScala, proprietarioConduttore, accorpamentoUnitaValore, getTipoAccorpamento(), stampaSaldi.Checked, addebitiCondominio.Checked, addebitiDirettiStabileScala.Checked, null);
return dataSource;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella lettura del datasource del riparto - {0} - esercizio:{1} - stabile:{2} - scala:{3} - proprietarioConduttore:{4} - accorpamentoUnitaValore:{5} - tipoAccorpamento:{6} - tipoRendiconto:{7} - azienda:{8}", ex, Utility.GetMethodDescription(), idEsercizio, idStabile.GetValueOrDefault(), idScala.GetValueOrDefault(), proprietarioConduttore.GetValueOrDefault(), accorpamentoUnitaValore, tipoAccorpamento, tipoRendiconto, Security.Login.Instance.CurrentLogin().Azienda);
throw;
}
}
public List<ImportoSaldoSoggettoDTO> GetSaldiSoggetti(int idEsercizio, int? idStabile, int? idScala, TipoAccorpamentoRateEnum tipoAccorpamento)
{
try
{
Dictionary<int, ImportoSaldoSoggettoDTO> listaSaldi = new Dictionary<int, ImportoSaldoSoggettoDTO>();
var esercizio = _daoFactory.GetEsercizioDao().Find(idEsercizio, false);
if (esercizio != null)
{
var saldi = _daoFactory.GetSaldoSoggettoDao().GetByEsercizioStabileScala(esercizio, idStabile, idScala);
List<ReportRipartizioneBilancioDTO> spese = null;
if (saldi.Count == 0 && esercizio.Gestione == GestioneEsercizioEnum.Ordinario &&
esercizio.AnnoGestionale.AnnoGestionalePrecedente != null &&
esercizio.GetEsercizioPrecedente() != null)
{
var items = _bilancioService.GetDataSourceRipartizioneBilancioConsuntivo(esercizio.GetEsercizioPrecedente().ID, null, null, null, null, idStabile, idScala, false, false, TipoAccorpamentoRateEnum.Nessuno, false, false, false, false, null);
spese = (from item in items
where item.OrdineConto == 9993 || item.OrdineConto == 9994
select item).ToList();
}
// var soggetti = esercizio.CondominioRiferimento.GetSoggetti(esercizio.DataApertura.GetValueOrDefault(), stabile, scala);
var soggetti = _daoFactory.GetSoggettoCondominioDao().GetAttiviByCondominioData(esercizio.CondominioRiferimento.ID, idStabile, idScala, esercizio.DataApertura.GetValueOrDefault());
var saldiSoggetto = new Dictionary<int, SaldoSoggetto>();
foreach (var saldoSoggetto in saldi)
{
if(!saldiSoggetto.ContainsKey(saldoSoggetto.Soggetto.ID))
saldiSoggetto.Add(saldoSoggetto.Soggetto.ID, saldoSoggetto);
else
_log.ErrorFormat("Trovato saldo doppio - {0} - saldo:{1} - esercizio:{2} - azienda:{3}", Library.Utility.GetMethodDescription(), saldoSoggetto.ID, esercizio.ID, esercizio.CondominioRiferimento.Azienda.ID);
}
listaSaldi = new Dictionary<int, ImportoSaldoSoggettoDTO>();
foreach (var soggetto in soggetti)
{
try
{
var soggettoPrincipale = soggetto;
if (tipoAccorpamento == TipoAccorpamentoRateEnum.Personalizzato && soggetto.SoggettoPrincipale != null)
soggettoPrincipale = soggetto.SoggettoPrincipale;
ImportoSaldoSoggettoDTO saldoDTO;
if (listaSaldi.ContainsKey(soggettoPrincipale.ID))
saldoDTO = listaSaldi[soggettoPrincipale.ID];
else
{
saldoDTO = new ImportoSaldoSoggettoDTO { IdSoggettoCondominio = soggettoPrincipale.ID, IdPersona = soggetto.Persona.ID, Importo = 0 };
listaSaldi.Add(soggettoPrincipale.ID, saldoDTO);
}
// Se presente uso il saldo in tabella altrimenti ......
if (saldiSoggetto.ContainsKey(soggetto.ID))
saldoDTO.Importo += saldiSoggetto[soggetto.ID].Importo.GetValueOrDefault();
// .... lo ricalcolo partendo dal consuntivo dell'anno precedente, solo per gli esercizi ORDINARI.
else if (esercizio.Gestione == GestioneEsercizioEnum.Ordinario && spese != null)
saldoDTO.Importo += GetImportoSaldoPrecedenteDaConsuntivo(soggetto.ID, spese);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante il caricamento dei saldi dei soggetti - SINGOLO SOGGETTO - {0} - soggetto:{1} - esercizio:{2}", ex, Library.Utility.GetMethodDescription(), soggetto.ID, idEsercizio);
throw;
}
}
// Aggiungo eventuali saldi non considerati
foreach (var saldo in saldi)
{
var soggettoPrincipale = saldo.Soggetto;
if (tipoAccorpamento == TipoAccorpamentoRateEnum.Personalizzato && saldo.Soggetto.SoggettoPrincipale != null)
soggettoPrincipale = saldo.Soggetto.SoggettoPrincipale;
if (saldo.Importo.GetValueOrDefault() != 0 && !listaSaldi.ContainsKey(soggettoPrincipale.ID))
{
var saldoDTO = new ImportoSaldoSoggettoDTO
{
IdSoggettoCondominio = soggettoPrincipale.ID,
IdPersona = saldo.Soggetto.Persona.ID,
Importo = saldo.Importo.GetValueOrDefault(),
ID = saldo.ID,
Version = saldo.Version
};
listaSaldi.Add(saldoDTO.IdSoggettoCondominio, saldoDTO);
}
}
}
return listaSaldi.Values.ToList();
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante il caricamento dei saldi dei soggetti - {0} - esercizio:{1}", ex, Library.Utility.GetMethodDescription(), idEsercizio);
throw;
}
}
public IList<SoggettoCondominio> GetPartecipantiPianoRateale(int idEsercizio, TipoAccorpamentoRateEnum tipo)
{
try
{
var partecipanti = new List<SoggettoCondominio>();
var esercizio = _daoFactory.GetEsercizioDao().Find(idEsercizio, false);
if (esercizio != null)
{
var lista = _daoFactory.GetSoggettoCondominioDao().GetAttiviByEsercizio(esercizio, esercizio.DataChiusura);
foreach (var soggetto in lista)
{
if (soggetto.PercentualeRiferimento != null)
{
var principale = getSoggettoCondominioPrincipale(soggetto, lista, tipo);
if (!partecipanti.Contains(principale))
partecipanti.Add(principale);
}
}
}
return partecipanti;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la lettura dei soggetti partecipanti al piano rateale - {0} - esercizio:{1} - tipoCreazione:{2}", ex, Utility.GetMethodDescription(), idEsercizio, tipo);
throw;
}
}
public BilancioConsuntivoReportParameters(string[] descrizioneCondominio, string codiceCondominio, string descrizioneEsercizio, string descrizioneAzienda, bool? visualizzaGriglia, TipoDettaglioReportBilancio tipoDettaglio, bool? visualizzaProprietariInquilini, TipoReportBilancio tipoReport, TipoRendiconto tipoRendiconto, bool? definitivo, bool? stampaMillesimi, bool stampaSaldi, string note, string intestazioneStudio, string viaStudio, string capStudio, string localitaStudio, decimal totaleVersamenti, decimal saldoPrecedente, DateTime dataFineEsercizio, bool parzialeGruppo, bool parzialeStabile, bool accorpamentoUnita, bool totalePerPersona, TipoAccorpamentoRateEnum tipoAccorpamento, string datiFatturaNumeroRegistrazione, bool numeroInterno, bool salvaRiparto, bool inversioneSaldi, DateTime dataPrimaRegistrazione, DateTime dataUltimaRegistrazione)
{
DescrizioneCondominio = descrizioneCondominio;
CodiceCondominio = codiceCondominio;
DescrizioneAzienda = descrizioneAzienda;
DescrizioneEsercizio = descrizioneEsercizio;
VisualizzaGriglia = visualizzaGriglia;
TipoDettaglio = tipoDettaglio;
VisualizzaProprietariInquilini = visualizzaProprietariInquilini;
TipoReport = tipoReport;
TipoRendiconto = tipoRendiconto;
Definitivo = definitivo;
StampaMillesimi = stampaMillesimi;
StampaSaldi = stampaSaldi;
Note = note;
IntestazioneStudio = intestazioneStudio;
ViaStudio = viaStudio;
CapStudio = capStudio;
LocalitaStudio = localitaStudio;
TotaleVersamenti = totaleVersamenti;
SaldoPrecedente = saldoPrecedente;
DataFineEsercizio = dataFineEsercizio;
ParzialeGruppo = parzialeGruppo;
ParzialeStabile = parzialeStabile;
AccorpamentoUnita = accorpamentoUnita;
TotalePerPersona = totalePerPersona;
TipoAccorpamento = tipoAccorpamento;
DatiFatturaNumeroRegistrazione = datiFatturaNumeroRegistrazione;
NumeroInterno = numeroInterno;
SalvaRiparto = salvaRiparto;
InversioneSaldi = inversioneSaldi;
DataPrimaRegistrazione = dataPrimaRegistrazione;
DataUltimaRegistrazione = dataUltimaRegistrazione;
}
private List<ReportRipartizioneBilancioDTO> getRipartoDatasource(int idCondominio, int anno, int detrazione, bool accorpamentoUnita, TipoAccorpamentoRateEnum tipoAccorpamento)
{
return _bilancioService.GetRipartizioneDetrazione(idCondominio, anno, detrazione, _spese, accorpamentoUnita, tipoAccorpamento);
}
