コード例 #1
0
ファイル: BilancioService.cs プロジェクト: gipasoft/Sfera
        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;
            }
        }
コード例 #2
0
ファイル: BilancioService.cs プロジェクト: gipasoft/Sfera
        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;
                }
            }        
        }
コード例 #3
0
ファイル: BilancioService.cs プロジェクト: gipasoft/Sfera
        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;
            }
        }