private ChiusuraEsercizioStraordinarioInfo getChiusuraEsercizioStraordinarioInfo(SceltaEsercizioSaldiUI form)
        {
            var result = new ChiusuraEsercizioStraordinarioInfo
            {
                TipoChiusura = getTipoChiusuraEsercizioStraordinario()
            };

            if (form != null)
            {
                result.DataApertura = form.DataApertura;
                result.DataChiusura = form.DataChiusura;
                result.Descrizione = form.DescrizioneEsercizio;
                result.IdEsercizioSaldi = form.IdEsercizioSaldi;
            }

            return result;
        }
        private void btnConfermaClick(object sender, EventArgs e)
        {
            try
            {
                dataRegistrazioneValidator1.Enable = esercizioSaldi.Enabled;

                validationSummary1.Validate();
                if (validationSummary1.IsValid)
                {
                    if (CommonMessages.DisplayConfirm("Sei sicuro di voler chiudere l'esercizio?" + Environment.NewLine + "L'esercizio chiuso sarà disponibile solo in modalità di consultazione.") == DialogResult.Yes)
                    {
                        int? idEsercizioSaldi = null;
                        if (esercizioSaldi.SelectedItem != null)
                        {
                            var esercizio = esercizioSaldi.SelectedItem.ListObject as EsercizioDTO;
                            if (esercizio != null)
                                idEsercizioSaldi = esercizio.ID;
                        }

                        var messageAuth = getEsercizioService().IsAllowChiusura(_esercizio, null, (DateTime?)dataChiusuraEsercizio.Value, forzaChiusuraSenzaNuovo.Checked, idEsercizioSaldi, getChiusuraEsercizioStraordinarioInfo(null).TipoChiusura);
                        if (string.IsNullOrEmpty(messageAuth.FatalMessage))
                        {
                            var result = DialogResult.Yes;
                            if (!string.IsNullOrEmpty(messageAuth.WarnMessage))
                                result = CommonMessages.DisplayConfirm("Avvertimenti per la chiusura dell'esercizio:" + Environment.NewLine + messageAuth.WarnMessage + Environment.NewLine + "Vuoi confermare la chiusura dell'esercizio?");

                            if (result == DialogResult.Yes)
                            {
                                var resultForzatura = DialogResult.OK;
                                if (forzaChiusuraSenzaNuovo.Checked)
                                {
                                    var messageinfo = new UltraMessageBoxInfo
                                    {
                                        Caption = "Chiusura Esercizio",
                                        Header = "Richiesta conferma forzatura senza esercizio nuovo",
                                        TextFormatted = "ATTENZIONE: E' stata richiesta la forzatura della chiusura dell'esercizio<br /><b>senza che sia presente un esercizio nuovo</b><br /><br />Sei sicuro di voler continuare?",
                                        Buttons = MessageBoxButtons.OKCancel,
                                        Icon = MessageBoxIcon.Warning,
                                        FooterFormatted = "Non verrà eseguita <b>nessuna registrazione</b> di operazione contabili di chiusura o apertura"
                                    };

                                    resultForzatura = messaggioChiusuraEsercizio.ShowMessageBox(messageinfo);
                                }

                                if (resultForzatura == DialogResult.OK)
                                {
                                    EsercizioDTO esercizioAperto = null;
                                    var resultChiusura = string.Empty;
                                    if (_esercizio.Gestione == GestioneEsercizioEnum.Ordinario)
                                    {
                                        try
                                        {
                                            var form = new ExecuteLoadDataObjectAsync<string>("E' in corso di esecuzione la chiusura dell'esercizio ....." + Environment.NewLine + "Si prega di attendere.");
                                            Func<string> loadDati = () => getEsercizioService().Chiusura(_esercizio, _condominio, dataChiusuraEsercizio.DateTime, forzaChiusuraSenzaNuovo.Checked, storicizzaRiparto.Checked, note.Text);
                                            form.LoadData(loadDati);
                                            form.ShowDialog();

                                            try
                                            {
                                                resultChiusura = form.DataSourceObject;
                                            }
                                            catch (Exception ex)
                                            {
                                                _log.ErrorFormat("Errore durante la chiusura degli esercizi - IMPOSTAZIONE DATA SOURCE - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), _esercizio.ID);
                                                throw;
                                            }

                                            form.Dispose();
                                        }
                                        catch (Exception ex)
                                        {
                                            _log.ErrorFormat("Errore durante la chiusura degli esercizi - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), _esercizio.ID);
                                            throw;
                                        }
                                    }
                                    else
                                    {
                                        SceltaEsercizioSaldiUI form = null;
                                        var dialogResult = DialogResult.OK;
                                        if (getTipoChiusuraEsercizioStraordinario() == TipoChiusuraEsercizioStraordinarioEnum.NuovoStraordinario)
                                        {
                                            form = new SceltaEsercizioSaldiUI(_esercizio);
                                            dialogResult = form.ShowDialog();
                                        }

                                        if (dialogResult == DialogResult.OK)
                                        {
                                            EsercizioDTO esercizioTrasferimentoSaldi = null;
                                            if (esercizioSaldi.SelectedItem != null)
                                                esercizioTrasferimentoSaldi = (EsercizioDTO)esercizioSaldi.SelectedItem.ListObject;
                                            resultChiusura = getEsercizioService().ChiusuraStraordinario(_esercizio, esercizioTrasferimentoSaldi, getChiusuraEsercizioStraordinarioInfo(form), descrizioneConto.Text, (int)ordineConto.Value, _condominio, dataChiusuraEsercizio.DateTime, note.Text).Message;
                                            if (form != null)
                                                form.Dispose();
                                        }
                                        else if (dialogResult == DialogResult.Cancel)
                                        {
                                            if (form != null)
                                                form.Dispose();
                                            return;
                                        }
                                    }

                                    if (string.IsNullOrEmpty(resultChiusura))
                                    {
                                        try
                                        {
                                            CommonMessages.DisplayComplete("La chiusura dell'esercizio " + _esercizio.DisplayName + " è avvenuta correttamente.");
                                            OnUpdateEsercizi(new UpdateEserciziEventArgs(esercizioAperto));
                                        }
                                        catch (Exception ex)
                                        {
                                            _log.ErrorFormat("Errore durante la chiusura degli esercizi - NOTIFICA UPDATE - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), _esercizio.ID);
                                        }
                                    }
                                    else
                                        CommonMessages.DisplayWarning(resultChiusura);
                                }
                            }
                        }
                        else
                            CommonMessages.DisplayWarning("Non è ammessa la chiusura dell'esercizio:" + Environment.NewLine + messageAuth.FatalMessage);
                    }
                }
                else
                    validationSummary1.ShowErrorSummary();
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore nella chiusura dell'esercizio - {0} - condominio:{1} - esercizio:{2} - azienda:{3}", ex, _condominio != null ? _condominio.ID.ToString(CultureInfo.InvariantCulture) : "<NULL>", _esercizio != null ? _esercizio.ID.ToString(CultureInfo.InvariantCulture) : "<NULL>", Utility.GetMethodDescription(), Security.Login.Instance.CurrentLogin().Azienda);                
                CommonMessages.DisplayWarning(string.Format("Si sono verificati dei problemi nella chiusura dell'esercizio.{0}Si prega di riprovare", Environment.NewLine));
                if(ParentForm != null)
                    ParentForm.Close();
            }
        }