/// <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 RendicontoAnnualeConto(RendicontoAnnuale rendiconto, SottoConto sottoConto, decimal? importo)
{
Rendiconto = rendiconto;
SottoContoRiferimento = sottoConto;
Importo = importo;
}
public RendicontoAnnualeConto(RendicontoAnnuale rendiconto, Conto conto, decimal? importo)
{
Rendiconto = rendiconto;
ContoRiferimento = conto;
Importo = importo;
}
private IList<ReportRipartizioneBilancioDTO> getReportItemsPreventivo(Esercizio esercizio, RendicontoAnnuale rendicontoDaUsare, IList<SoggettoCondominio> soggettiAttivi, int? idStabile, int? idScala, bool ripartizioneProprietarioConduttore, bool accorpamentoUnita, bool inversioneSaldi, bool calcoloPerSubentro, bool addebitiCondominio, bool addebitiDirettiStabileScala, bool dettaglioSottoConto)
{
var condominio = esercizio.CondominioRiferimento;
var idEsercizio = esercizio.ID;
var lista = new Dictionary<string, ReportRipartizioneBilancioDTO>();
// =============================================================================================
// Se esiste devo proporre lo storico
// =============================================================================================
var listaStorico = getStoricoRiparto(idEsercizio, idStabile, idScala, addebitiDirettiStabileScala, TipoRendiconto.Preventivo);
if (listaStorico.Any())
{
return listaStorico.Where(item => item.IdConto > 0).ToList();
}
else
{
// =============================================================================================
// Ricalcolo i saldi solo se ho un esercizio precedente aperto
// =============================================================================================
var esercizioPrecedente = esercizio.GetEsercizioPrecedente();
if (esercizioPrecedente != null && esercizioPrecedente.Stato == StatoEsercizioEnum.Aperto)
_saldoContabileService.TrasferimentoSaldiNuovoEsercizio(esercizio.ID, this, calcoloPerSubentro);
//====================================================================================
// Raggruppo gli importi del preventivo per Conto, Sottoconto, Lotto, Stabile e Scala
//====================================================================================
IList<ReportRipartizioneBilancioDTO> consuntivo = null;
if (rendicontoDaUsare.Conti.Any(item => item.GetConto().IsRipartoLetture))
{
// Il calcolo dal consuntivo, necessario per ripartire il preventivo se presente un conto a letture, deve sempre essere calcolato senza accorpamenti
// bugid#4171
if (esercizioPrecedente != null)
consuntivo = GetDataSourceRipartizioneBilancioConsuntivo(esercizioPrecedente.ID, null, null, null, null, idStabile, idScala, ripartizioneProprietarioConduttore, accorpamentoUnita, TipoAccorpamentoRateEnum.Nessuno, inversioneSaldi, calcoloPerSubentro, addebitiCondominio, addebitiDirettiStabileScala, null).ToList();
}
var importiConto = new List<ImportiContoSottocontoDTO>();
foreach (var rendicontoAnnualeConto in rendicontoDaUsare.Conti.Where(item => !item.GetConto().IsSpesePersonali))
{
if (!addebitiCondominio || !addebitiDirettiStabileScala || (rendicontoAnnualeConto.Stabile == null && rendicontoAnnualeConto.GruppoStabile == null))
{
if (!addebitiDirettiStabileScala ||
(
(idStabile == null || (rendicontoAnnualeConto.Stabile != null && rendicontoAnnualeConto.Stabile.ID == idStabile.GetValueOrDefault())) &&
(idScala == null || (rendicontoAnnualeConto.GruppoStabile != null && rendicontoAnnualeConto.GruppoStabile.ID == idScala.GetValueOrDefault()))
))
{
int? idSottoConto = null;
if (dettaglioSottoConto)
{
if (rendicontoAnnualeConto.SottoContoRiferimento != null)
idSottoConto = rendicontoAnnualeConto.SottoContoRiferimento.ID;
else
idSottoConto = rendicontoAnnualeConto.GetConto().ID *-1;
}
int? idStabileConto = null;
if (rendicontoAnnualeConto.Stabile != null)
idStabileConto = rendicontoAnnualeConto.Stabile.ID;
int? idScalaConto = null;
if (rendicontoAnnualeConto.GruppoStabile != null)
idScalaConto = rendicontoAnnualeConto.GruppoStabile.ID;
var importoConto = new ImportiContoSottocontoDTO
{
Conto = rendicontoAnnualeConto.GetConto().ID,
SottoConto = idSottoConto,
Stabile = idStabileConto,
Scala = idScalaConto,
ImportoProprieta =
_ripartizioneService.GetImportoCompetenza(
rendicontoAnnualeConto.Importo.GetValueOrDefault(),
rendicontoAnnualeConto.GetConto(),
rendicontoAnnualeConto.SottoContoRiferimento,
TipoSoggetto.Proprietario),
ImportoConduzione =
_ripartizioneService.GetImportoCompetenza(
rendicontoAnnualeConto.Importo.GetValueOrDefault(),
rendicontoAnnualeConto.GetConto(),
rendicontoAnnualeConto.SottoContoRiferimento,
TipoSoggetto.Conduttore)
};
addImporto(importoConto, importiConto);
}
}
}
//====================================================================================
// Eseguo il riparto
//====================================================================================
var millesimi = _daoFactory.GetMillesimoDao().GetByCondominio(condominio.ID);
var millesimiGroupByConto = millesimi.GroupBy(item => item.ContoRiferimento.ID).ToList();
var unitaImmobiliari = _daoFactory.GetUnitaImmobiliareDao().GetByCondominio(condominio.ID).ToDictionary(item => item.ID);
var conti = _daoFactory.GetContoDao().GetByCondominio(condominio.ID).ToDictionary(item => item.ID);
var soggetti = soggettiAttivi.ToDictionary(item => item.ID);
var riparto = new List<SpeseUnitaRipartoDTO>();
foreach (var importiContoSottocontoDTO in importiConto)
riparto.AddRange(getRiparto(importiContoSottocontoDTO, millesimiGroupByConto, consuntivo, esercizio, dettaglioSottoConto));
// ------------------------------------------------------------------
// Proprietari attivi
// ------------------------------------------------------------------
var listaProprietariAttivi = new Dictionary<int, IList<SoggettoCondominio>>();
var proprietariSoggettiAttivi = new Dictionary<int, SoggettoCondominio>();
foreach (var soggettoCondominio in soggettiAttivi.Where(item => item.Tipo == TipoSoggetto.Proprietario))
{
if (soggettoCondominio.Principale.GetValueOrDefault())
{
if (proprietariSoggettiAttivi.ContainsKey(soggettoCondominio.UnitaImmobiliare.ID))
{
if (soggettoCondominio.DataInizio.GetValueOrDefault() > proprietariSoggettiAttivi[soggettoCondominio.UnitaImmobiliare.ID].DataInizio.GetValueOrDefault() || proprietariSoggettiAttivi[soggettoCondominio.UnitaImmobiliare.ID].DataFine != null)
proprietariSoggettiAttivi[soggettoCondominio.UnitaImmobiliare.ID] = soggettoCondominio;
}
else
proprietariSoggettiAttivi.Add(soggettoCondominio.UnitaImmobiliare.ID, soggettoCondominio);
}
if (listaProprietariAttivi.ContainsKey(soggettoCondominio.UnitaImmobiliare.ID))
listaProprietariAttivi[soggettoCondominio.UnitaImmobiliare.ID].Add(soggettoCondominio);
else
listaProprietariAttivi.Add(soggettoCondominio.UnitaImmobiliare.ID, new List<SoggettoCondominio> { soggettoCondominio });
}
// ------------------------------------------------------------------
// Conduttori attivi
// ------------------------------------------------------------------
var conduttoriSoggettiAttivi = new Dictionary<int, IList<SoggettoCondominio>>();
foreach (var soggettoCondominioUnita in soggettiAttivi.Where(item => item.Tipo == TipoSoggetto.Conduttore).GroupBy(item => item.UnitaImmobiliare))
conduttoriSoggettiAttivi.Add(soggettoCondominioUnita.Key.ID, soggettoCondominioUnita.ToList());
var soggettiAttiviByUnitaImmobiliare = new Dictionary<int, IList<SoggettoCondominio>>();
foreach (var soggettoCondominioUnita in soggettiAttivi.GroupBy(item => item.UnitaImmobiliare))
soggettiAttiviByUnitaImmobiliare.Add(soggettoCondominioUnita.Key.ID, soggettoCondominioUnita.ToList());
// ------------------------------------------------------------------
// Aggiungo le spese personali (NON sono soggette a riparto)
// ------------------------------------------------------------------
foreach (var rendicontoAnnualeConto in rendicontoDaUsare.Conti.Where(item => item.GetConto().IsSpesePersonali))
{
riparto.AddRange(rendicontoAnnualeConto.DettagliUnita.Select(spesa => new SpeseUnitaRipartoDTO
{
ID = spesa.ID,
IdConto = rendicontoAnnualeConto.GetConto().ID,
IdUnita = spesa.Unita.ID,
UnitaMisuraMillesimo = "PC",
ImportoConduttore = _ripartizioneService.GetImportoCompetenza(spesa.Importo.GetValueOrDefault(), rendicontoAnnualeConto.GetConto(), rendicontoAnnualeConto.SottoContoRiferimento, TipoSoggetto.Conduttore),
ImportoProprietario = _ripartizioneService.GetImportoCompetenza(spesa.Importo.GetValueOrDefault(), rendicontoAnnualeConto.GetConto(), rendicontoAnnualeConto.SottoContoRiferimento, TipoSoggetto.Proprietario)
}));
}
//=====================================================================================================
// Elaborazione delle ripartizioni
//=====================================================================================================
var index = 0;
foreach (var spesa in riparto)
{
try
{
index++;
var conto = conti.ContainsKey(spesa.IdConto) ? conti[spesa.IdConto] : _daoFactory.GetContoDao().GetById(spesa.IdConto, false);
var unita = unitaImmobiliari.ContainsKey(spesa.IdUnita.GetValueOrDefault()) ? unitaImmobiliari[spesa.IdUnita.GetValueOrDefault()] : _daoFactory.GetUnitaImmobiliareDao().GetById(spesa.IdUnita.GetValueOrDefault(), false);
SottoConto sottoconto = null;
if (spesa.IdSottoConto > 0)
sottoconto = conto.SottoConti.FirstOrDefault(item => item.ID == spesa.IdSottoConto.Value);
// -------------------------------------------------------
// Verifica se appartiene a scala e/o stabile selezionato
// -------------------------------------------------------
if (idStabile != null)
{
if (unita.GruppoStabileRiferimento.PalazzinaRiferimento.ID != idStabile.Value)
continue;
}
if (idScala != null)
{
if (unita.GruppoStabileRiferimento.ID != idScala.Value)
continue;
}
// -------------------------
// Proprietario
// -------------------------
SoggettoCondominio proprietarioPrincipale = null;
if(proprietariSoggettiAttivi.ContainsKey(spesa.IdUnita.GetValueOrDefault()))
proprietarioPrincipale = proprietariSoggettiAttivi[spesa.IdUnita.GetValueOrDefault()];
// Se il proprietario non è presente lo cerco tra tutti i proprietari
if (proprietarioPrincipale == null)
{
proprietarioPrincipale = (from item in unita.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(), spesa.IdUnita, idEsercizio.ToString());
}
var importoProprieta = spesa.ImportoProprietario;
if (importoProprieta != 0)
{
var soggProp = new List<ImportiDTO>();
if (!accorpamentoUnita)
{
var soggPropRip = (conto.SoggettiRipartizione.Where(itemSogg =>
itemSogg.PercentualeRipartizione > 0 &&
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)
{
IList<SoggettoCondominio> proprietariAttivi = new List<SoggettoCondominio>();
if(listaProprietariAttivi.ContainsKey(spesa.IdUnita.GetValueOrDefault()))
proprietariAttivi = listaProprietariAttivi[spesa.IdUnita.GetValueOrDefault()];
if (proprietariAttivi.Count == 0 && proprietarioPrincipale != null)
proprietariAttivi.Add(proprietarioPrincipale);
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()));
foreach (var idSogg in soggProp)
{
try
{
if (idSogg.Importo != 0)
{
var key = spesa.IdConto + "_" + spesa.IdUnita;
if (!accorpamentoUnita)
key += "_" + idSogg.Id;
key += "_PROP";
ReportRipartizioneBilancioDTO item;
if (lista.ContainsKey(key))
item = lista[key];
else
{
item = new ReportRipartizioneBilancioDTO();
lista.Add(key, item);
item.IdPartecipante = idSogg.Id;
item.Importo = 0;
item.IdConto = spesa.IdConto;
item.IdUnitaImmobiliare = spesa.IdUnita.GetValueOrDefault();
item.IdStabile = unita.GruppoStabileRiferimento.PalazzinaRiferimento.ID;
item.IdGruppoStabile = unita.GruppoStabileRiferimento.ID;
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;
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)
{
descrizioneSottoConto = item.DescrizioneConto;
codiceSottoConto = item.CodiceConto;
}
item.CodiceSottoConto = codiceSottoConto;
item.DescrizioneSottoConto = descrizioneSottoConto;
item.IdSottoConto = spesa.IdSottoConto;
}
item.OrdineConto = conto.Ordine;
item.TipoUnitaImmobiliare = unita.TipoUnitaImmobiliare.Descrizione;
item.DescrizioneGruppoStabile = unita.GruppoStabileRiferimento.Descrizione;
item.OrdineGruppoStabile = unita.GruppoStabileRiferimento.Ordine;
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;
if (!accorpamentoUnita)
{
var sogg = findSoggettoCondominio(idSogg.Id, soggetti);
item.DataUscitaPartecipante = getDataUscita(sogg);
item.Nominativo = sogg.DisplayName;
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 = 10;
item.TipoNominativo = "PROP";
item.TipoNominativoEffettivo = findSoggettoCondominio(item.IdPartecipante, soggetti).Tipo.ToString().Substring(0, 1);
item.NumeroColonne = 1;
item.IdGruppoStabileAddebito = spesa.IdGruppoStabileAddebito;
item.IdStabileAddebito = spesa.IdStabileAddebito;
}
item.Importo += idSogg.Importo;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la lettura del datasource per il riparto del consuntivo - SPESE PROPRIETARI - {0} - soggetto:{1} - spesa:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), idSogg.Id, spesa.ID, idEsercizio);
throw;
}
}
}
// -------------------------
// Conduttore
// -------------------------
if (spesa.ImportoConduttore != 0)
{
var soggCond = new List<ImportiDTO>();
if (!accorpamentoUnita)
{
var soggCondRip = (conto.SoggettiRipartizione.Where(
itemSogg => itemSogg.PercentualeRipartizione > 0 &&
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 = new List<SoggettoCondominio>();
if(conduttoriSoggettiAttivi.ContainsKey(spesa.IdUnita.GetValueOrDefault()))
conduttoriAttivi = conduttoriSoggettiAttivi[spesa.IdUnita.GetValueOrDefault()].Where(item => item.PercentualeRiferimento > 0).ToList();
if (!conduttoriAttivi.Any())
{
if(listaProprietariAttivi.ContainsKey(spesa.IdUnita.GetValueOrDefault()))
conduttoriAttivi.AddRange(listaProprietariAttivi[spesa.IdUnita.GetValueOrDefault()]);
}
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
{
_log.ErrorFormat("Unità immobiliare senza proprietario principale - {0} - idUnita:{1}", Utility.GetMethodDescription(), unita.ID);
throw new InvalidDataException($"L'unità immobiliare {unita.Descrizione} non ha un proprietario principale");
}
foreach (var idSogg in soggCond)
{
try
{
if (idSogg.Importo != 0)
{
var key = spesa.IdConto + "_" + spesa.IdUnita;
if (!accorpamentoUnita)
key += "_" + idSogg.Id;
key += "_COND";
ReportRipartizioneBilancioDTO item;
if (lista.ContainsKey(key))
item = lista[key];
else
{
item = new ReportRipartizioneBilancioDTO();
lista.Add(key, item);
item.IdPartecipante = idSogg.Id;
item.Importo = 0;
item.IdConto = spesa.IdConto;
item.IdStabile = unita.GruppoStabileRiferimento.PalazzinaRiferimento.ID;
item.IdGruppoStabile = unita.GruppoStabileRiferimento.ID;
item.IdUnitaImmobiliare = spesa.IdUnita.GetValueOrDefault();
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)
{
descrizioneSottoConto = item.DescrizioneConto;
codiceSottoConto = item.CodiceConto;
}
item.CodiceSottoConto = codiceSottoConto;
item.DescrizioneSottoConto = descrizioneSottoConto;
item.IdSottoConto = spesa.IdSottoConto;
}
item.TipoUnitaImmobiliare = unita.TipoUnitaImmobiliare.Descrizione;
item.DescrizioneGruppoStabile = unita.GruppoStabileRiferimento.Descrizione;
item.DescrizioneStabile = unita.GruppoStabileRiferimento.PalazzinaRiferimento.Descrizione;
item.OrdineGruppoStabile = unita.GruppoStabileRiferimento.Ordine;
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;
if (!accorpamentoUnita)
{
var sogg = findSoggettoCondominio(idSogg.Id, soggetti);
item.DataUscitaPartecipante = getDataUscita(sogg);
item.Nominativo = sogg.DisplayName;
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, soggetti).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} - spesa:{1} - esercizio:{2}", ex, Utility.GetMethodDescription(), spesa.ID, idEsercizio);
throw;
}
}
//==============================================================================================================
// Elaborazione SUBENTRI per avere una riga per ogni soggetto
//==============================================================================================================
elaboraSubentri(esercizio, accorpamentoUnita, lista, soggettiAttiviByUnitaImmobiliare, conti, dettaglioSottoConto);
// ======================================================
// Rielaborazione nominativi
// ======================================================
elaborazioneNominativi(lista.Values);
return lista.Values.ToList();
}
}
public void SalvaBilancio(int idEsercizio, byte[] bytes, TipoRendiconto tipo)
{
var esercizio = _daoFactory.GetEsercizioDao().GetById(idEsercizio, false);
// Elenco rendiconti
var rendiconto = new RendicontoAnnuale(esercizio, "Bilancio", tipo) { Stato = StatoRendicontoEnum.Salvato };
var fileName = "Bilancio " + tipo + " - " + esercizio.DataApertura.GetValueOrDefault().Year + ".pdf";
var documentMessage = _documentService.SaveDocument(bytes, fileName, ".pdf", null, esercizio.CondominioRiferimento.Azienda.ID);
if(documentMessage.Documento != null)
{
var checksum = documentMessage.Documento.Checksum;
rendiconto.Documento = new Documento(checksum, fileName, ".pdf", "Bilancio", false, esercizio.CondominioRiferimento.Azienda);
_daoFactory.GetDocumentoDao().SaveOrUpdate(rendiconto.Documento);
_daoFactory.GetRendicontoAnnualeDao().SaveOrUpdate(rendiconto);
}
}
public string SetRendicontoPreventivo(int idEsercizio, int? idStabile, int? idScala, BilancioPreventivoDTO bilancioPreventivo, StatoRendicontoEnum stato, bool dettaglioSottoConto)
{
try
{
var message = string.Empty;
var esercizio = _daoFactory.GetEsercizioDao().GetById(idEsercizio, false);
if (esercizio.Stato == StatoEsercizioEnum.Chiuso)
return "L'esercizio è chiuso non è possibile modificare il bilancio preventivo";
// -------------------------------------------
// Testata rendiconto
// -------------------------------------------
RendicontoAnnuale rendiconto = null;
try
{
rendiconto = _daoFactory.GetRendicontoAnnualeDao().Find(bilancioPreventivo.ID, false);
if (rendiconto == null)
{
// Eliminazione vecchi rendiconti provvisori
// -----------------------------------------------------------------
try
{
var rendiconti = _daoFactory.GetRendicontoAnnualeDao().GetByEsercizio(idEsercizio);
foreach (var rendicontoOld in rendiconti)
{
try
{
if (rendicontoOld.Stato == StatoRendicontoEnum.Provvisorio && rendicontoOld.Tipo == TipoRendiconto.Preventivo)
_daoFactory.GetRendicontoAnnualeDao().Delete(rendicontoOld);
else if (rendicontoOld.Stato == StatoRendicontoEnum.Definitivo && rendicontoOld.Tipo == TipoRendiconto.Preventivo)
throw new InvalidOperationException("E' già presente un rendiconto Preventivo DEFINITIVO non è possibile creare un ulteriore rendiconto.");
}
catch (Exception ex)
{
var idRendiconto = "<NULL>";
if (rendicontoOld != null)
idRendiconto = rendicontoOld.ID.ToString(CultureInfo.InvariantCulture);
_log.ErrorFormat("Errore inaspettato durante la creazione del bilancio preventivo - ELIMINAZIONE SINGOLO RENDICONTO - {0} - rendiconto:{1} - idEsercizio:{2} - stabile:{3} - scala:{4} - dettaglioSottoConto:{5}", ex, Utility.GetMethodDescription(), idRendiconto, idEsercizio, idStabile.GetValueOrDefault(), idScala.GetValueOrDefault(), dettaglioSottoConto);
throw;
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la creazione del bilancio preventivo - ELIMINAZIONE VECCHI RENDICONTI - {0} - idEsercizio:{1} - stabile:{2} - scala:{3} - dettaglioSottoConto:{5}", ex, Utility.GetMethodDescription(), idEsercizio, idStabile.GetValueOrDefault(), idScala.GetValueOrDefault(), dettaglioSottoConto);
throw;
}
// Elimino il riparto storico
// -----------------------------------------------------------------
try
{
var storico = _daoFactory.GetStoricoRipartoDao().GetByEsercizioTipo(idEsercizio, TipoRendiconto.Preventivo);
foreach (var storicoRiparto in storico)
_daoFactory.GetStoricoRipartoDao().Delete(storicoRiparto);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la creazione del bilancio preventivo - ELIMINAZIONE STORICO - {0} - idEsercizio:{1} - stabile:{2} - scala:{3} - dettaglioSottoConto:{4}", ex, Utility.GetMethodDescription(), idEsercizio, idStabile.GetValueOrDefault(), idScala.GetValueOrDefault(), dettaglioSottoConto);
throw;
}
// Creo il nuovo rendiconto
// -----------------------------------------------------------------
try
{
rendiconto = new RendicontoAnnuale(esercizio, "Bilancio", TipoRendiconto.Preventivo) { CalcoloPerSottoconto = dettaglioSottoConto, Stato = stato };
_daoFactory.GetRendicontoAnnualeDao().SaveOrUpdate(rendiconto);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la creazione del bilancio preventivo - NUOVO RENDICONTO - {0} - idEsercizio:{1} - stabile:{2} - scala:{3} - dettaglioSottoConto:{4}", ex, Utility.GetMethodDescription(), idEsercizio, idStabile.GetValueOrDefault(), idScala.GetValueOrDefault(), dettaglioSottoConto);
throw;
}
}
rendiconto.Stato = stato;
}
catch (Exception ex)
{
var idRendiconto = "<NULL>";
if (rendiconto != null)
idRendiconto = rendiconto.ID.ToString(CultureInfo.InvariantCulture);
_log.ErrorFormat("Errore inaspettato durante la creazione del bilancio preventivo - TESTATA RENDICONTO - {0} - rendiconto:{1} - idEsercizio:{2} - stabile:{3} - scala:{4} - dettaglioSottoConto:{5}", ex, Utility.GetMethodDescription(), idRendiconto, idEsercizio, idStabile.GetValueOrDefault(), idScala.GetValueOrDefault(), dettaglioSottoConto);
throw;
}
// -------------------------------------------
// Dettaglio conti
// -------------------------------------------
foreach (var dettaglioConto in bilancioPreventivo.Dettaglio)
{
try
{
if (dettaglioConto.ImportoPreventivo != null && dettaglioConto.ImportoPreventivo != 0)
{
RendicontoAnnualeConto conto;
if (dettaglioConto.ID == 0)
{
// Stabile e/o Gruppo Stabile (Scala) di riferimento
// --------------------------------------------------
Palazzina stabile = null;
if (dettaglioConto.IdStabile > 0)
stabile = _daoFactory.GetPalazzinaDao().GetById(dettaglioConto.IdStabile.Value, false);
GruppoStabile scala = null;
if (dettaglioConto.IdGruppoStabile > 0)
scala = _daoFactory.GetGruppoStabileDao().GetById(dettaglioConto.IdGruppoStabile.Value, false);
conto = dettaglioConto.IdSottoConto > 0 ? new RendicontoAnnualeConto(rendiconto, _daoFactory.GetSottoContoDao().GetById(dettaglioConto.IdSottoConto, false), dettaglioConto.ImportoPreventivo) : new RendicontoAnnualeConto(rendiconto, _daoFactory.GetContoDao().GetById(dettaglioConto.IdConto, false), dettaglioConto.ImportoPreventivo);
conto.Stabile = stabile;
conto.GruppoStabile = scala;
}
else
{
conto = _daoFactory.GetRendicontoAnnualeContoDao().Find(dettaglioConto.ID, false);
if (conto == null)
{
message = "Errore inaspettato nella creazione del bilancio preventivo." + Environment.NewLine + "Ricaricare la videata e riprovare";
_log.Error("Errore inaspettato durante la creazione del bilancio preventivo - Dettaglio Conti - GetById - " + Utility.GetMethodDescription() + " - dettaglioConto:" + dettaglioConto.ID + " - idEsercizio: " + idEsercizio + " - Stabile:" + idStabile.GetValueOrDefault() + " - Scala:" + idScala.GetValueOrDefault() + " - dettaglio:" + dettaglioSottoConto);
return message;
}
conto.Importo = dettaglioConto.ImportoPreventivo;
}
// Eventuali dettagli per unità
// -------------------------------------
if (dettaglioConto.DettaglioUnita != null && dettaglioConto.DettaglioUnita.Count > 0)
{
decimal importoConto = 0;
foreach (var calcoloUnita in dettaglioConto.DettaglioUnita)
{
try
{
var dettaglioUnita = _daoFactory.GetRendicontoAnnualeUnitaDao().Find(calcoloUnita.ID, false);
if (dettaglioUnita != null)
{
if (calcoloUnita.ImportoPreventivo != null && calcoloUnita.ImportoPreventivo != 0)
dettaglioUnita.Importo = calcoloUnita.ImportoPreventivo;
else // se importo == 0 elimino il dettaglio per unità
{
dettaglioUnita.Conto.DettagliUnita.Remove(dettaglioUnita);
dettaglioUnita.Conto = null;
}
}
else
{
if (calcoloUnita.ImportoPreventivo != null && calcoloUnita.ImportoPreventivo != 0)
new RendicontoAnnualeUnita(conto, _daoFactory.GetUnitaImmobiliareDao().GetById(calcoloUnita.IdUnita, false), calcoloUnita.ImportoPreventivo);
}
if (calcoloUnita.ImportoPreventivo != null)
importoConto += calcoloUnita.ImportoPreventivo.Value;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la creazione del bilancio preventivo - SINGOLA UNITA' - {0} - dettaglioConto:{1} - idEsercizio:{2} - stabile:{3} - scala:{4} - conto:{5} - unità:{6}", ex, Utility.GetMethodDescription(), dettaglioConto.ID, idEsercizio, idStabile.GetValueOrDefault(), idScala.GetValueOrDefault(), dettaglioSottoConto, calcoloUnita.ID);
throw;
}
}
conto.Importo = importoConto;
}
_daoFactory.GetRendicontoAnnualeContoDao().SaveOrUpdate(conto);
}
else if (dettaglioConto.ID > 0)
{
var conto = _daoFactory.GetRendicontoAnnualeContoDao().Find(dettaglioConto.ID, false);
if (conto != null)
{
conto.Rendiconto.Conti.Remove(conto);
conto.Rendiconto = null;
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la creazione del bilancio preventivo - SINGOLO CONTO - {0} - dettaglioConto:{1} - idEsercizio:{2} - stabile:{3} - scala:{4} - dettaglio:{5}", ex, Utility.GetMethodDescription(), dettaglioConto.ID, idEsercizio, idStabile.GetValueOrDefault(), idScala.GetValueOrDefault(), dettaglioSottoConto);
throw;
}
}
// -------------------------------------------------------------
// Memorizzo nell'esercizio il codice del rendiconto DEFINITIVO
// -------------------------------------------------------------
if (stato == StatoRendicontoEnum.Definitivo)
{
esercizio.RendicontoPreventivoCorrente = rendiconto;
if (esercizio.AnnoGestionale.AnnoGestionalePrecedente?.EsercizioOrdinario != null)
esercizio.AnnoGestionale.AnnoGestionalePrecedente.EsercizioOrdinario.RendicontoPreventivoEsercizioSuccessivo = rendiconto;
// se è definitivo storicizzo il riparto
// ===================================================================================
// TODO: Per ora non viene salvato lo storico perchè può capitare che per sbaglio il
// preventivo sia reso definitivo senza che siano stati inseriti i millesimi.
// ===================================================================================
//var messageStorico = StoricizzaRiparto(idEsercizio, TipoRendiconto.Preventivo);
//if (!string.IsNullOrEmpty(messageStorico))
// message += messageStorico + Environment.NewLine;
}
return message;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la creazione del bilancio preventivo - {0} - idEsercizio:{1} - Stabile:{2} - Scala:{3} - Dettaglio:{4}", ex, Utility.GetMethodDescription(), idEsercizio, idStabile.GetValueOrDefault(), idScala.GetValueOrDefault(), dettaglioSottoConto);
throw;
}
}
private RendicontoAnnualeDTO setDto(RendicontoAnnuale item)
{
var dto = new RendicontoAnnualeDTO
{
DescrizioneEsercizio = item.Esercizio.DisplayName,
ID = item.ID,
IdEsercizio = item.Esercizio.ID,
Note = item.Note,
StatoRendiconto = item.Stato,
Tipo = item.Tipo,
CalcoloPerSottoconto = item.CalcoloPerSottoconto,
Descrizione = item.Descrizione,
Version = item.Version
};
if (item.Documento != null)
dto.IdDocumento = item.Documento.ID;
dto.Conti = new List<RendicontoAnnualeContoDTO>(item.Conti.Count);
foreach (var conto in item.Conti)
{
var contoDTO = new RendicontoAnnualeContoDTO();
if (conto.ContoRiferimento != null)
{
contoDTO.DescrizioneConto = conto.ContoRiferimento.Descrizione;
contoDTO.CodiceConto = conto.ContoRiferimento.Codice;
}
else if (conto.SottoContoRiferimento != null)
{
contoDTO.DescrizioneConto = conto.SottoContoRiferimento.GetDescrizione(item.Esercizio, null , null);
contoDTO.CodiceConto = conto.SottoContoRiferimento.Codice;
}
contoDTO.ID = conto.ID;
contoDTO.IdRendiconto = dto.ID;
contoDTO.Importo = conto.Importo;
contoDTO.Version = conto.Version;
dto.Conti.Add(contoDTO);
}
return dto;
}