public AnteprimaReportRiparto(IList<ReportRipartizioneBilancioDTO> dataSource, CondominioDTO condominio, EsercizioDTO esercizio, BilancioConsuntivoReportParameters parameters, ImpostazioneReportDTO impostazioneReportDTO)
        {
            InitializeComponent();
            _dataSource = dataSource;
            _condominio = condominio;
            _esercizio = esercizio;
            _parameters = parameters;
            _impostazioneReportDTO = impostazioneReportDTO;

            Text = $"Riparto {_impostazioneReportDTO.Descrizione}";

            try
            {
                _importoTotale = getBilancioService().GetTotale(dataSource.ToList());
                _importoPreventivo = getBilancioService().GetTotalePreventivo(dataSource.ToList());

                IReportProvider document;
                if(_impostazioneReportDTO.MultiPageOrdered)
                    document = new RipartoMerge(dataSource, _condominio, _esercizio, _parameters, _impostazioneReportDTO, _importoTotale, _importoPreventivo);
                else
                    document = new RipartoSubreport(dataSource, _condominio, _esercizio, _parameters, _impostazioneReportDTO, _importoTotale, _importoPreventivo);
                
                SetDataSource(document.GetReport(), _impostazioneReportDTO);
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore nell'apertura della maschera di anteprima per riparto - {0} - condominio:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), _condominio?.ID.ToString(CultureInfo.InvariantCulture) ?? "<NULL>", Login.Instance.CurrentLogin().Azienda);
                Close();
            }
        }

        private void loadReportBilancio(IList<ReportBilancioDTO> bilancioDataSource, CondominioDTO condominioDTO, EsercizioDTO esercizioDTO)
        {
            var importoTotale = 0m;

            reportViewer1.LocalReport.ReportEmbeddedResource = _reportParameters.TipoDettaglio == TipoDettaglioReportBilancio.Movimenti ? "Gipasoft.Stabili.UI.Bilanci.Reports.BilancioConsuntivo_Movimenti.rdlc" : "Gipasoft.Stabili.UI.Bilanci.Reports.BilancioConsuntivo_SottoConti.rdlc";
            reportViewer1.LocalReport.DataSources.Add(new ReportDataSource("ReportBilancioDTO", _bilancioService.CloneReportBilancioDataSource(bilancioDataSource)));

            if (_bilancioDataSource != null)
            {
                _reportParameters.TotaleVersamenti = _reportParameters.TotaleVersamenti*-1;
                importoTotale = bilancioDataSource.Sum(item => item.ImportoSottoConto) + bilancioDataSource.Sum(item => item.ImportoMovimento);
                if (Login.Instance.CurrentLogin().InversioneSaldiCondomini)
                {
                    importoTotale = importoTotale * -1;
                    _reportParameters.TotaleVersamenti = _reportParameters.TotaleVersamenti*-1;
                }
                
                importoTotale += _reportParameters.TotaleVersamenti;
                importoTotale += _reportParameters.SaldoPrecedente;
            }

            getReportParameters(importoTotale, condominioDTO, esercizioDTO);

            reportViewer1.LocalReport.SetParameters(getReportParameters(importoTotale, condominioDTO, esercizioDTO));
            reportViewer1.RefreshReport();
        }

        public AnteprimaReportRipartoPersona(IList<ReportRipartizioneBilancioDTO> dataSource, CondominioDTO condominio, EsercizioDTO esercizio, IList<PersonaContattoDTO> personeRiparto, Dictionary<int, IList<IList<UnitaImmobiliareListaDTO>>> listaUnitaImmobiliare, BilancioConsuntivoReportParameters parameters, ImpostazioneReportDTO impostazioneReportDTO, string reportKey, string note)
        {
            InitializeComponent();
            _dataSource = dataSource;
            _condominio = condominio;
            _esercizio = esercizio;
            _parameters = parameters;
            _personeRiparto = personeRiparto;
            _impostazioneReportDTO = impostazioneReportDTO;
            _note = note;

            Text = $"Riparto {_impostazioneReportDTO.Descrizione}";

            try
            {
                _importoTotale = getBilancioService().GetTotale(dataSource.ToList());
                _importoPreventivo = getBilancioService().GetTotalePreventivo(dataSource.ToList());

                IReportProvider document = new RipartoAnnualePersona(dataSource, _condominio, _esercizio, personeRiparto, listaUnitaImmobiliare, _parameters, _impostazioneReportDTO, reportKey, _note);
                SetDataSource(document.GetReport(), _impostazioneReportDTO);
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore nell'apertura della maschera di anteprima per riparto - {0} - condominio:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), _condominio?.ID.ToString(CultureInfo.InvariantCulture) ?? "<NULL>", Login.Instance.CurrentLogin().Azienda);
                throw;
            }
        }

        public ChiusuraEsercizioContabileUC(CondominioDTO condominio, EsercizioDTO esercizio)
        {
            InitializeComponent();

            _condominio = condominio;
            _esercizio = esercizio;
        }

        public RegistrazioneSpeseAccorpateUI(CondominioDTO condominio, EsercizioDTO esercizo)
        {
            InitializeComponent();

            _condominio = condominio;
            _esercizio = esercizo;
        }

 public void LoadData(CondominioDTO condominio, EsercizioDTO esercizio, decimal importo, ContoDTO contoPatrimoniale, int? idBancaCondominio, int idCondomino, int? idMovimentoBancario, DateTime dataRegistrazione)
 {
     _gestioneVersamenti = new GestioneVersamentiPersonaUC(condominio, esercizio, importo, contoPatrimoniale, idBancaCondominio, idCondomino, idMovimentoBancario, dataRegistrazione);
     MainStandardForm_Fill_Panel.Controls.Add(_gestioneVersamenti);
     _gestioneVersamenti.Dock = DockStyle.Fill;
     _gestioneVersamenti.AfterUpdate += gestioneVersamentiAfterUpdate;
 }

        public AssociaVersamentiRateUC(EsercizioDTO esercizio)
        {
            _esercizio = esercizio;

            InitializeComponent();
            inizializza();
        }

 public Control GetListaControl(CondominioDTO condominio, EsercizioDTO esercizio)
 {
     _condominio = condominio;
     _esercizio = esercizio;
     _listaMovimentiUC =  new ListaMovimentiUC(condominio, esercizio);
     return _listaMovimentiUC;
 }

        public void Reload(CondominioDTO condominio, EsercizioDTO esercizio)
        {
            Dirty = false;
            _condominio = condominio;
            _esercizio = esercizio;

            if (_condominio != null)
            {
                sceltaCondominioCombo1.SelectItem -= sceltaCondominioComboSelectItem;
                sceltaCondominioCombo1.SetCondominioInitial(_condominio.ID);
                sceltaCondominioCombo1.SelectItem += sceltaCondominioComboSelectItem;
            }

            // Conti
            if (_esercizio != null)
            {
                contoBindingSource.DataSource = _pianoContiServiceCache.GetDaMillesimareByCondominio(_esercizio);

                contoOrigineBindingSource.DataSource = _pianoContiServiceCache.GetDaMillesimareByCondominio(_esercizio);
                contoOrigineBindingSource.Insert(0, new ContoDTO { ID = 0, Descrizione = "<Millesimi di Proprietà>", DescrizioneCompleta = "<Millesimi di Proprietà>" });
                contoOrigineBindingSource.Insert(1, new ContoDTO { ID = -1, Descrizione = "<Millesimi di Stabile>", DescrizioneCompleta = "<Millesimi di Stabile>" });
                contoOrigineBindingSource.Insert(2, new ContoDTO { ID = -2, Descrizione = "<Millesimi di Scala>", DescrizioneCompleta = "<Millesimi di Scala>" });

                _millesimi.Clear();
                tableLayoutPanelMillesimi.Visible = false;
                millesimoBindingSource.DataSource = new List<MillesimoDTO>();
            }
            else
            {
                conti.Items.Clear();
                contiOrigine.Items.Clear();
            }
        }

        public MovimentoContabileEconomicoUC(CausaleContabileDTO causale, EsercizioDTO esercizio, ContoDTO conto, int? idContoBancario, DateTime? dataContabile, string descrizione, decimal importo, TipoMovimentoEnum incassoSpesa, int? idMovimentoBancario)
        {
            InitializeComponent();

            _idMovimentoBancario = idMovimentoBancario;
            _causalePreimpostata = true;
            _causale = causale;
            _esercizio = esercizio;
            _conto = conto;
            _idContoBancario = idContoBancario;
            _importo = importo;
            _dataContabile = dataContabile;

            if (_importo > 0)
            {
                importoMovimento.TabStop = false;
                importoCompareValidator.ValueToCompare = _importo.ToString();
                movimentoValidationSummary.Validators.Add(importoCompareValidator);
            }

            inizializza();
            executeNew();
            _confirmByParent = true;
            _tipoMovimento = incassoSpesa;
            ripartizioneDettaglio.DisplayLayout.Bands[0].Override.AllowAddNew = AllowAddNew.TemplateOnBottom;
            descrizioneDettaglio.Text = descrizione;

            sceltaCondominioCombo1.Enabled = false;
        }

        public PianoRatealeSubreport(IList<ReportRataSoggettoDTO> dataSource, CondominioDTO condominio, EsercizioDTO esercizio, PianoRatealeReportParameters parameters, ImpostazioneReportDTO impostazioneReportDTO, decimal importoTotale) : base(condominio, esercizio, null ,null, false, true)
        {
            _impostazioneReportDTO = impostazioneReportDTO;
            base.Inizializza(impostazioneReportDTO, parameters.Note);

            if (impostazioneReportDTO.MultiPage)
            {
                var helper = new PianoRatealeHelper(dataSource, impostazioneReportDTO);
                var columns = helper.GetColumnList(null, null, null, null);
                var pagine = columns.Select(item => item.PrintPage).Distinct().ToList();
                _mergeReports = new List<PianoRatealeSinglePage>(pagine.Count);

                foreach (var i in pagine)
                {
                    var columnsPage = columns.Where(item => item.PrintPage == i).Select(item => item.Order);
                    var dataSourcePage = dataSource.Where(item => (item.NumeroRata == 0 && item.NumeroRata == 0) || columnsPage.Contains(item.NumeroRata)).ToList();
                    var pageReport = new PianoRatealeSinglePage(dataSourcePage, condominio, esercizio, parameters, impostazioneReportDTO, importoTotale, i, true);
                    _mergeReports.Add(pageReport);
                    pageReport.CreateDocument(impostazioneReportDTO);
                }

                _reportMerge = _report;
                _reportMerge.BeforePrint += XtraReportMerged_BeforePrint;
            }
            else
            {
                var riparto = new PianoRatealeSinglePage(dataSource, condominio, esercizio, parameters, impostazioneReportDTO, importoTotale, null, false);
                var report = riparto.GetReport();
                _reportMerge = report;
            }}

        public void Reload(CondominioDTO condominio, EsercizioDTO esercizio)
        {
            _condominio = condominio;
            _esercizio = esercizio;

            load();
        }

 public DettaglioImpostazioneReportUI(ImpostazioneReportDTO impostazioneReport, EsercizioDTO esercizio, string reportKey)
 {
     InitializeComponent();
     _esercizio = esercizio;
     _reportKey = reportKey;
     _impostazioneReportDTO = impostazioneReport;
 }

        public DettaglioBollettaUI(string numeroFattura, DateTime dataFattura, int idFornitore, EsercizioDTO esercizio)
        {
            InitializeComponent();

            if (!DesignMode)
            {
                inizializza();
                _bolletta = _utenzaService.GetBollettaByNumeroDataFattura(numeroFattura, dataFattura, idFornitore);
                if (_bolletta == null)
                {
                    CloseForm();
                }
                else
                {
                    _idBolletta = _bolletta.ID;
                    inizializza();
                    BusinessClass = new[] { (BaseDTOOfint)_bolletta };
                    _esercizio = esercizio;

                    _dettaglioBolletta = new DettaglioBollettaUC(_bolletta, _esercizio) { Dock = DockStyle.Fill };
                    _dettaglioBolletta.AfterAddControl += dettaglioBollettaAfterAddControl;
                    _dettaglioBolletta.LoadComplete += dettaglioBollettaLoadComplete;
                    _dettaglioBolletta.Confirm += dettaglioBollettaConfirmed;
                    _dettaglioBolletta.AfterUpdate += dettaglioBollettaAfterUpdate;
                    MainStandardForm_Fill_Panel.Controls.Add(_dettaglioBolletta);
                }
            }
        }

 public ListaSollecitiUC(CondominioDTO condominio, EsercizioDTO esercizio)
 {
     InitializeComponent();
     _condominio = condominio;
     _esercizio = esercizio;
     inizializza();
 }

        private void load(EsercizioDTO esercizio)
        {
            StabileDTO stabile = null;
            if (stabili.SelectedItem != null)
                stabile = (StabileDTO)stabili.SelectedItem.ListObject;

            GruppoStabileDTO gruppo = null;
            if (gruppi.SelectedItem != null)
                gruppo = (GruppoStabileDTO)gruppi.SelectedItem.ListObject;

            lista.DataSource = ultraDataSource1;

            var form = new ExecuteLoadDataObjectAsync<DataView>("Sono in corso di caricamento i millesimi ....." + Environment.NewLine + "Si prega di attendere.");
            Func<DataView> loadDati = () => _pianoContiService.GetRiepilogoMillesimiPivotByEsercizio(esercizio, stabile, gruppo);
            form.LoadData(loadDati);
            form.ShowDialog();

            lista.DataSource = form.DataSourceObject;
            
            setGridLayout(esercizio);

            lista.Visible = true;
            btnStampa.Visible = true;
            saltoPagina.Visible = true;
            form.Dispose();
        }

 public void Reload(CondominioDTO condominio, EsercizioDTO esercizio)
 {
     _condominio = condominio;
     _esercizio = esercizio;
     sceltaCondominioCombo.SetCondominioInitial(_condominio.ID);
     setDataChiusura();
 }

        public NuovoSubentroUI(CondominioDTO condominio, EsercizioDTO esercizio)
        {
            InitializeComponent();

            _condominio = condominio;
            _esercizio = esercizio;
        }

        public List<ModelloRegistrazioneContabileDTO> GetByEsercizio(EsercizioDTO esercizio)
        {
            try
            {
                if (esercizio != null)
                {
                    if (!_cache.Contains("ModelliContabili_" + esercizio.ID))
                        Reload(esercizio);

                    var cacheModelli = _cache["ModelliContabili_" + esercizio.ID];
                    if(cacheModelli != null)
                        return (List<ModelloRegistrazioneContabileDTO>)cacheModelli;

                    _log.WarnFormat("Cache modelli a NULL - {0} - esercizio:{1} - azienda:{2}", Utility.GetMethodDescription(), esercizio.ID, Login.Instance.CurrentLogin().Azienda);
                }

                return new List<ModelloRegistrazioneContabileDTO>();
            }
            catch (Exception ex)
            {
                var idEsercizio = "<NULL>";
                if (esercizio != null)
                    idEsercizio = esercizio.ID.ToString();

                _log.ErrorFormat("Errore nel caricamento dei modelli per esercizio - {0} - esercizio:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), idEsercizio, Login.Instance.CurrentLogin().Azienda);
                throw;
            }
        }

        public Form GetMovimentiEvasi(int id, CondominioDTO condominio, EsercizioDTO esercizio)
        {
            var service = ResolveComponent<IMovimentoBancarioService>();

            // Caricamento asincrono dei movimenti bancari
            var form = new ExecuteLoadDataListAsync<MovimentiBancariDTO>("E' in corso la ricerca dei movimenti bancari ....." + Environment.NewLine + "Si prega di attendere.");
            Func<List<MovimentiBancariDTO>> loadDati = () => service.GetByFilter(new MovimentoBancarioFilter { IdEvasioneBancaria = id });
            form.LoadData(loadDati);
            form.ShowDialog();

            // Se presente un solo movimento bancario carico direttamente il dettaglio
            if (form.DataSourceObject.Count > 1)
            {
                _formMovimenti = new GestioneMovimentiBancariUI(condominio, esercizio);
                ((GestioneMovimentiBancariUI)_formMovimenti).HideFilterPanel();
                ((GestioneMovimentiBancariUI)_formMovimenti).LoadData(form.DataSourceObject);
            }
            else if(form.DataSourceObject.Count > 0)
            {
                _formMovimenti = new DettaglioMovimentoBancario(form.DataSourceObject[0]);
                ((DettaglioMovimentoBancario)_formMovimenti).LoadData();
            }
            form.Dispose();

            return _formMovimenti;
        }