private void btnCalcolaClick(object sender, EventArgs e) { string message = getBilancioService().IsAllowNewPreventivo(_esercizio.ID); if (string.IsNullOrEmpty(message)) { provvisorioDefinitivo.Value = "P"; provvisorioDefinitivo.Enabled = false; var form = new ExecuteLoadDataObjectAsync<ResultBilancioPreventivo>("E' in corso il calcolo del bilancio preventivo ....." + Environment.NewLine + "Si prega di attendere."); Func<ResultBilancioPreventivo> loadDati = () => getBilancioService().CalcolaPreventivo((int)esercizi.Value, (int?)stabili.Value, (int?)gruppi.Value, (TipoRendiconto)Enum.Parse(typeof(TipoRendiconto), variazionePreventivoConsuntivo.Value.ToString()), Convert.ToDecimal(variazionePercentuale.Value), livelloContoSottoconto.Value.ToString() == "S", chkPreventivoEsercizioPrecedente.Checked, importiEsercizioPrecedente.Checked); form.LoadData(loadDati); form.ShowDialog(); if (form.DataSourceObject.Bilancio != null) { _bilancioPreventivo = form.DataSourceObject.Bilancio; form.Dispose(); calcoloBilancioPreventivoDTOBindingSource.DataSource = _bilancioPreventivo.Dettaglio; if (calcoloBilancioPreventivoDTOBindingSource.DataSource != null) { if (lista.DisplayLayout.Bands[0].Summaries.Count == 0) { DataGridHelper.AddSummary(lista.DisplayLayout.Bands[0], "ImportoPreventivoAnnoPrecedente", "c"); DataGridHelper.AddSummary(lista.DisplayLayout.Bands[0], "ImportoConsuntivo", "c"); DataGridHelper.AddSummary(lista.DisplayLayout.Bands[0], "ImportoPreventivo", "c"); } if (lista.DisplayLayout.Bands[1].Summaries.Count == 0) { DataGridHelper.AddSummary(lista.DisplayLayout.Bands[1], "ImportoPreventivoAnnoPrecedente", "c"); DataGridHelper.AddSummary(lista.DisplayLayout.Bands[1], "ImportoConsuntivo", "c"); DataGridHelper.AddSummary(lista.DisplayLayout.Bands[1], "ImportoPreventivo", "c"); } lista.Visible = true; btnConferma.Visible = true; lista.UpdateData(); lista.PerformAction(UltraGridAction.ExitEditMode); } else CommonMessages.DisplayWarning("Non è possibile aprire il bilancio preventivo, verificare la correttezza del piano dei conti."); } else { if (!string.IsNullOrEmpty(form.DataSourceObject.Message)) { CommonMessages.DisplayWarning(string.Format("Non è possibile aprire il bilancio preventivo:{0}{1}", Environment.NewLine, form.DataSourceObject.Message)); } } } else CommonMessages.DisplayWarning("Non è ammessa la creazione di un nuovo bilancio preventivo:" + Environment.NewLine + Environment.NewLine + message); }
private void load() { btnConferma.Visible = false; if (esercizi.Value != null) { // ------------------------------------------------------------------------------- // Preventivo già aperto propongo l'apertura per eventuali modifiche ..... // ------------------------------------------------------------------------------- if (getBilancioService().IsOpen((int)esercizi.Value) == ControlEnableEnum.True) { var form = new ExecuteLoadDataObjectAsync<ResultBilancioPreventivo>("E' in corso il caricamento del bilancio preventivo ....." + Environment.NewLine + "Si prega di attendere."); Func<ResultBilancioPreventivo> loadDati = () => getBilancioService().GetPreventivo((int)esercizi.Value, (int?)stabili.Value, (int?)gruppi.Value, importiEsercizioPrecedente.Checked); form.LoadData(loadDati); form.ShowDialog(); if (form.DataSourceObject.Bilancio != null) { _bilancioPreventivo = form.DataSourceObject.Bilancio; form.Dispose(); if (_bilancioPreventivo != null) { calcoloBilancioPreventivoDTOBindingSource.DataSource = _bilancioPreventivo.Dettaglio; livelloContoSottoconto.Value = _bilancioPreventivo.CalcoloPerSottoconto ? "S" : "C"; if (lista.DisplayLayout.Bands[0].Summaries.Count == 0) { DataGridHelper.AddSummary(lista.DisplayLayout.Bands[0], "ImportoPreventivoAnnoPrecedente", "c"); DataGridHelper.AddSummary(lista.DisplayLayout.Bands[0], "ImportoConsuntivo", "c"); DataGridHelper.AddSummary(lista.DisplayLayout.Bands[0], "ImportoPreventivo", "c"); } if (lista.DisplayLayout.Bands[1].Summaries.Count == 0) { DataGridHelper.AddSummary(lista.DisplayLayout.Bands[1], "ImportoPreventivoAnnoPrecedente", "c"); DataGridHelper.AddSummary(lista.DisplayLayout.Bands[1], "ImportoConsuntivo", "c"); DataGridHelper.AddSummary(lista.DisplayLayout.Bands[1], "ImportoPreventivo", "c"); } lista.Visible = true; btnConferma.Visible = true; if (_bilancioPreventivo.StatoRendiconto == StatoRendicontoEnum.Definitivo) { provvisorioDefinitivo.Value = "D"; provvisorioDefinitivo.Enabled = false; lista.DisplayLayout.Override.AllowUpdate = DefaultableBoolean.False; lista.DisplayLayout.Override.AllowAddNew = AllowAddNew.No; } else { provvisorioDefinitivo.Value = "P"; provvisorioDefinitivo.Enabled = true; lista.DisplayLayout.Override.AllowUpdate = DefaultableBoolean.True; lista.DisplayLayout.Override.AllowAddNew = AllowAddNew.Default; } } else { _log.ErrorFormat("Errore imprevisto nell'apertura del bilancio preventivo - {0} - condominio:{1} - esercizio:{2} - azienda:{2}", Utility.GetMethodDescription(), _condominio != null ? _condominio.ID.ToString() : "<NULL>", _esercizio != null ? _esercizio.ID.ToString() : "<NULL>"); if (ParentForm != null) ParentForm.Close(); return; } } else { if (!string.IsNullOrEmpty(form.DataSourceObject.Message)) { CommonMessages.DisplayWarning(string.Format("Non è possibile aprire il bilancio preventivo:{0}{1}", Environment.NewLine, form.DataSourceObject.Message)); } } } // ------------------------------------------------------------------------------------------------- // .... altrimenti verifico se è ammessa l'apertura da Preventivo o Consuntivo dell'anno precedente // ------------------------------------------------------------------------------------------------- else if (!getBilancioService().IsAllowCalcoloPreventivoDaConsuntivo((int)esercizi.Value)) { manuale.Value = true; manuale.Enabled = false; variazionePreventivoConsuntivo.Enabled = false; variazionePercentuale.Enabled = false; btnCalcolaClick(this, EventArgs.Empty); } else { manuale.Enabled = true; variazionePreventivoConsuntivo.Enabled = true; } _enableProvvisorioDefinitivo = getBilancioService().IsAllowPreventivoDefinitivo(_esercizio.ID); if (_enableProvvisorioDefinitivo == ControlEnableEnum.True || _enableProvvisorioDefinitivo == ControlEnableEnum.Confirm) { provvisorioDefinitivo.Enabled = true; opzioniGroup.Visible = true; if(lista.DisplayLayout != null) lista.DisplayLayout.Override.AllowUpdate = DefaultableBoolean.True; } else { provvisorioDefinitivo.Value = "D"; provvisorioDefinitivo.Enabled = false; opzioniGroup.Visible = false; btnConferma.Visible = false; if (lista.DisplayLayout != null) lista.DisplayLayout.Override.AllowUpdate = DefaultableBoolean.False; } panelPiede.Visible = true; lista.UpdateData(); lista.PerformAction(UltraGridAction.ExitEditMode); filtroSelezionatiCheckedChanged(null, EventArgs.Empty); } }
public string SetRendicontoPreventivo(int idEsercizio, int? idStabile, int? idScala, BilancioPreventivoDTO preventivo, StatoRendicontoEnum stato, bool dettaglioSottoConto) { var result = GetServiceClient().SetRendicontoPreventivo(idEsercizio, idStabile, idScala, preventivo, stato, dettaglioSottoConto, GetUserInfo()); CloseService(); return result; }
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; } }
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; } }
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; } }
public string SetRendicontoPreventivo(int idEsercizio, int? idStabile, int? idScala, BilancioPreventivoDTO bilancioPreventivo, StatoRendicontoEnum stato, bool dettaglioSottoConto, UserInfo userinfo) { var retryCount = 10; var success = false; var windsorRep = new WindsorConfigRepository(); string item = null; while (retryCount >= 0 && !success) { try { windsorRep.BeginTransaction(userinfo); var bilancioService = windsorRep.GetContainer(userinfo.Azienda).Resolve<IBilancioService>(); item = bilancioService.SetRendicontoPreventivo(idEsercizio, idStabile, idScala, bilancioPreventivo, stato, dettaglioSottoConto); windsorRep.Commit(); success = true; } catch (Exception ex) { _log.ErrorFormat("Errore nella esecuzione della funzione - TENTATIVO:{0} - {1} - esercizio:{2} - stabile:{3} - scala:{4} - dettaglioSottoConto:{5} - stato:{6} - azienda:{7} - number:{8}", ex, (11 - retryCount), Utility.GetMethodDescription(), idEsercizio, idStabile, idScala, dettaglioSottoConto, stato, userinfo.Azienda, getExceptionId(ex)); windsorRep.Rollback(); if (!isRetryException(ex)) throw; // Add delay here if you wish. System.Threading.Thread.Sleep(1000 * (11 - retryCount)); retryCount--; _log.InfoFormat("Set rendiconto preventivo - INIZIO TENTATIVO:{0} - {1} - esercizio:{2} - stabile:{3} - scala:{4} - dettaglioSottoConto:{5} - stato:{6} - azienda:{7}", (11 - retryCount), Utility.GetMethodDescription(), idEsercizio, idStabile, idScala, dettaglioSottoConto, stato, userinfo.Azienda); } } if (!success) windsorRep.Rollback(); return item; }