public BilancioPreventivoDTO CalcolaPreventivo(int idEsercizio, int? idStabile, int? idScala, TipoRendiconto riferimentoVariazione, decimal? variazione, bool dettaglioSottoConto, bool copiaEsercizioPrecedente, bool importiEsercizioPrecedente)
{
try
{
var esercizio = _daoFactory.GetEsercizioDao().GetById(idEsercizio, false);
// ==========================================================================================================
// Se richiesto lo copio dall'esercizio precedente
// ==========================================================================================================
if (copiaEsercizioPrecedente)
{
var esercizioPrecedente = esercizio.GetEsercizioPrecedente();
if (esercizioPrecedente != null)
{
var consuntivoPrecedente = GetDataSourceBilancioConsuntivo_SottoConto(esercizioPrecedente.ID, null, null, null, null, true, true).ToList();
var rendiconti = _daoFactory.GetRendicontoAnnualeDao().GetByEsercizio(esercizioPrecedente.ID).Where(item => item.Tipo == TipoRendiconto.Preventivo).ToList();
if (rendiconti.Count > 0)
{
var rendicontoPrecedente = rendiconti[0];
var rendiconto = new BilancioPreventivoDTO
{
DescrizioneEsercizio = esercizio.DisplayName,
IdEsercizio = esercizio.ID,
CalcoloPerSottoconto = rendicontoPrecedente.CalcoloPerSottoconto,
StatoRendiconto = StatoRendicontoEnum.Provvisorio,
Dettaglio = new List<CalcoloBilancioPreventivoDTO>()
};
foreach (var rendicontoAnnualeContoPrecedente in rendicontoPrecedente.Conti)
{
var conto = rendicontoAnnualeContoPrecedente.ContoRiferimento;
if (conto == null && rendicontoAnnualeContoPrecedente.SottoContoRiferimento != null)
conto = rendicontoAnnualeContoPrecedente.SottoContoRiferimento.ContoRiferimento;
if (conto != null && conto.EsercizioRiferimento == null)
{
var rendicontoConto = new CalcoloBilancioPreventivoDTO { DettaglioUnita = new List<CalcoloUnitaBilancioPreventivoDTO>() };
if(rendicontoAnnualeContoPrecedente.ContoRiferimento != null)
{
rendicontoConto.IdConto = rendicontoAnnualeContoPrecedente.ContoRiferimento.ID;
rendicontoConto.Codice = rendicontoAnnualeContoPrecedente.ContoRiferimento.Codice;
rendicontoConto.OrdineConto = rendicontoAnnualeContoPrecedente.ContoRiferimento.Ordine;
rendicontoConto.Descrizione = rendicontoAnnualeContoPrecedente.ContoRiferimento.Descrizione;
}
if (rendicontoAnnualeContoPrecedente.SottoContoRiferimento != null)
{
rendicontoConto.IdConto = rendicontoAnnualeContoPrecedente.SottoContoRiferimento.ContoRiferimento.ID;
rendicontoConto.Codice = rendicontoAnnualeContoPrecedente.SottoContoRiferimento.Codice;
rendicontoConto.OrdineConto = rendicontoAnnualeContoPrecedente.SottoContoRiferimento.ContoRiferimento.Ordine;
rendicontoConto.IdSottoConto = rendicontoAnnualeContoPrecedente.SottoContoRiferimento.ID;
rendicontoConto.Descrizione = rendicontoAnnualeContoPrecedente.SottoContoRiferimento.GetDescrizione(esercizio, null, null);
}
if(rendicontoAnnualeContoPrecedente.Stabile != null)
{
rendicontoConto.IdStabile = rendicontoAnnualeContoPrecedente.Stabile.ID;
rendicontoConto.DescrizioneStabile = rendicontoAnnualeContoPrecedente.Stabile.DisplayName;
}
if (rendicontoAnnualeContoPrecedente.GruppoStabile != null)
{
rendicontoConto.IdStabile = rendicontoAnnualeContoPrecedente.GruppoStabile.PalazzinaRiferimento.ID;
rendicontoConto.DescrizioneStabile = rendicontoAnnualeContoPrecedente.GruppoStabile.PalazzinaRiferimento.DisplayName;
rendicontoConto.IdGruppoStabile = rendicontoAnnualeContoPrecedente.GruppoStabile.ID;
rendicontoConto.DescrizioneGruppoStabile = rendicontoAnnualeContoPrecedente.GruppoStabile.Descrizione;
}
var importoConsuntivo = getImportoConsuntivo(rendicontoConto.IdConto, rendicontoConto.IdSottoConto, rendicontoConto.IdStabile, rendicontoConto.IdGruppoStabile, consuntivoPrecedente);
rendicontoConto.ImportoConsuntivo = importoConsuntivo;
rendicontoConto.ImportoPreventivoAnnoPrecedente = rendicontoAnnualeContoPrecedente.Importo;
var importo = rendicontoConto.ImportoPreventivoAnnoPrecedente;
if (variazione != null)
{
if (riferimentoVariazione == TipoRendiconto.Consuntivo && rendicontoConto.ImportoConsuntivo != null)
importo = rendicontoConto.ImportoConsuntivo + ((rendicontoConto.ImportoConsuntivo * variazione) / 100);
else if (riferimentoVariazione == TipoRendiconto.Preventivo && rendicontoConto.ImportoPreventivoAnnoPrecedente != null)
importo = rendicontoConto.ImportoPreventivoAnnoPrecedente + ((rendicontoConto.ImportoPreventivoAnnoPrecedente * variazione) / 100);
}
rendicontoConto.ImportoPreventivo = importo;
foreach (var rendicontoAnnualeUnitaPrecedente in rendicontoAnnualeContoPrecedente.DettagliUnita)
{
var rendicontoUnita = new CalcoloUnitaBilancioPreventivoDTO
{
IdUnita = rendicontoAnnualeUnitaPrecedente.Unita.ID,
Ordine = rendicontoAnnualeUnitaPrecedente.Unita.Ordine.GetValueOrDefault(),
Descrizione = rendicontoAnnualeUnitaPrecedente.Unita.Descrizione,
ImportoPreventivoAnnoPrecedente = rendicontoAnnualeUnitaPrecedente.Importo,
ImportoPreventivo = rendicontoAnnualeUnitaPrecedente.Importo
};
rendicontoConto.DettaglioUnita.Add(rendicontoUnita);
}
rendiconto.Dettaglio.Add(rendicontoConto);
}
}
return rendiconto;
}
}
}
// ==========================================================================================================
// Il calcolo del preventivo può essere effettuato sulla base del consuntivo/preventivo dell'anno precedente
// ==========================================================================================================
IList<ReportBilancioDTO> consuntivo = null;
IList<ReportBilancioDTO> preventivoBilancio = null;
if (esercizio.GetEsercizioPrecedente() != null && importiEsercizioPrecedente)
{
preventivoBilancio = GetDataSourceBilancioPreventivo_SottoConto(esercizio.GetEsercizioPrecedente().ID, idStabile, idScala, false, false, false, false);
consuntivo = dettaglioSottoConto ? GetDataSourceBilancioConsuntivo_SottoConto(esercizio.GetEsercizioPrecedente().ID, null, null, null, null, false, false).ToList() : GetDataSourceBilancioConsuntivoConto(esercizio.GetEsercizioPrecedente().ID).ToList();
}
var preventivoCalcolato = new List<CalcoloBilancioPreventivoDTO>();
var conti = _daoFactory.GetContoDao().GetBilancioByEsercizio(idEsercizio, esercizio.CondominioRiferimento.ID);
foreach (var conto in conti)
{
var sottoConti = conto.SottoConti.Where(item => item.Deleted != "Y").OrderBy(item => item.Codice);
// ====================================================
// Calcolo per sotto conto
// ====================================================
if (sottoConti.Any() && dettaglioSottoConto)
{
// -----------------------
// Righe conto
// -----------------------
if (sottoConti.Any())
{
try
{
var preventivoConto = new CalcoloBilancioPreventivoDTO
{
IdConto = conto.ID,
Codice = conto.Codice,
Descrizione = conto.Descrizione,
OrdineConto = conto.Ordine
};
if (preventivoBilancio != null || consuntivo != null)
{
// Preventivo anno precedente
if (preventivoBilancio != null)
preventivoConto.ImportoPreventivoAnnoPrecedente = getImportoConsuntivo(conto.ID, 0, preventivoBilancio, true);
// Consuntivo anno precedente
if (consuntivo != null)
preventivoConto.ImportoConsuntivo = getImportoConsuntivo(conto.ID, 0, consuntivo, true);
// Preventivo attuale proposto
if (variazione != null)
{
if (riferimentoVariazione == TipoRendiconto.Consuntivo && preventivoConto.ImportoConsuntivo != null)
preventivoConto.ImportoPreventivo = preventivoConto.ImportoConsuntivo + ((preventivoConto.ImportoConsuntivo * variazione) / 100);
else if (riferimentoVariazione == TipoRendiconto.Preventivo && preventivoConto.ImportoPreventivoAnnoPrecedente != null)
preventivoConto.ImportoPreventivo = preventivoConto.ImportoPreventivoAnnoPrecedente + ((preventivoConto.ImportoPreventivoAnnoPrecedente * variazione) / 100);
}
}
// --------------------------------------------------------------------------------
// Stabile
// --------------------------------------------------------------------------------
if (idStabile != null)
{
var palazzina = _daoFactory.GetPalazzinaDao().GetById(idStabile.Value, false);
preventivoConto.IdStabile = palazzina.ID;
preventivoConto.DescrizioneStabile = palazzina.Descrizione;
}
// --------------------------------------------------------------------------------
// Scala
// --------------------------------------------------------------------------------
if (idScala != null)
{
var scala = _daoFactory.GetGruppoStabileDao().GetById(idScala.Value, false);
preventivoConto.IdGruppoStabile = scala.ID;
preventivoConto.DescrizioneGruppoStabile = scala.Descrizione;
preventivoConto.IdStabile = scala.PalazzinaRiferimento.ID;
preventivoConto.DescrizioneStabile = scala.PalazzinaRiferimento.Descrizione;
}
// --------------------------------------------------------------------------------
// Aggiungo i dettagli se il conto è di spese personali
// --------------------------------------------------------------------------------
preventivoConto.DettaglioUnita = new List<CalcoloUnitaBilancioPreventivoDTO>();
if (conto.IsSpesePersonali)
{
IList<ImportiDTO> importi = new List<ImportiDTO>();
if (esercizio.GetEsercizioPrecedente() != null)
importi = _daoFactory.GetSpeseUnitaDao().GetTotaleSpeseByConto(conto.ID, esercizio.GetEsercizioPrecedente());
addPreventivoPerUnita(preventivoConto, esercizio, importi);
}
preventivoCalcolato.Add(preventivoConto);
}
catch (Exception ex)
{
_log.Error("Errore inaspettato durante la creazione della lista per l'inserimento dei valori di preventivo - Calcolo per sottoconto - " + Utility.GetMethodDescription() + " - idEsercizio: " + idEsercizio + " - Conto:" + conto.ID, ex);
throw;
}
}
// -----------------------
// Righe Sotto Conto
// -----------------------
foreach (var sottoConto in sottoConti)
{
try
{
var preventivo = new CalcoloBilancioPreventivoDTO
{
IdConto = conto.ID,
IdSottoConto = sottoConto.ID,
Codice = sottoConto.Codice,
Descrizione = sottoConto.GetDescrizione(esercizio, null, null),
OrdineConto = conto.Ordine
};
if (preventivoBilancio != null || consuntivo != null)
{
// Preventivo anno precedente
if (preventivoBilancio != null)
preventivo.ImportoPreventivoAnnoPrecedente = getImportoConsuntivo(0, sottoConto.ID, preventivoBilancio, true);
// Consuntivo anno precedente
if (consuntivo != null)
preventivo.ImportoConsuntivo = getImportoConsuntivo(0, sottoConto.ID, consuntivo, true);
// Preventivo attuale proposto
if (variazione != null)
{
if (riferimentoVariazione == TipoRendiconto.Consuntivo && preventivo.ImportoConsuntivo != null)
preventivo.ImportoPreventivo = preventivo.ImportoConsuntivo + ((preventivo.ImportoConsuntivo * variazione) / 100);
else if (riferimentoVariazione == TipoRendiconto.Preventivo && preventivo.ImportoPreventivoAnnoPrecedente != null)
preventivo.ImportoPreventivo = preventivo.ImportoPreventivoAnnoPrecedente + ((preventivo.ImportoPreventivoAnnoPrecedente * variazione) / 100);
}
}
// --------------------------------------------------------------------------------
// Stabile
// --------------------------------------------------------------------------------
if (idStabile != null)
{
var palazzina = _daoFactory.GetPalazzinaDao().GetById(idStabile.Value, false);
preventivo.IdStabile = palazzina.ID;
preventivo.DescrizioneStabile = palazzina.Descrizione;
}
// --------------------------------------------------------------------------------
// Scala
// --------------------------------------------------------------------------------
if (idScala != null)
{
var scala = _daoFactory.GetGruppoStabileDao().GetById(idScala.Value, false);
preventivo.IdGruppoStabile = scala.ID;
preventivo.DescrizioneGruppoStabile = scala.Descrizione;
preventivo.IdStabile = scala.PalazzinaRiferimento.ID;
preventivo.DescrizioneStabile = scala.PalazzinaRiferimento.Descrizione;
}
// --------------------------------------------------------------------------------
// Aggiungo i dettagli se il conto è di spese personali
// --------------------------------------------------------------------------------
preventivo.DettaglioUnita = new List<CalcoloUnitaBilancioPreventivoDTO>();
if (conto.IsSpesePersonali)
{
IList<ImportiDTO> importi = new List<ImportiDTO>();
if (esercizio.GetEsercizioPrecedente() != null)
importi = _daoFactory.GetSpeseUnitaDao().GetTotaleSpeseByConto(conto.ID, esercizio.GetEsercizioPrecedente());
addPreventivoPerUnita(preventivo, esercizio, importi);
}
preventivoCalcolato.Add(preventivo);
}
catch (Exception ex)
{
_log.Error("Errore inaspettato durante la creazione della lista per l'inserimento dei valori di preventivo - Calcolo per sottoconto - Righe SottoConto - " + Utility.GetMethodDescription() + " - idEsercizio: " + idEsercizio + " - SottoConto:" + sottoConto.ID, ex);
throw;
}
}
}
// ====================================================
// Calcolo per Conto
// ====================================================
else
{
try
{
var preventivo = new CalcoloBilancioPreventivoDTO
{
IdConto = conto.ID,
Codice = conto.Codice,
Descrizione = conto.Descrizione,
OrdineConto = conto.Ordine
};
if (preventivoBilancio != null || consuntivo != null)
{
// Consuntivo anno precedente
if (consuntivo != null)
preventivo.ImportoConsuntivo = getImportoConsuntivo(conto.ID, 0, consuntivo, dettaglioSottoConto);
// Preventivo anno precedente
if (preventivoBilancio != null)
preventivo.ImportoPreventivoAnnoPrecedente = getImportoConsuntivo(conto.ID, 0, preventivoBilancio, dettaglioSottoConto);
// Preventivo attuale proposto
if (variazione != null)
{
if (riferimentoVariazione == TipoRendiconto.Consuntivo && preventivo.ImportoConsuntivo != null)
preventivo.ImportoPreventivo = preventivo.ImportoConsuntivo + ((preventivo.ImportoConsuntivo * variazione) / 100);
else if (riferimentoVariazione == TipoRendiconto.Preventivo && preventivo.ImportoPreventivoAnnoPrecedente != null)
preventivo.ImportoPreventivo = preventivo.ImportoPreventivoAnnoPrecedente + ((preventivo.ImportoPreventivoAnnoPrecedente * variazione) / 100);
}
}
// --------------------------------------------------------------------------------
// Stabile
// --------------------------------------------------------------------------------
if (idStabile != null)
{
var palazzina = _daoFactory.GetPalazzinaDao().GetById(idStabile.Value, false);
preventivo.IdStabile = palazzina.ID;
preventivo.DescrizioneStabile = palazzina.Descrizione;
}
// --------------------------------------------------------------------------------
// Scala
// --------------------------------------------------------------------------------
if (idScala != null)
{
var scala = _daoFactory.GetGruppoStabileDao().GetById(idScala.Value, false);
preventivo.IdGruppoStabile = scala.ID;
preventivo.DescrizioneGruppoStabile = scala.Descrizione;
preventivo.IdStabile = scala.PalazzinaRiferimento.ID;
preventivo.DescrizioneStabile = scala.PalazzinaRiferimento.Descrizione;
}
// --------------------------------------------------------------------------------
// Aggiungo i dettagli se il conto è di spese personali
// --------------------------------------------------------------------------------
preventivo.DettaglioUnita = new List<CalcoloUnitaBilancioPreventivoDTO>();
if (conto.IsSpesePersonali)
{
IList<ImportiDTO> importi = new List<ImportiDTO>();
if (esercizio.GetEsercizioPrecedente() != null)
importi = _daoFactory.GetSpeseUnitaDao().GetTotaleSpeseByConto(conto.ID, esercizio.GetEsercizioPrecedente());
addPreventivoPerUnita(preventivo, esercizio, importi);
}
preventivoCalcolato.Add(preventivo);
}
catch (Exception ex)
{
_log.Error("Errore inaspettato durante la creazione della lista per l'inserimento dei valori di preventivo - Calcolo per Conto - " + Utility.GetMethodDescription() + " - idEsercizio: " + idEsercizio, ex);
throw;
}
}
}
var bilancioPreventivo = new BilancioPreventivoDTO
{
ID = 0,
CalcoloPerSottoconto = dettaglioSottoConto,
IdEsercizio = esercizio.ID,
DescrizioneEsercizio = esercizio.DisplayName,
Dettaglio = preventivoCalcolato.OrderBy(item => item.OrdineConto).ToList(),
StatoRendiconto = StatoRendicontoEnum.Provvisorio
};
return bilancioPreventivo;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la creazione della lista per l'inserimento dei valori di preventivo - {0} - idEsercizio:{1}", ex, Utility.GetMethodDescription(), idEsercizio);
throw;
}
}
private void addPreventivoPerUnita(CalcoloBilancioPreventivoDTO preventivo, Esercizio esercizio, IList<ImportiDTO> importi)
{
var listaUnita = _daoFactory.GetUnitaImmobiliareDao().GetByCondominio(esercizio.CondominioRiferimento.ID);
foreach (var unita in listaUnita)
{
try
{
if (preventivo.DettaglioUnita.All(item => item.IdUnita != unita.ID))
{
var calcoloUnita = new CalcoloUnitaBilancioPreventivoDTO
{
Descrizione = unita.Descrizione,
IdTestata = preventivo.ID,
IdUnita = unita.ID,
Ordine = unita.Ordine.GetValueOrDefault()
};
if (esercizio.GetEsercizioPrecedente() != null && importi != null)
{
// Consuntivo anno precedente
var unita1 = unita;
var importoDTO = (importi.Where(importo => importo.Id == unita1.ID)).SingleOrDefault();
if (importoDTO != null)
calcoloUnita.ImportoConsuntivo = importoDTO.Importo;
// Per ora evito di proporre un importo in base al consuntivo o preventivo dell'anno precedente
//// Preventivo attuale proposto
//if (variazione != null)
//{
// if (riferimentoVariazione == TipoRendiconto.Consuntivo && calcoloUnita.ImportoConsuntivo != null)
// calcoloUnita.ImportoPreventivo = calcoloUnita.ImportoConsuntivo + ((calcoloUnita.ImportoConsuntivo * variazione) / 100);
// else if (riferimentoVariazione == TipoRendiconto.Preventivo && calcoloUnita.ImportoPreventivoAnnoPrecedente != null)
// calcoloUnita.ImportoPreventivo = calcoloUnita.ImportoPreventivoAnnoPrecedente + ((calcoloUnita.ImportoPreventivoAnnoPrecedente * variazione) / 100);
//}
}
preventivo.DettaglioUnita.Add(calcoloUnita);
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la creazione della lista per l'inserimento dei valori di preventivo - CALCOLO PREVENTIVO PER SOTTOCONTO - SPESE PERSONALI - {0} - idEsercizio:{1} - conto:{2} - sottoconto:{3}", ex, Utility.GetMethodDescription(), esercizio.ID, preventivo.IdConto, preventivo.IdSottoConto);
throw;
}
}
}
public BilancioPreventivoDTO GetPreventivo(int idEsercizio, int? idStabile, int? idScala, bool importiEsercizioPrecedente)
{
try
{
// ===================================================================================
// Domain Model
// ===================================================================================
var esercizio = _daoFactory.GetEsercizioDao().GetById(idEsercizio, false);
IList<ReportBilancioDTO> consuntivo = null;
IList<ReportBilancioDTO> preventivoBilancio = null;
if (esercizio.GetEsercizioPrecedente() != null && importiEsercizioPrecedente)
{
// PER evitare timeout per ora non facciamo calcoli su preventivo o consuntivo dell'anno precedente
consuntivo = GetDataSourceBilancioConsuntivo_SottoConto(esercizio.GetEsercizioPrecedente().ID, null, null, null, null, false, false).ToList();
preventivoBilancio = GetDataSourceBilancioPreventivo_SottoConto(esercizio.GetEsercizioPrecedente().ID, idStabile, idScala, false, false, false, false);
}
var rendiconto = getRendicontoPreventivoCorrente(idEsercizio);
if(rendiconto == null)
{
_log.ErrorFormat("Rendiconto a NULL - {0} - esercizio:{1}", Utility.GetMethodDescription(), idEsercizio);
return null;
}
var bilancio = new BilancioPreventivoDTO
{
ID = rendiconto.ID,
CalcoloPerSottoconto = rendiconto.CalcoloPerSottoconto,
DescrizioneEsercizio = rendiconto.Esercizio.DisplayName,
IdEsercizio = rendiconto.Esercizio.ID,
Note = rendiconto.Note,
StatoRendiconto = rendiconto.Stato
};
if (rendiconto.Documento != null)
bilancio.IdDocumento = rendiconto.Documento.ID;
var preventivoCalcolato = new List<CalcoloBilancioPreventivoDTO>();
// =======================================================================================
// Dettaglio Preventivo
// =======================================================================================
const string hql = "FROM RendicontoAnnualeConto RAC WHERE RAC.Rendiconto = :rendiconto";
var parameters = new List<QueryParam>(3) {new QueryParam("rendiconto", rendiconto)};
var conti = _daoFactory.GetRendicontoAnnualeContoDao().GetByQuery(hql, parameters.ToArray());
// ========================================================
// Elaboro tutte le righe di rendiconto già presenti
// ========================================================
foreach (var conto in conti)
{
if ((conto.ContoRiferimento == null || conto.ContoRiferimento.Deleted != "Y") && (conto.SottoContoRiferimento == null || conto.SottoContoRiferimento.ContoRiferimento.Deleted != "Y"))
{
try
{
var preventivo = new CalcoloBilancioPreventivoDTO {ID = conto.ID};
if (conto.ContoRiferimento != null)
preventivo.OrdineConto = conto.ContoRiferimento.Ordine;
else if (conto.SottoContoRiferimento != null)
preventivo.OrdineConto = conto.SottoContoRiferimento.ContoRiferimento.Ordine;
if (conto.ContoRiferimento != null)
{
preventivo.IdConto = conto.ContoRiferimento.ID;
preventivo.Codice = conto.ContoRiferimento.Codice;
preventivo.Descrizione = conto.ContoRiferimento.Descrizione;
}
else
{
preventivo.IdConto = conto.SottoContoRiferimento.ContoRiferimento.ID;
preventivo.IdSottoConto = conto.SottoContoRiferimento.ID;
preventivo.Codice = conto.SottoContoRiferimento.Codice;
preventivo.Descrizione = conto.SottoContoRiferimento.GetDescrizione(esercizio, null, null);
}
preventivo.ImportoPreventivo = conto.Importo;
if (consuntivo != null)
{
var idConto = 0;
var idSottoConto = 0;
var dettaglioSottoConto = false;
if (preventivo.IdSottoConto > 0)
idSottoConto = preventivo.IdSottoConto;
else
{
idConto = preventivo.IdConto;
dettaglioSottoConto = true;
}
preventivo.ImportoConsuntivo = getImportoConsuntivo(idConto, idSottoConto, consuntivo, dettaglioSottoConto);
}
if (preventivoBilancio != null)
{
var idConto = 0;
var idSottoconto = 0;
if (conto.ContoRiferimento != null)
idConto = conto.ContoRiferimento.ID;
if (conto.SottoContoRiferimento != null)
idSottoconto = conto.SottoContoRiferimento.ID;
preventivo.ImportoPreventivoAnnoPrecedente = getImportoConsuntivo(idConto, idSottoconto, preventivoBilancio, false);
}
// --------------------------------------------------------------------
// Stabile
// --------------------------------------------------------------------
if (conto.Stabile != null)
{
preventivo.IdStabile = conto.Stabile.ID;
preventivo.DescrizioneStabile = conto.Stabile.Descrizione;
}
// --------------------------------------------------------------------
// Gruppo Stabile (Scala)
// --------------------------------------------------------------------
if (conto.GruppoStabile != null)
{
preventivo.IdGruppoStabile = conto.GruppoStabile.ID;
preventivo.DescrizioneGruppoStabile = conto.GruppoStabile.Descrizione;
preventivo.IdStabile = conto.GruppoStabile.PalazzinaRiferimento.ID;
preventivo.DescrizioneStabile = conto.GruppoStabile.PalazzinaRiferimento.Descrizione;
}
// Eventuali dettagli per unita
// -----------------------------
preventivo.DettaglioUnita = new List<CalcoloUnitaBilancioPreventivoDTO>(conto.DettagliUnita.Count);
if (conto.DettagliUnita.Count > 0)
{
int? idConto = null;
int? idSottoConto = null;
if (conto.ContoRiferimento != null)
idConto = conto.ContoRiferimento.ID;
else if (conto.SottoContoRiferimento != null)
{
idSottoConto = conto.SottoContoRiferimento.ID;
idConto = conto.SottoContoRiferimento.ContoRiferimento.ID;
}
var rendiconti = _daoFactory.GetRendicontoAnnualeUnitaDao().GetByConto(rendiconto, idConto, idSottoConto);
IList<ImportiDTO> importi = new List<ImportiDTO>();
if (esercizio.GetEsercizioPrecedente() != null)
importi = _daoFactory.GetSpeseUnitaDao().GetTotaleSpeseByConto(idConto.GetValueOrDefault(), esercizio.GetEsercizioPrecedente());
foreach (var dettaglio in conto.DettagliUnita)
{
try
{
var unita = new CalcoloUnitaBilancioPreventivoDTO
{
ID = dettaglio.ID,
IdTestata = preventivo.ID,
IdUnita = dettaglio.Unita.ID,
Ordine = dettaglio.Unita.Ordine.GetValueOrDefault(),
ImportoPreventivo = dettaglio.Importo,
Descrizione = dettaglio.Unita.Descrizione
};
// --------------------------------------------------------------------
// Importi consuntivo e preventivo anno precedente
// --------------------------------------------------------------------
var rendicontoUnita = (from rend in rendiconti
where rend.Unita.ID == unita.IdUnita
select rend).SingleOrDefault();
if (rendicontoUnita != null)
unita.ImportoPreventivo = rendicontoUnita.Importo;
var importoDTO = (from importo in importi
where importo.Id == unita.IdUnita
select importo).SingleOrDefault();
if (importoDTO != null)
unita.ImportoConsuntivo = importoDTO.Importo;
preventivo.DettaglioUnita.Add(unita);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante il recupero del Preventivo - Elaborazione righe rendiconto già presenti - Dettagli per Unità Immobiliare - {0} - esercizio:{1} - conto:{2} - dettaglio:{3}", ex, Utility.GetMethodDescription(), idEsercizio, conto.ID, dettaglio.ID);
throw;
}
}
// Eventuali dettagli per unità non presenti
addPreventivoPerUnita(preventivo, esercizio, importi);
}
preventivoCalcolato.Add(preventivo);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante il recupero del Preventivo - Elaborazione righe rendiconto già presenti - {0} - esercizio:{1} - conto:{2}", ex, Utility.GetMethodDescription(), idEsercizio, conto.ID);
throw;
}
}
}
// ========================================================
// Aggiungo righe per Stabile
// ========================================================
if (idStabile != null && idScala == null)
{
var contiStabili = from item in conti
where item.Stabile != null && item.Stabile.ID == idStabile.GetValueOrDefault()
select item;
if (contiStabili != null && !contiStabili.Any())
preventivoCalcolato.AddRange(CalcolaPreventivo(idEsercizio, idStabile, idScala, rendiconto.Tipo, null, rendiconto.CalcoloPerSottoconto, false, importiEsercizioPrecedente).Dettaglio);
}
// ========================================================
// Aggiungo righe per Scala
// ========================================================
if (idScala != null)
{
var contiScale = from item in conti
where item.GruppoStabile != null && item.GruppoStabile.ID == idScala.GetValueOrDefault()
select item;
if (contiScale != null && !contiScale.Any())
{
preventivoCalcolato.AddRange(CalcolaPreventivo(idEsercizio, idStabile, idScala, rendiconto.Tipo, null, rendiconto.CalcoloPerSottoconto, false, importiEsercizioPrecedente).Dettaglio);
}
}
// ========================================================
// Aggiungo eventuali conti sottoconti non presenti
// ========================================================
IList<CalcoloBilancioPreventivoDTO> contiAll = CalcolaPreventivo(idEsercizio, idStabile, idScala, rendiconto.Tipo, null, rendiconto.CalcoloPerSottoconto, false, importiEsercizioPrecedente).Dettaglio;
foreach (var contoItem in contiAll)
{
var item1 = contoItem;
var itemFound = from item in preventivoCalcolato
where item.IdConto == item1.IdConto && item.IdSottoConto == item1.IdSottoConto &&
item.IdGruppoStabile == item1.IdGruppoStabile && item.IdStabile == item1.IdStabile
select item;
if (!itemFound.Any())
{
contoItem.IdGruppoStabile = idScala;
contoItem.IdStabile = idStabile;
preventivoCalcolato.Add(contoItem);
}
}
bilancio.Dettaglio = preventivoCalcolato.OrderBy(item => item.OrdineConto).ToList();
return bilancio;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante il recupero del Preventivo - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), idEsercizio);
throw;
}
}
