private void btnConfermaClick(object sender, EventArgs e)
        {
            var righe = _riepilogoInteressiMora.GetSelectedRows();
            if (righe.Count > 0)
            {
                if (_riepilogoInteressiMora.ValidateCalcolo())
                {
                    var form = new ExecuteLoadDataObjectAsync<string>("Il calcolo degli interessi si mora è in corso di esecuzione ....." + Environment.NewLine + "Si prega di attendere.");
                    Func<string> loadDati = () =>_sollecitiService.ConfermaCalcoloInteresse(_riepilogoInteressiMora.GetEsercizio(), righe, _riepilogoInteressiMora.GetContoAddebitoProprieta(), _riepilogoInteressiMora.GetContoAddebitoConduzione(), _riepilogoInteressiMora.GetContoAccredito(), _riepilogoInteressiMora.GetDescrizioneSpesePersonali(), _riepilogoInteressiMora.GetDescrizioneAccredito(), _riepilogoInteressiMora.GetDataRegistrazione());
                    form.LoadData(loadDati);
                    form.ShowDialog();

                    if (string.IsNullOrEmpty(form.DataSourceObject))
                    {
                        Library.CommonMessages.DisplayComplete("Il calcolo degli interessi di mora è terminato correttamente.");
                        _riepilogoInteressiMora.Clear();                   
                    }
                    else
                        Library.CommonMessages.DisplayWarning("Si sono verificati i seguenti problemi durante il calcolo degli interessi di mora:" + Environment.NewLine + form.DataSourceObject);
                    form.Dispose();
                }
            }
            else
                Library.CommonMessages.DisplayWarning("Selezionare almeno una riga per poter procedere al calcolo.");

        }
Exemple #2
0
        public void Reload(CondominioDTO condominio, EsercizioDTO esercizio)
        {
            _condominio = condominio;

            if (_condominio != null)
            {
                // Caricamento finestrella feedback per il salvataggio
                var form = new ExecuteLoadDataObjectAsync<MatchDataSource>("I movimenti sono in corso di caricamento ....." + Environment.NewLine + "Si prega di attendere.");
                Func<MatchDataSource> loadDati = loadDataSource;
                form.LoadData(loadDati);
                form.ShowDialog();

                movimentoContabileBindingSource.DataSource = form.DataSourceObject.MovimentiContabiliDataSource;
                movimentiBancariDTOBindingSource.DataSource = form.DataSourceObject.MovimentiBancariDataSource;

                // Summary
                if (listaMovimentiContabili.DisplayLayout.Bands[0].Summaries.Count == 0)
                    DataGridHelper.AddSummary(listaMovimentiContabili.DisplayLayout.Bands[0], "Importo", "c");

                if (listaMovimenti.DisplayLayout.Bands[0].Summaries.Count == 0)
                    DataGridHelper.AddSummary(listaMovimenti.DisplayLayout.Bands[0], "Importo", "c");
            
                panelDati.Visible = true;
                form.Dispose();
            }
            else
            {
                movimentiBancariDTOBindingSource.Clear();
                movimentoContabileBindingSource.Clear();
                panelDati.Visible = false;
            }
        }
        private void btnConfermaClick(object sender, EventArgs e)
        {
            validationSummary1.Validate();
            if (validationSummary1.IsValid)
            {
                var form = new ExecuteLoadDataObjectAsync<CondominioDTO>("E' in corso l'importazione del condominio ....." + Environment.NewLine + "Si prega di attendere.");
                Func<CondominioDTO> loadDati = () => getImportazioneService().ImportCondominio(openFileDialog1.FileName, codiceCondominio.Text, new EsercizioDTO {Descrizione = descrizioneEsercizio.Text, DataApertura = dataApertura.DateTime, DataChiusura = dataChiusura.DateTime });
                form.LoadData(loadDati);
                form.ShowDialog();
                form.Dispose();

                ParentForm?.Close();
            }
            else
                validationSummary1.ShowErrorSummary();
        }
        private void btnConfermaClick(object sender, EventArgs e)
        {
            if (_esercizio != null)
            {
                var form = new ExecuteLoadDataObjectAsync<string>("E' in corso l'associazione dei versamenti con le rate emesse ....." + Environment.NewLine + "Si prega di attendere.");
                Func<string> loadDati = () => getVersamentoCondominiService().AssociaVersamentiCondominiSenzaRata(_esercizio);
                form.LoadData(loadDati);
                form.ShowDialog();

                var message = form.DataSourceObject;
                form.Dispose();
                if (!string.IsNullOrEmpty(message))
                    CommonMessages.DisplayWarning("Si sono verificati degli errori nell'associare i versamenti alle rate: " + Environment.NewLine + Environment.NewLine + message);
                else
                    CommonMessages.DisplayComplete("I versamenti sono stati correttamente associati alle rate.");
            }
        }
        private void btnConfermaClick(object sender, EventArgs e)
        {
            validationSummary1.Validate();
            if (validationSummary1.IsValid)
            {
                validationOptionalSummary.Validate();
                if (validationOptionalSummary.IsValid)
                {
                    var tipoRendiconto = TipoRendiconto.Consuntivo;
                    if (preventivoConsuntivo.Value.ToString() == "P")
                        tipoRendiconto = TipoRendiconto.Preventivo;

                    // ====================================================================
                    // Se riparto consuntivo chiedo la stampa batch
                    // ====================================================================
                    var dialogResult = CommonMessages.DisplayConfirmCancel("Vuoi eseguire una stampa batch in modo che l'applicazione non resti bloccata durante l'elaborazione?");
                    switch (dialogResult)
                    {
                        case DialogResult.No:
                            {
                                var form = new ExecuteLoadDataObjectAsync<ResultRiparto>("E' in corso il caricamento del riparto ....." + Environment.NewLine + "Si prega di attendere.");
                                Func<ResultRiparto> loadDati = () => getRipartoDatasource((int)esercizi.Value, (int?)stabili.Value, (int?)gruppi.Value, suddivisioneProprietari.Checked, accorpamentoUnita.Checked, getTipoAccorpamento(), tipoRendiconto);
                                form.LoadData(loadDati);
                                form.ShowDialog();

                                ShowReport((int)esercizi.Value, form.DataSourceObject, getParameters(sceltaCondominioCombo1.CondominioSelected, (EsercizioDTO)esercizi.SelectedItem.ListObject, tipoRendiconto, "HTML"));
                                form.Dispose();
                            }
                            break;

                        case DialogResult.Yes:
                            INotifier notifier = null;
                            if (ParentForm?.MdiParent is INotifier)
                                notifier = (INotifier) ParentForm.MdiParent;
                            getBilancioService().GetRipartizioneAsync((int)esercizi.Value, (int?)stabili.Value, (int?)gruppi.Value, suddivisioneProprietari.Checked, addebitiCondominio.Checked, addebitiDirettiStabileScala.Checked, accorpamentoUnita.Checked, getTipoAccorpamento(), getParameters(sceltaCondominioCombo1.CondominioSelected, (EsercizioDTO)esercizi.SelectedItem.ListObject, tipoRendiconto, "HTML"), notifier, BilancioConsuntivoResources.riparto_large);
                            break;
                    }
                }
                else
                    validationOptionalSummary.ShowErrorSummary();
            }
            else
                validationSummary1.ShowErrorSummary();
        }
 private void btnConfermaClick(object sender, EventArgs e)
 {
     validationSummary1.Validate();
     if (validationSummary1.IsValid)
     {
         var form = new ExecuteLoadDataObjectAsync<DocumentInfo>("L'esportazione del condominio è in corso ....." + Environment.NewLine + "Si prega di attendere.");
         Func<DocumentInfo> loadDati = () => getImportazioneService().ExportCondominio(sceltaCondominioCombo1.IdCondominioSelected);
         form.LoadData(loadDati);
         form.ShowDialog();
         var documentInfo = form.DataSourceObject;
         documentInfo.FileName = $"{nomeFolder.Text}/{documentInfo.FileName}.{documentInfo.FileExtension}";
         var fullPathFile = getManageDocumentService().Save(documentInfo);
         getManageDocumentService().Open(documentInfo, null, false, MergeFieldType.Undefined);
         form.Dispose();
         ParentForm?.Close();
     }
     else
         validationSummary1.ShowErrorSummary();
 }
Exemple #7
0
        private void caricaAzienda(int idAzienda)
        {
            var form = new ExecuteLoadDataObjectAsync<bool>("Sono in corso di caricamento i dati dell'azienda ....." + Environment.NewLine + "Si prega di attendere.");
            Func<bool> loadDati = () => loadDatiCacheAzienda(idAzienda);
            form.LoadData(loadDati);
            form.ShowDialog();
            form.Dispose();

            if (form.DataSourceObject)
            {
                CommonMessages.DisplayComplete("I dati sono stati correttamente caricati");
                listaAziende.Value = idAzienda;
                if(listaAziende.CheckedItem != null)
                    OnSelectAzienda(new SelectAziendaArgs((AziendaListaDTO)listaAziende.CheckedItem.ListObject));
            }
            else
            {
                CommonMessages.DisplayWarning("Si sono verificati dei problemi nel caricamento dei dati. Si prega di riprovare");
            }
        }
        private void btnConfermaClick(object sender, EventArgs e)
        {
            try
            {
                validationSummary1.Validate();
                if (validationSummary1.IsValid)
                {
                    var righeCondominio = _condominio.IndirizzoCompleto.Split('&');
                    var righeDaPubblicare = new string[4];
                    righeDaPubblicare[0] = righeCondominio[0];
                    righeDaPubblicare[2] = string.Empty;
                    righeDaPubblicare[3] = string.Empty;
                    for (var i = 1; i < 4; i++)
                    {
                        if (righeCondominio.Length > i)
                        {
                            if (!string.IsNullOrEmpty(righeDaPubblicare[1]))
                                righeDaPubblicare[1] += " - ";
                            righeDaPubblicare[1] += righeCondominio[i];
                        }
                    }

                    // ====================================================================
                    // Recupero l'intestazione dello studio
                    // ====================================================================
                    var azienda = getAziendaService().GetAzienda();
                    var intestazioneStudio = azienda.Descrizione;
                    var viaStudio = string.Empty;
                    var capStudio = string.Empty;
                    var localitaStudio = string.Empty;
                    if (azienda.IndirizzoSede != null)
                    {
                        viaStudio = azienda.IndirizzoSede.Indirizzo + " n. " + azienda.IndirizzoSede.Civico;
                        capStudio = azienda.IndirizzoSede.Cap;
                        localitaStudio = azienda.IndirizzoSede.DescrizioneComune + " " + azienda.IndirizzoSede.CodiceProvincia;

                        // Collasso diverse informazioni nel campo viaStudio
                        viaStudio += " - " + capStudio + " " + localitaStudio;
                    }

                    var descrizioneEsercizio = string.Empty;
                    EsercizioDTO esercizio = null;
                    if (esercizi.SelectedItem != null)
                    {
                        esercizio = (EsercizioDTO)esercizi.SelectedItem.ListObject;
                        descrizioneEsercizio = esercizio.DisplayName;
                    }

                    var reportParameters =
                        new StatoPatrimonialeReportParameters
                            (
                            righeDaPubblicare,
                            _condominio.Codice,
                            descrizioneEsercizio,
                            string.Empty,
                            true,
                            string.Empty,
                            intestazioneStudio,
                            viaStudio,
                            capStudio,
                            localitaStudio,
                            (DateTime?)dataFinale.Value
                            );

                    if (tipoStampa.Value.ToString() == "SP" && esercizi.SelectedItem != null)
                    {
                        try
                        {
                            var dataSourceCassa = getStatoPatrimonialeService().GetSituazioneCassa(_condominio, esercizio, (DateTime?)dataFinale.Value);
                            var resultPatrimoniale = getStatoPatrimonialeService().GetSituazionePatrimoniale((EsercizioDTO)esercizi.SelectedItem.ListObject, (DateTime?)dataFinale.Value);
                            if (string.IsNullOrEmpty(resultPatrimoniale.Message))
                            {
                                var dataSourcePatrimoniale = resultPatrimoniale.SituazionePatrimoniale;
                                if (dataSourceCassa != null && dataSourcePatrimoniale != null)
                                {
                                    var anteprima = new AnteprimaStampa(dataSourceCassa, dataSourcePatrimoniale, reportParameters);
                                    anteprima.ShowDialog();
                                    anteprima.Dispose();
                                }
                            }
                            else
                            {
                                CommonMessages.DisplayWarning($"Errore nell'elaborazione dello stato patrimoniale:{Environment.NewLine}{resultPatrimoniale.Message}");
                            }
                        }
                        catch (Exception ex)
                        {
                            var idEsercizio = "<NULL>";
                            if (esercizio != null)
                                idEsercizio = esercizio.ID.ToString(CultureInfo.InvariantCulture);

                            _log.ErrorFormat("Errore inaspettato durante la stampa dello stato patrimoniale - {0} - tipoStampa: SP - condominio:{1} - esercizio:{2}", ex, Utility.GetMethodDescription(), _condominio.ID, idEsercizio);
                            throw;
                        }
                    }
                    else if (tipoStampa.Value.ToString() == "BS")
                    {
                        try
                        {
                            var dataSource = getStatoPatrimonialeService().GetSaldiConti(_condominio, esercizio, (DateTime?)dataFinale.Value);
                            if (dataSource != null)
                            {
                                var anteprima = new AnteprimaStampaBilancio(dataSource, reportParameters);
                                anteprima.ShowDialog();
                                anteprima.Dispose();
                            }
                        }
                        catch (Exception ex)
                        {
                            var idEsercizio = "<NULL>";
                            if (esercizio != null)
                                idEsercizio = esercizio.ID.ToString(CultureInfo.InvariantCulture);

                            _log.ErrorFormat("Errore inaspettato durante la stampa dello stato patrimoniale - {0} - tipoStampa: BS - esercizio:{1}", ex, Utility.GetMethodDescription(), idEsercizio);
                            throw;
                        }
                    }
                    else if (tipoStampa.Value.ToString() == "PT")
                    {
                        try
                        {
                            if (string.IsNullOrEmpty(reportParameters.DescrizioneEsercizio))
                                reportParameters.DescrizioneEsercizio = dataIniziale.DateTime.ToShortDateString() + " - " + dataFinale.DateTime.ToShortDateString();

                            EsercizioDTO esercizioDTO = null;
                            if (esercizi.SelectedItem != null)
                                esercizioDTO = esercizi.SelectedItem.ListObject as EsercizioDTO;

                            var contiSelezionati = new List<ContoDTO>();
                            var righeContiSelezionati = DataGridHelper.GetSelectedRows(conti, true);
                            var sottoContiSelezionati = new List<string>();

                            try
                            {
                                foreach (var ultraGridRow in righeContiSelezionati)
                                {
                                    try
                                    {
                                        var conto = ultraGridRow.ListObject as ContoDTO;
                                        if (conto != null)
                                        {
                                            contiSelezionati.Add(conto);
                                            if (ultraGridRow.ChildBands != null && ultraGridRow.ChildBands.Count > 0)
                                            {
                                                foreach (var row in ultraGridRow.ChildBands[0].Rows)
                                                {
                                                    if (row.Cells.Exists("SelectColumn") && row.Cells["SelectColumn"].Value.ToString().ToLower() == "true")
                                                    {
                                                        if (row.Cells["Codice"].Value != null)
                                                            sottoContiSelezionati.Add(row.Cells["Codice"].Value.ToString());
                                                        else
                                                            _log.ErrorFormat("Codice sottoconto null - {0} - conto:{1} - sottoconto:{2}", Utility.GetMethodDescription(), conto.ID, row.Cells["ID"].Value);
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    catch (Exception ex)
                                    {
                                        _log.ErrorFormat("Errore nella selezione dei sottoconti - SINGOLO CONTO - {0} - rowindex:{1} - condominio:{2} - azienda:{3}", ex, Utility.GetMethodDescription(), ultraGridRow.Index, _condominio.ID, Login.Instance.CurrentLogin().Azienda);                                
                                        throw;
                                    }
                                }
                            }
                            catch (Exception ex)
                            {
                                _log.ErrorFormat("Errore nella selezione dei sottoconti - {0} - condominio:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), _condominio.ID, Login.Instance.CurrentLogin().Azienda);                                
                            }

                            var form = new ExecuteLoadDataListAsync<MovimentoContabileBilancioDTO>("Il partitario è in corso di caricamento ....." + Environment.NewLine + "Si prega di attendere.");
                            Func<List<MovimentoContabileBilancioDTO>> loadDati = () => getStatoPatrimonialeService().GetDettaglioPartitario(esercizioDTO, contiSelezionati, sottoContiSelezionati, (DateTime?)dataIniziale.Value, (DateTime?)dataFinale.Value);
                            form.LoadData(loadDati);
                            form.ShowDialog();
                            var dataSource = form.DataSourceObject;
                            form.Dispose();

                            if (dataSource != null)
                            {
                                var anteprima = new AnteprimaStampaPartitario(dataSource, reportParameters);
                                anteprima.ShowDialog();
                                anteprima.Dispose();
                            }
                        }
                        catch (Exception ex)
                        {
                            var idEsercizio = "<NULL>";
                            if (esercizio != null)
                                idEsercizio = esercizio.ID.ToString(CultureInfo.InvariantCulture);

                            _log.ErrorFormat("Errore inaspettato durante la stampa dello stato patrimoniale - {0} - tipoStampa: PT - condominio:{1} - esercizio:{2}", ex, Utility.GetMethodDescription(), _condominio.ID, idEsercizio);
                            throw;
                        }
                    }
                    else if (tipoStampa.Value.ToString() == "RC")
                    {
                        try
                        {
                            var dataInizialeParam = dataIniziale.Value as DateTime?;
                            var dataFinaleParam = dataFinale.Value as DateTime?;
                            if (dataInizialeParam == null && esercizio != null)
                                dataInizialeParam = esercizio.DataApertura.GetValueOrDefault();
                            if (dataFinaleParam == null && esercizio != null)
                                dataFinaleParam = esercizio.DataChiusura.GetValueOrDefault();

                            if (dataInizialeParam == null || dataFinaleParam == null)
                            {
                                CommonMessages.DisplayWarning("Occorre scegliere un esercizio o un intervallo di date");
                                return;
                            }

                            var form = new ExecuteLoadDataObjectAsync<ResultMessagesOfArrayOfMovimentoLiquiditaDTOn0Zc5SOa>("Il registro di contabilità è in corso di caricamento ....." + Environment.NewLine + "Si prega di attendere.");
                            Func<ResultMessagesOfArrayOfMovimentoLiquiditaDTOn0Zc5SOa> loadDati = () => getStatoPatrimonialeService().GetRegistroContabilita(_condominio, dataInizialeParam.GetValueOrDefault(), dataFinaleParam.GetValueOrDefault());
                            form.LoadData(loadDati);
                            form.ShowDialog();
                            var result = form.DataSourceObject;
                            form.Dispose();

                            if (!string.IsNullOrEmpty(result.FatalMessage))
                            {
                                CommonMessages.DisplayWarning($"Si sono verificati i seguenti errori:{Environment.NewLine}{result.FatalMessage}");
                                return;
                            }
                            if (!string.IsNullOrEmpty(result.WarnMessage))
                                CommonMessages.DisplayWarning($"ATTENZIONE sono stati segnalati i seguenti avvertimenti:{Environment.NewLine}{result.WarnMessage}");

                            var dataSource = result.Result;
                            if (dataSource != null)
                            {
                                if (esercizio == null)
                                    esercizio = getEsercizioService().GetEsercizioCompetenza(sceltaCondominioCombo1.CondominioSelected, DateTime.Today);

                                if (_impostazioneReportDTO == null)
                                {
                                    if(esercizio.ID == 0)
                                        return;
                                    setImpostazioneReport(esercizio);
                                    impostazioneReportDTOBindingSource.DataSource = _impostazioneReportDTO;
                                    if (_impostazioneReportDTO == null)
                                        return;
                                }

                                var anteprima = new AnteprimaReportRegistroContabilita(dataSource, sceltaCondominioCombo1.CondominioSelected, getEsercizioReport(), dataInizialeParam.GetValueOrDefault(), dataFinaleParam.GetValueOrDefault(), _impostazioneReportDTO, getReportKey());
                                anteprima.ShowDialog();
                                anteprima.Dispose();
                            }
                        }
                        catch (Exception ex)
                        {
                            var idEsercizio = "<NULL>";
                            if (esercizio != null)
                                idEsercizio = esercizio.ID.ToString(CultureInfo.InvariantCulture);

                            _log.ErrorFormat("Errore inaspettato durante la stampa del registro di contabilità - {0} - tipoStampa: RC - esercizio:{1}", ex, Utility.GetMethodDescription(), idEsercizio);
                            throw;
                        }
                    }
                    else if (tipoStampa.Value.ToString() == "RE")
                    {
                        try
                        {
                            var dataInizialeParam = dataIniziale.Value as DateTime?;
                            var dataFinaleParam = dataFinale.Value as DateTime?;
                            if (dataInizialeParam == null && esercizio != null)
                                dataInizialeParam = esercizio.DataApertura.GetValueOrDefault();
                            if (dataFinaleParam == null && esercizio != null)
                                dataFinaleParam = esercizio.DataChiusura.GetValueOrDefault();

                            if (dataInizialeParam == null || dataFinaleParam == null)
                            {
                                CommonMessages.DisplayWarning("Occorre scegliere un esercizio o un intervallo di date");
                                return;
                            }

                            var form = new ExecuteLoadDataObjectAsync<ResultMessagesOfArrayOfReportRiepilogoContoEconomicoDTOn0Zc5SOa>("Il riepilogo economico è in corso di caricamento ....." + Environment.NewLine + "Si prega di attendere.");
                            Func<ResultMessagesOfArrayOfReportRiepilogoContoEconomicoDTOn0Zc5SOa> loadDati = () => getStatoPatrimonialeService().GetRiepilogoContoEconomico(esercizio, dataInizialeParam.GetValueOrDefault(), dataFinaleParam.GetValueOrDefault());
                            form.LoadData(loadDati);
                            form.ShowDialog();
                            var result = form.DataSourceObject;
                            form.Dispose();

                            if (!string.IsNullOrEmpty(result.FatalMessage))
                            {
                                CommonMessages.DisplayWarning($"Si sono verificati i seguenti errori:{Environment.NewLine}{result.FatalMessage}");
                                return;
                            }
                            if (!string.IsNullOrEmpty(result.WarnMessage))
                                CommonMessages.DisplayWarning($"ATTENZIONE sono stati segnalati i seguenti avvertimenti:{Environment.NewLine}{result.WarnMessage}");

                            var dataSource = result.Result;
                            if (dataSource != null)
                            {
                                if (esercizio == null)
                                    esercizio = getEsercizioService().GetEsercizioCompetenza(sceltaCondominioCombo1.CondominioSelected, DateTime.Today);

                                if (_impostazioneReportDTO == null)
                                {
                                    if (esercizio.ID == 0)
                                        return;
                                    setImpostazioneReport(esercizio);
                                    impostazioneReportDTOBindingSource.DataSource = _impostazioneReportDTO;
                                    if (_impostazioneReportDTO == null)
                                        return;
                                }

                                var anteprima = new AnteprimaReportRiepilogoContoEconomico(dataSource, sceltaCondominioCombo1.CondominioSelected, getEsercizioReport(), dataInizialeParam.GetValueOrDefault(), dataFinaleParam.GetValueOrDefault(), _impostazioneReportDTO, getReportKey());
                                anteprima.ShowDialog();
                                anteprima.Dispose();
                            }
                        }
                        catch (Exception ex)
                        {
                            var idEsercizio = "<NULL>";
                            if (esercizio != null)
                                idEsercizio = esercizio.ID.ToString(CultureInfo.InvariantCulture);

                            _log.ErrorFormat("Errore inaspettato durante la stampa del registro di contabilità - {0} - tipoStampa: RC - esercizio:{1}", ex, Utility.GetMethodDescription(), idEsercizio);
                            throw;
                        }
                    }
                }
                else
                    validationSummary1.ShowErrorSummary();
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato durante la stampa dello stato patrimoniale - {0} - condominio:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), _condominio.ID, Login.Instance.CurrentLogin().Azienda);
            }
        }
Exemple #9
0
        public bool Salva()
        {
            const bool result = true;

            if (_millesimi.Count > 0)
            {
                var form = new ExecuteLoadDataObjectAsync<string>("E' in corso l'aggiornamento dei millesimi ....." + Environment.NewLine + "Si prega di attendere.");
                Func<string> loadDati = () => salvaMillesimiAndReload(_millesimi, _esercizio);
                form.LoadData(loadDati);
                form.ShowDialog();
                if (string.IsNullOrEmpty(form.DataSourceObject))
                    CommonMessages.DisplayComplete("I millesimi sono stati correttamente aggiornati");
                else
                    CommonMessages.DisplayWarning("Si sono verificati degli errori durante l'aggiornamento dei millesimi:" + Environment.NewLine + Environment.NewLine + form.DataSourceObject);

                millesimi.UpdateData();
                millesimi.PerformAction(Infragistics.Win.UltraWinGrid.UltraGridAction.ExitEditMode);

                Dirty = false;

                form.Dispose();
            }

            return result;
        }
        protected override void ExecuteRefresh()
        {
            if (_condominio.ID > 0)
            {
                var form = new ExecuteLoadDataObjectAsync<CondominioDataSources>("E' in corso l'aggiornamento dei dati ....." + Environment.NewLine + "Si prega di attendere.");
                Func<CondominioDataSources> loadDati = () => executeRefresh(_condominio.ID);
                form.LoadData(loadDati);
                form.ShowDialog();

                if (form.DataSourceObject.Condominio != null)
                    setDataSources(form.DataSourceObject);

                CommonMessages.DisplayComplete("I dati sono stati correttamente aggiornati");
                form.Dispose();
            }
        }
        protected override bool Save()
        {
            var result = true;
            if (_condominio.Stato != "")
            {
                CondominioDTO condominioSave;
                bool updateTemplateDescrizioneUnita = false;
                try
                {
                    var dialogResult = DialogResult.No;
                    if (!string.IsNullOrEmpty(descrizioneUnitaImmobiliare.Text) && _condominio.TemplateDescrizioneUnitaImmobiliare != descrizioneUnitaImmobiliare.Text && !IsNew)
                    {
                        dialogResult = CommonMessages.DisplayConfirmCancel("Vuoi aggiornare la descrizione di tutte le unità immobiliari sulla base del modello definito?");
                    }

                    if (dialogResult == DialogResult.Cancel)
                        return false;

                    _condominio.IdResponsabiliAssemblea.Clear();
                    var responsabiliRows = DataGridHelper.GetSelectedRows(responsabiliAssemblea, false);
                    foreach (var row in responsabiliRows)
                        _condominio.IdResponsabiliAssemblea.Add((int)row.GetCellValue("ID"));

                    _condominio.TipoVersamentoDopoChiusura = getTipoVersamentoDopoChiusura();
                    _condominio.TipoVersamentoPrimaApertura = getTipoVersamentoPrimaApertura();
                    _condominio.TemplateDescrizioneUnitaImmobiliare = descrizioneUnitaImmobiliare.Text;
                    condominioSave = getCondominioService().Save(_condominio);

                    if (dialogResult == DialogResult.Yes)
                    {
                        var form = new ExecuteLoadDataObjectAsync<string>("E' in corso l'aggiornamento della descrizione delle unità immobiliari ....." + Environment.NewLine + "Si prega di attendere.");
                        Func<string> loadDati = () => getUnitaImmobiliareService().AggiornaDescrizioneUnitaImmobiliareCondominio(condominioSave.ID, false);
                        form.LoadData(loadDati);
                        form.ShowDialog();
                        if(string.IsNullOrEmpty(form.DataSourceObject))
                            updateTemplateDescrizioneUnita = true;
                        else
                            CommonMessages.DisplayWarning(string.Format("Si sono verificati degli errori nell'aggiornamento della descrizione delle unità immobiliari.{0}{1}", Environment.NewLine, form.DataSourceObject));
                        form.Dispose();
                    }
                }
                catch (Exception ex)
                {
                    log.ErrorFormat("Errore durante il Salvataggio del condominio - {0} - id:{1}", ex, Utility.GetMethodDescription(), _condominio.ID);
                    throw;
                }

                if (condominioSave.ID == 0)
                {
                    CommonMessages.DisplayWarning("Si è verificato un errore: un altro utente ha effettuato un aggiornamento. Uscire e riprovare ");
                    Dispose();
                }
                else
                {
                    _condominio = condominioSave;
                    BusinessClass = new BaseDTOOfint[] { _condominio };
                    condominioBindingSource.DataSource = _condominio;
                    indirizzoCondominioBindingSource.DataSource = _condominio.Indirizzo;
                    datiBancariDTOBindingSource.DataSource = _condominio.DatiBancari;
                }

                if ((_listPlugin != null) && (_condominio.ID != 0))
                {
                    foreach (var kvp in _listPlugin)
                    {
                        // TODO: Trovare qualcosa di più intelligente per identificare l'aggiornamento della lista delle unità immobiliari
                        if (!updateTemplateDescrizioneUnita || kvp.Value.Order > 10)
                        {
                            var version = kvp.Value.Salva();
                            if (version != null)
                            {
                                if (version >= 0)
                                {
                                    kvp.Value.Reload(_condominio);
                                    _condominio.Version = version.Value;
                                }
                                else
                                {
                                    result = false;
                                    break;
                                }
                            }
                        }
                    }
                }

                if ((_listPlugin == null) && (_condominio.ID != 0) && SaveBehavoir != SaveBehavoir.Exit && !Modal)
                    loadPlugins();

                base.Save();
            }

            return result;
        }
        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);
            }
        }
Exemple #13
0
        private void listaDoubleClickRow(object sender, DoubleClickRowEventArgs e)
        {
            var doc = e.Row.ListObject as DocumentoDTO;
            if (doc != null)
            {
                try
                {
                    if (doc.FileExtension != "Archiva")
                    {
                        if (doc.FileName != string.Empty)
                        {
                            try
                            {
                                if (getDocumentoService().IsEditabile(doc, null))
                                {
                                    openDocument(doc);
                                }
                                else
                                {
                                    var form = new ExecuteLoadDataObjectAsync<bool>("Il documento è in corso di caricamento ....." + Environment.NewLine + "Si prega di attendere.");
                                    Func<bool> loadDati = () => openDocument(doc);
                                    form.LoadData(loadDati);
                                    form.ShowDialog();
                                    form.Dispose();
                                }
                            }
                            catch (Exception ex)
                            {
                                _log.ErrorFormat("Errore inaspettato durante l'apertura del documento - {0} - documento:{1}", ex, Gipasoft.Library.Utility.GetMethodDescription(), doc.FileName);
                            }
                        }
                        else
                        {
                            _log.ErrorFormat("Non trovato il percorso del documento - {0} - documento:{1}", Gipasoft.Library.Utility.GetMethodDescription(), doc.FileName);
                        }
                    }
                    else
                    {
                        var identificativoArchiviazioneOttica = string.Empty;
                        if (!string.IsNullOrEmpty(doc.IdentificativoArchiviazioneOttica))
                            identificativoArchiviazioneOttica = doc.IdentificativoArchiviazioneOttica.Trim();

                        var result = getArchiviazioneOtticaService().ShowDocumento(doc, TipoDocumento.Contratto, null, identificativoArchiviazioneOttica);
                        if (!string.IsNullOrEmpty(result))
                            CommonMessages.DisplayWarning(result);
                    }

                }
                catch (Exception ex)
                {
                    _log.ErrorFormat("Errore nell'apertura del documento - {0} - documento:{1} - azienda:{2}", ex, Gipasoft.Library.Utility.GetMethodDescription(), doc.ID, Security.Login.Instance.CurrentLogin().Azienda);
                }
            }
        }
Exemple #14
0
        private void btnConfermaClick(object sender, EventArgs e)
        {
            richiestaValidation.Validate();
            if (!richiestaValidation.IsValid)
            {
                richiestaValidation.ShowErrorSummary();
            }
            else
            {
                var condominio = sceltaCondominio.CondominioSelected;

                var tipo = TipoRichiestaEnum.Variazione;
                if (tipoRichiesta.Value.ToString() == "A")
                    tipo = TipoRichiestaEnum.Nuovo;

                int? idReferente = null;
                if (referenti.Value != null)
                    idReferente = ((ReferenteDTO)referenti.SelectedItem.ListObject).ID;

                // Caricamento asincrono del modulo
                if (condominio.ID > 0)
                {
                    var form = new ExecuteLoadDataObjectAsync<bool>("Il modulo è in corso di caricamento ....." + Environment.NewLine + "Si prega di attendere.");
                    Func<bool> loadDati = () => loadModulo(condominio.ID, dataCompilazione.DateTime, idReferente, (int)rappresentante.Value, nuovoCodiceFiscale.Text, tipo, (DateTime?)dataVariazioneDati.Value);
                    form.LoadData(loadDati);
                    form.ShowDialog();

                    if (nuovoCodiceFiscale.Visible && nuovoCodiceFiscale.Text != condominio.CodiceFiscale)
                    {
                        condominio.CodiceFiscale = nuovoCodiceFiscale.Text;
                        getCondominioService().Save(condominio);
                    }
                    form.Dispose();
                }
                else
                {
                    CommonMessages.DisplayWarning("Scegliere un condominio");
                    return;
                }

                Close();
            }
        }
Exemple #15
0
        private void listaDoubleClickRow(object sender, DoubleClickRowEventArgs e)
        {
            try
            {
                var documento = e.Row.ListObject as DocumentoDTO;
                if (documento != null)
                {
                    if (documento.FileExtension != "Archiva")
                    {
                        openDocument(documento);
                        //var form = new ExecuteLoadDataObjectAsync<bool>("Il documento è in corso di caricamento ....." + Environment.NewLine + "Si prega di attendere.");
                        //Func<bool> loadDati = () => openDocument(documento);
                        //form.LoadData(loadDati);
                        //form.ShowDialog();
                    }
                    else if (!string.IsNullOrEmpty(documento.IdentificativoArchiviazioneOttica))
                    {
                        TipoDocumento tipo;
                        int? anno = null;
                        string id;
                        switch (documento.Tipo)
                        {
                            case "Fattura":
                                anno = int.Parse(documento.Checksum);
                                id = documento.IdentificativoArchiviazioneOttica.Trim();
                                tipo = TipoDocumento.FatturaPassiva;
                                break;
                            default:
                                id = documento.IdentificativoArchiviazioneOttica.Trim();
                                tipo = TipoDocumento.Contratto;
                                break;
                        }

                        if (getAziendaService().GetAperturaDocumentoPdf() == TipoAperturaDocumentoEnum.BuiltInViewer)
                        {
                            getArchiviazioneOtticaService().ShowDocumento(documento, tipo, anno, id);
                            return;
                        }

                        var form = new ExecuteLoadDataObjectAsync<string>("Il documento è in corso di caricamento ....." + Environment.NewLine + "Si prega di attendere.");
                        Func<string> loadDati = () => getArchiviazioneOtticaService().ShowDocumento(documento, tipo, anno, id);
                        form.LoadData(loadDati);
                        form.ShowDialog();
                        if (!string.IsNullOrEmpty(form.DataSourceObject))
                            CommonMessages.DisplayWarning(form.DataSourceObject);
                        form.Dispose();
                    }
                    else
                        CommonMessages.DisplayWarning("Non è possibile aprire il documento selezionato." + Environment.NewLine + "L'identificativo di archiviazione non è presente.");
                }

            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore nell'apertura di un documento - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), Login.Instance.CurrentLogin().Azienda);
                CommonMessages.DisplayWarning("Non è possibile aprire il documento selezionato.");
            }

        }
        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();
            }
        }
        public bool Conferma()
        {
            validationSummary1.Validate();
            if (validationSummary1.IsValid)
            {
                
                var messageinfo = new Infragistics.Win.UltraMessageBox.UltraMessageBoxInfo
                {
                    Caption = "Aggiornamento modello contabile",
                    Header = "Conferma dell'aggiornamento della descrizione bollette",
                    TextFormatted = "La descrizione delle bollette legate al modello può essere aggiornata automaticamente con la nuova descrizione:<br /><strong>" + descrizioneVoceFattura.Text + "</strong><br />Vuoi aggiornare la descrizione di tutte le bollette legate al presente modello?",
                    Buttons = MessageBoxButtons.YesNoCancel,
                    Icon = MessageBoxIcon.Warning,
                    FooterFormatted = "<strong>ATTENZIONE:</strong> Eventuali descrizioni personalizzate per specifiche bollette saranno <strong>irrimediabilmente perse</strong>"
                };
                var result = confermaAggiornamentoDescrizione.ShowMessageBox(messageinfo);
                if(result != DialogResult.Cancel)
                {
                    var form = new ExecuteLoadDataObjectAsync<AuthorizationMessages>("Aggiornamento e ricalcolo spese in corso ....." + Environment.NewLine + "Si prega di attendere.");
                    Func<AuthorizationMessages> loadDati = () => getModelloContabileService().Salva(_modello, _esercizio, ripartizioneSpese.Checked);
                    form.LoadData(loadDati);
                    form.ShowDialog();
                    var messageAuth = form.DataSourceObject;
                    form.Dispose();

                    if (string.IsNullOrEmpty(messageAuth.FatalMessage))
                    {
                        if (!string.IsNullOrEmpty(messageAuth.WarnMessage))
                            CommonMessages.DisplayWarning("Avvertimenti per il salvataggio del modello contabile:" + Environment.NewLine + messageAuth.WarnMessage);

                        if(result == DialogResult.Yes)
                        {
                            var messageAggiornamentoDescrizione = getUtenzaService().AggiornaDescrizioneBollettaByModello(_modello.ID, descrizioneVoceFattura.Text);
                            if(!string.IsNullOrEmpty(messageAggiornamentoDescrizione))
                            {
                                CommonMessages.DisplayWarning("Si sono verificati i seguenti problemi durante l'aggiornamento della descrizione delle bollette:" + Environment.NewLine + messageAggiornamentoDescrizione);
                                return false;
                            }
                        }

                        CommonMessages.DisplayComplete("Il modello è stato correttamente salvato.");
                        return true;
                    }
                    CommonMessages.DisplayWarning("Si sono verificati i seguenti problemi durante il salvataggio del modello:" + Environment.NewLine + messageAuth.FatalMessage);
                }
            }
            else
                validationSummary1.ShowErrorSummary();

            return false;
        }
Exemple #18
0
        private void contextMenuStrip1ItemClicked(object sender, ToolStripItemClickedEventArgs e)
        {
            try
            {
                contextMenuStrip1.Close(ToolStripDropDownCloseReason.ItemClicked);
                if (e.ClickedItem.Name == "allegatiToolStripMenuItem")
                {
                    if (_messaggioClick != null && _messaggioClick.ID > 0)
                    {
                        apriAllegati(_messaggioClick);
                    }
                }
                else if (e.ClickedItem.Name == "controllaRapportinoToolStripMenuItem")
                {
                    var form = new ExecuteLoadDataObjectAsync<string>("Il controllo del rapportino è in corso di esecuzione ....." + Environment.NewLine + "Si prega di attendere.");
                    Func<string> loadDati = () => getMessaggioService().ControllaRapportinoSingolo(_messaggioClick);
                    form.LoadData(loadDati);
                    form.ShowDialog();

                    if(string.IsNullOrEmpty(form.DataSourceObject))
                        CommonMessages.DisplayComplete("Il controllo del rapportino è terminato correttamente");
                    else
                        CommonMessages.DisplayWarning(form.DataSourceObject);

                    form.Dispose();
                }
                else if (e.ClickedItem.Name == "riprovaInvioToolStripMenuItem")
                {
                    var messageRetry = getMessaggioService().RetryInvioMessaggio(_messaggioClick.ID);
                    if(string.IsNullOrEmpty(messageRetry))
                        CommonMessages.DisplayComplete("Il messaggio è stato messo in coda d'invio");
                    else
                        CommonMessages.DisplayWarning(string.Format("Si sono verificati dei problemi nel tentativo di reinviare il messaggio:{0}{1}", Environment.NewLine, messageRetry));
                }
                else if (e.ClickedItem.Name == "infoMessaggioToolStripMenuItem")
                {
                    var form = new ExecuteLoadDataListAsync<InfoSpedizioneMessaggioDTO>("E' in corso la ricerca dei documenti ....." + Environment.NewLine + "Si prega di attendere.");
                    Func<List<InfoSpedizioneMessaggioDTO>> loadDati = () => getMessaggioService().GetInfoMessaggio(new List<StoricoMessaggioDTO> { _messaggioClick }, _messaggioClick.Tipo);
                    form.LoadData(loadDati);
                    form.ShowDialog();
                    var infoList = form.DataSourceObject;
                    var info = infoList.FirstOrDefault(item => item.Id == _messaggioClick.ID);
                    if (info != null)
                    {
                        var formInfo = new InfoMessaggioUI(info);
                        formInfo.ShowDialog();
                        formInfo.Dispose();
                    }
                    else
                        CommonMessages.DisplayComplete("Non sono disponibili informazioni");
                    form.Dispose();
                }

                contextMenuStrip1.Close(ToolStripDropDownCloseReason.ItemClicked);

            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore nel click col bottone DX del mouse - {0} - key:{1}", ex, Utility.GetMethodDescription(), e.ClickedItem.Name);
                throw;
            }
        }
Exemple #19
0
        private void btnElaboraInfoMessaggiClick(object sender, EventArgs e)
        {
            var form = new ExecuteLoadDataObjectAsync<bool>("La verifica è in corso di esecuzione ....." + Environment.NewLine + "Si prega di attendere.");
            Func<bool> loadDati = () => getMessaggioService().ElaboraInfoMessaggi();
            form.LoadData(loadDati);
            form.ShowDialog();

            if (form.DataSourceObject)
            {
                CommonMessages.DisplayComplete("La verifica è terminata");
                if(_persona != null)
                    LoadData(false);
            }
            form.Dispose();
        }
Exemple #20
0
        private void btnNewDocumentClick(object sender, EventArgs e)
        {
            try
            {
                var nuovoDoc = new NuovoDocumento();
                var result = nuovoDoc.ShowDialog(this);
                if (result == DialogResult.OK)
                {
                    var file = new FileInfo(nuovoDoc.DocumentFullPath);
                    if (file.Exists)
                    {
                        try
                        {
                            var numBytes = file.Length;
                            var fStream = new FileStream(nuovoDoc.DocumentFullPath, FileMode.Open, FileAccess.Read);
                            var br = new BinaryReader(fStream);
                            var data = br.ReadBytes((int) numBytes);
                            br.Close();
                            fStream.Close();

                            var fileName = nuovoDoc.DocumentFullPath.Substring(nuovoDoc.DocumentFullPath.LastIndexOf("\\") + 1);

                            // Caricamento finestrella feedback per il salvataggio
                            var form = new ExecuteLoadDataObjectAsync<DocumentMessages>("Il documento è in corso di salvataggio ....." + Environment.NewLine + "Si prega di attendere.");
                            Func<DocumentMessages> loadDati = () => saveDocument(data, fileName, nuovoDoc.DescrizioneDocumento, nuovoDoc.VisibileCondomino);
                            form.LoadData(loadDati);
                            form.ShowDialog();

                            if (form.DataSourceObject.Documento != null)
                            {
                                var documento = form.DataSourceObject.Documento;
                                documento.VisibileCondomino = nuovoDoc.VisibileCondomino;
                                _fascicolo.Documenti.Add(documento);
                                lista.DataSource = _fascicolo.Documenti;
                            }
                            else
                                CommonMessages.DisplayWarning(string.Format("Si è verificato un errore nel salvataggio del documento.{0}{1}", Environment.NewLine, form.DataSourceObject.Message));

                            form.Dispose();
                        }
                        catch (IOException ex)
                        {
                            _log.WarnFormat("Errore inaspettato nel caricamento del documento - FILE ESISTENTE - {0} - file:{1}", ex, Gipasoft.Library.Utility.GetMethodDescription(), nuovoDoc.DocumentFullPath);
                            CommonMessages.DisplayWarning(string.Format("Il documento non può essere aperto.{0}Verificare se il documento è già aperto in un'altra applicazione", Environment.NewLine));
                        }
                        catch (Exception ex)
                        {
                            _log.ErrorFormat("Errore inaspettato nel caricamento del documento - FILE ESISTENTE - {0} - file:{1}", ex, Gipasoft.Library.Utility.GetMethodDescription(), nuovoDoc.DocumentFullPath);
                            throw;
                        }
                    }
                    else
                    {
                        CommonMessages.DisplayWarning("Il file " + nuovoDoc.DocumentFullPath + " non è stato trovato." + Environment.NewLine + "Si prega di riprovare.");
                    }
                }

                nuovoDoc.Dispose();

            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato nel caricamento del documento - {0} - azienda:{1}", ex, Gipasoft.Library.Utility.GetMethodDescription(), Security.Login.Instance.CurrentLogin().Azienda);
            }
        }
Exemple #21
0
        public bool Salva()
        {
            var result = true;
            validationSummary1.Validate();
            if (validationSummary1.IsValid)
            {

                if (_contiDaAggiornare.Count > 0)
                {
                    var form = new ExecuteLoadDataObjectAsync<string>("Il salvataggio dei conti è in corso di esecuzione ....." + Environment.NewLine + "Si prega di attendere.");
                    Func<string> loadDati = () => getPianoContiService().Save(_contiDaAggiornare, _esercizio);
                    form.LoadData(loadDati);
                    form.ShowDialog();
                    var message = form.DataSourceObject;

                    if (string.IsNullOrEmpty(message))
                    {
                        Reload(_condominio, _esercizio);
                        conti.PerformAction(UltraGridAction.CommitRow);
                        CommonMessages.DisplayComplete("Il piano dei conti è stato correttamente aggiornato.");
                        _contiDaAggiornare.Clear();
                    }
                    else
                    {
                        CommonMessages.DisplayConfirmCancel("Durante l'aggiornamento del piano dei conti si sono verificati i seguenti errori:" + Environment.NewLine + message + "Vuoi ricaricare i conti per provare a ripetere la modifica?");
                        result = false;
                    }
                    form.Dispose();
                }
                else
                {
                    CommonMessages.DisplayWarning("Non è presente nessun conto da aggiornare");
                    result = false;
                }

            }
            else
            {
                result = false;
                validationSummary1.ShowErrorSummary();
            }

            return result;
        }
        private void btnSearchClick(object sender, EventArgs e)
        {
            validationSummary1.Validate();
            if (validationSummary1.IsValid)
            {
                var form = new ExecuteLoadDataObjectAsync<CondominiImportabili>("Ricerca dei condomini in corso......");
                Func<CondominiImportabili> loadDati = () => getImportazioneService().GetCondomini(openFileDialog1.FileName, password.Text, SoftwareInput.Condor);
                form.LoadData(loadDati);
                form.ShowDialog();

                if (form.DataSourceObject.Condomini != null)
                {
                    ricercaCondominio.DataSource = condominioDTOBindingSource;
                    condominioDTOBindingSource.DataSource = form.DataSourceObject.Condomini;
                }
                if (!string.IsNullOrEmpty(form.DataSourceObject.Message))
                    CommonMessages.DisplayWarning(form.DataSourceObject.Message);

                form.Dispose();
            }
            else
                validationSummary1.ShowErrorSummary();
        }
        private void btnRielaborazioneClick(object sender, EventArgs e)
        {
            var form = new ExecuteLoadDataObjectAsync<string>("La rielaborazione dei movimenti è in corso di esecuzione ....." + Environment.NewLine + "Si prega di attendere.");
            Func<string> loadDati = () => getMovimentoBancarioService().RielaborazioneMovimenti();
            form.LoadData(loadDati);
            form.ShowDialog();

            if (string.IsNullOrEmpty(form.DataSourceObject))
                CommonMessages.DisplayComplete("I movimenti sono stati correttamente rielaborati.");
            else
                CommonMessages.DisplayWarning("Si sono verificati dei problemi durante l'elaborazione dei movimenti:" + Environment.NewLine + form.DataSourceObject);
            form.Dispose();
        }
Exemple #24
0
        private void btnNewDocumentClick(object sender, EventArgs e)
        {
            try
            {
                var tipoDoc = string.Empty;
                if (_contratto != null)
                    tipoDoc = "TipoDocumentoContratto";
                else if (_condominio != null)
                    tipoDoc = "TipoDocumentoCondominio";
                else if (_fornitore != null)
                    tipoDoc = "TipoDocumentoFornitore";
                else if (_unitaImmobiliare != null)
                    tipoDoc = "TipoDocumentoUnitaImmobiliare";

                var nuovoDocumento = new NuovoDocumento(tipoDoc);
                if (nuovoDocumento.ShowDialog() == DialogResult.OK)
                {
                    var file = new FileInfo(nuovoDocumento.DocumentFullPath);

                    // Generazione DTO relativo al documento selezionato
                    DocumentoDTO doc;
                    if (_contratto != null)
                        doc = getDocumentoService().GetNew(_contratto);
                    else if (_condominio != null)
                        doc = getDocumentoService().GetNew(_condominio);
                    else if (_fornitore != null)
                        doc = getDocumentoService().GetNew(_fornitore);
                    else if (_unitaImmobiliare != null)
                        doc = getDocumentoService().GetNew(_unitaImmobiliare);
                    else if (_attivita != null)
                        doc = getDocumentoService().GetNew(_attivita);
                    else
                        doc = new DocumentoDTO();

                    doc.DirectoryName = file.DirectoryName;
                    doc.DataCreazione = DateTime.Now;
                    doc.Tipo = nuovoDocumento.TipoDocumento;
                    doc.Descrizione = nuovoDocumento.DescrizioneDocumento;
                    doc.FileName = file.Name;
                    doc.FileExtension = file.Extension;

                    // Lettura File
                    var data = new byte[0];
                    try
                    {
                        var numBytes = file.Length;
                        var fStream = new FileStream(nuovoDocumento.DocumentFullPath, FileMode.Open, FileAccess.Read);
                        var br = new BinaryReader(fStream);
                        data = br.ReadBytes((int) numBytes);
                        br.Close();
                        fStream.Close();
                    }
                    catch (IOException ex)
                    {
                        CommonMessages.DisplayWarning(string.Format("Non è possibile allegare il file '{0}' perchè risulta aperto in un'applicazione", file.Name));
                    }
                    catch (Exception ex)
                    {
                        _log.ErrorFormat("Errore nell'apertura di un documento - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), Login.Instance.CurrentLogin().Azienda);
                        throw;
                    }

                    if (data.Length > 0)
                    {
                        var docInfo = new DocumentInfo { Body = data, FileName = file.Name, FileExtension = file.Extension };

                        // Salvataggio Documento ... solo se sono in update
                        if (_mode == ListMode.Update)
                        {
                            var form = new ExecuteLoadDataObjectAsync<DocumentMessages>("Il documento è in corso di salvataggio ....." + Environment.NewLine + "Si prega di attendere.");
                            Func<DocumentMessages> loadDati = () => saveDocument(doc, docInfo);
                            form.LoadData(loadDati);
                            form.ShowDialog();

                            if (_contratto != null)
                            {
                                if (form.DataSourceObject.Documento != null)
                                {
                                    var docNew = form.DataSourceObject.Documento;
                                    docNew.VisibileCondomino = nuovoDocumento.VisibileCondomino;
                                    _contratto.Documenti.Add(docNew);
                                }
                                else
                                    CommonMessages.DisplayWarning(string.Format("Si è verificato un errore nel salvataggio del documento.{0}{1}", Environment.NewLine, form.DataSourceObject.Message));
                            }
                            else if(!string.IsNullOrEmpty(form.DataSourceObject.Message))
                                CommonMessages.DisplayWarning(string.Format("Si è verificato un errore nel salvataggio del documento:{0}{1}", Environment.NewLine, form.DataSourceObject.Message));
                            else
                                LoadData(false);

                            form.Dispose();
                        }
                        else if (_mode == ListMode.Select)
                        {
                            doc.Body = docInfo.Body;
                            _documentiNuovi.Add(docInfo);
                            docInfo.BodyText = nuovoDocumento.DescrizioneDocumento;
                            doc.Stato = "NEW";
                            documentoBindingSource.Add(doc);
                            
                            // Tutti i documenti nuovi devono essere selezionati
                            foreach (var row in lista.Rows)
                            {
                                var documento = row.ListObject as DocumentoDTO;
                                if (documento != null && documento.Stato == "NEW")
                                {
                                    if (row.Cells.Exists("SelectColumn"))
                                        row.Cells["SelectColumn"].Value = true;
                                }
                            }

                            if(lista.DisplayLayout.Bands[0].Columns.Exists("SelectColumn"))
                                lista.DisplayLayout.Bands[0].Columns["SelectColumn"].SortIndicator = SortIndicator.Descending;
                        }                        
                    }

                }

                lista.DataBind();
                nuovoDocumento.Dispose();
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore nell'upload di un nuovo documento - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), Login.Instance.CurrentLogin().Azienda);
                throw;
            }
        }
        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);
        }
Exemple #26
0
        private void contextMenuStrip1ItemClicked(object sender, ToolStripItemClickedEventArgs e)
        {
            if (e.ClickedItem.Name == "ricalcolaSpeseToolStripMenuItem")
            {
                contextMenuStrip1.Close(ToolStripDropDownCloseReason.ItemClicked);

                var form = new ExecuteLoadDataObjectAsync<AuthorizationMessages>("Il ricalcolo delle spese è in corso di esecuzione ....." + Environment.NewLine + "Si prega di attendere.");
                Func<AuthorizationMessages> loadDati = () => getModelloContabileService().RicalcoloRipartizioneSpese(_modelloClick.ID);
                form.LoadData(loadDati);
                form.ShowDialog();

                if (string.IsNullOrEmpty(form.DataSourceObject.FatalMessage))
                {
                    if(string.IsNullOrEmpty(form.DataSourceObject.WarnMessage))
                        CommonMessages.DisplayComplete("Le spese sono state correttamente ricalcolate");
                    else
                        CommonMessages.DisplayWarning("ATTENZIONE: Sono stati generati i seguenti avvertimenti." + Environment.NewLine + form.DataSourceObject.WarnMessage);
                }
                else
                    CommonMessages.DisplayComplete("Si sono verificati dei problemi nel ricalcolo delle spese: " + Environment.NewLine + form.DataSourceObject.FatalMessage);

                form.Dispose();
            }
            else if (e.ClickedItem.Name == "aggiornaDescrizioneBolletteToolStripMenuItem")
            {
                if (_modelloClick != null && _modelloClick.ID > 0 && !string.IsNullOrEmpty(_modelloClick.DescrizioneVoceFattura))
                {
                    contextMenuStrip1.Close(ToolStripDropDownCloseReason.ItemClicked);

                    var form = new ExecuteLoadDataObjectAsync<string>("Il ricalcolo delle spese è in corso di esecuzione ....." + Environment.NewLine + "Si prega di attendere.");
                    Func<string> loadDati = () => getUtenzaService().AggiornaDescrizioneBollettaByModello(_modelloClick.ID, _modelloClick.DescrizioneVoceFattura);
                    form.LoadData(loadDati);
                    form.ShowDialog();

                    if (string.IsNullOrEmpty(form.DataSourceObject))
                        CommonMessages.DisplayComplete("La descrizione è stata correttamente aggiornata.");
                    else
                        CommonMessages.DisplayWarning("Si sono verificati dei problemi durante l'aggiornamento della descrizione:" + Environment.NewLine + form.DataSourceObject);
                    form.Dispose();

                }                
            }
            else if(e.ClickedItem.Name == "apriDettaglioToolStripMenuItem")
            {
                if (_modelloClick != null && _modelloClick.ID > 0)
                {
                    var modello = getModelloContabileService().GetModelloContabileListaById(_modelloClick.ID);
                    var form = getDettaglioModelloContabileUIService().GetFormDettaglio(modello, _condominio, null);
                    if (ParentForm != null) 
                        form.MdiParent = ParentForm.MdiParent;
                    form.Show();
                }                
            }

        }
Exemple #27
0
        private void btnConfermaClick(object sender, EventArgs e)
        {
            try
            {
                ristrutturazioniValidation.Validate();
                if (!ristrutturazioniValidation.IsValid)
                {
                    ristrutturazioniValidation.ShowErrorSummary();
                }
                else
                {
                    var condominio = stabili.CondominioSelected;
                    var amministratore = _aziendaService.GetAmministratore();
                    var datiDichiarazione = new DatiDichiarazioneDTO
                    {
                        CapStab = condominio.Indirizzo.Cap,
                        CivicoStab = condominio.Indirizzo.Civico,
                        CodiceFiscaleAmm = amministratore.CodiceFiscale,
                        CodiceFiscaleStab = condominio.CodiceFiscale,
                        ComuneNascitaAmm = amministratore.ComuneNascita,
                        ComuneStab = condominio.Indirizzo.DescrizioneComune,
                        AllegaDocumentazione = decodCheckBox(allegaDocumentazione.Checked),
                        FlagComunicazioneAsl = decodCheckBox(comunicazioneASL.Checked),
                        FlagAutorizzazioneEdilizia = decodCheckBox(copiaAutorizzazioneEdilizia.Checked),
                        FlagConcessioneEdilizia = decodCheckBox(copiaConcessioneEdilizia.Checked),
                        FlagDeliberaAssembleare = decodCheckBox(copiaDeliberaAssembleare.Checked),
                        FlagDenunciaInizioAttivita = decodCheckBox(copiaDenunciaInizioAttivita.Checked),
                        FlagDomandaAccastamento = decodCheckBox(copiaDomandaAccastamento.Checked),
                        FlagIci = decodCheckBox(copiaIci.Checked),
                        DataCompilazione = dataCompilazione.DateTime,
                        DataInizioLavori = dataInizioLavori.DateTime,
                        DataNascitaAmm = amministratore.DataNascita,
                        FlagDichiarazioneConsenso = decodCheckBox(dichiarazioneConsenso.Checked),
                        FlagDichiarazionePossessoDocumentazione = decodCheckBox(dichiarazionePossessoDocumentazione.Checked),
                        FlagAmministratore = decodCheckBox(true),
                        FoglioCatastale = condominio.FoglioCatastale,
                        IndirizzoStab = condominio.Indirizzo.Indirizzo,
                        MappaleCatastale = _condominioService.GetMappaleCatastale(condominio),
                        ProvinciaStab = condominio.Indirizzo.CodiceProvincia,
                        SessoAmm = amministratore.Sesso
                    };

                    if (amministratore.Nome != null)
                        datiDichiarazione.CognomeAmm = amministratore.Cognome.ToUpper();
                    if (amministratore.Nome != null)
                        datiDichiarazione.NomeAmm = amministratore.Nome.ToUpper();

                    // Caricamento asincrono del modulo
                    var form = new ExecuteLoadDataObjectAsync<bool>("Il modulo è in corso di caricamento ....." + Environment.NewLine + "Si prega di attendere.");
                    Func<bool> loadDati = () => loadModulo(datiDichiarazione);
                    form.LoadData(loadDati);
                    form.ShowDialog();
                    form.Dispose();
                    Close();
                }

            }
            catch (Exception ex)
            {
                var idCondominio = 0;
                if (stabili.CondominioSelected != null)
                    idCondominio = stabili.CondominioSelected.ID;

                _log.ErrorFormat("Errore nella compilazione del modulo - {0} - condominio:{1} - azienda:{2}", ex, Gipasoft.Library.Utility.GetMethodDescription(), idCondominio, Security.Login.Instance.CurrentLogin().Azienda);                
                throw;
            }
        }
        private void btnConfermaClick(object sender, EventArgs e)
        {
            validationSummary1.Validate();

            if (validationSummary1.IsValid)
            {
                var personeSelezionate = Windows.Forms.Library.InfragisticsHelperMethods.DataGridHelper.GetRigheSelezionate<PersonaContattoDTO>(listaPersone, true);
                var soggettiCondominio = new List<SoggettoCondominioDTO>(personeSelezionate.Count);

                //TODO: Da migliorare per evitare eccessivamente chiamate al server (una per ogni persona) una sola chiamataper tutte le persone (GetByCondominioPersone(int idCondominio, IList<int> idPersone))
                foreach (var personaContattoDTO in personeSelezionate)
                    soggettiCondominio.AddRange(getSoggettoService().GetByCondominioPersona(_condominio, personaContattoDTO.ID));
                var idCondomini = soggettiCondominio.Select(item => item.ID).ToList();

                var form = new ExecuteLoadDataObjectAsync<ResultRiparto>("E' in corso il caricamento dei dati ....." + Environment.NewLine + "Si prega di attendere.");
                Func<ResultRiparto> loadDati;
                if(getTipoRiparto() == TipoRendiconto.Consuntivo)
                    loadDati = () => getBilancioService().GetRipartizioneConsuntivo(_esercizio.ID, null, null, null, false, false, false, getTipoAccorpamento(), idCondomini);
                else
                    loadDati = () => getBilancioService().GetRipartizionePreventivo(_esercizio.ID, null, null, null, false, getTipoAccorpamento(), true, false, false, idCondomini);
                
                form.LoadData(loadDati);
                form.ShowDialog();

                if (string.IsNullOrEmpty(form.DataSourceObject.Message))
                {
                    if (form.DataSourceObject.Riparto != null)
                    {
                        IList<ReportRipartizioneBilancioDTO> ripartoPersona = form.DataSourceObject.Riparto;
                        form.Dispose();

                        EsercizioDTO esercizio = null;
                        if (esercizi.SelectedItem != null)
                            esercizio = esercizi.SelectedItem.ListObject as EsercizioDTO;

                        var parameters = new BilancioConsuntivoReportParameters
                        {
                            TipoAccorpamento = getTipoAccorpamento()
                        };
                        if (esercizio != null)
                        {
                            parameters.DataPrimaRegistrazione = esercizio.DataApertura.GetValueOrDefault();
                            parameters.DataUltimaRegistrazione = esercizio.DataChiusura.GetValueOrDefault();
                            parameters.DataFineEsercizio = esercizio.DataChiusura.GetValueOrDefault();
                        }

                        if (string.IsNullOrEmpty(_note) && notePredefinite.Value != null)
                        {
                            var fakeForm = new GestioneTestoHTML(null, getNotaPredefinita(), MergeFieldType.Default, true, true, true);
                            _note = fakeForm.GetTesto("RTF");
                            fakeForm.Dispose();
                        }

                        var impostazioneReportDto = getImpostazioneReportDto();
                        if (impostazioneReportDto != null)
                        {
                            var unita = new Dictionary<int, IList<IList<UnitaImmobiliareListaDTO>>>();
                            foreach (var personaContattoDTO in personeSelezionate)
                            {
                                var unitaImmobiliari = getUnitaImmobiliareService().GetByPersonaEsercizio(personaContattoDTO.ID, _esercizio.ID);
                                var unitaPerPersona = new List<IList<UnitaImmobiliareListaDTO>>();

                                if (parameters.TipoAccorpamento == TipoAccorpamentoRateEnum.Nessuno)
                                {
                                    foreach (var unitaImmobiliareListaDTO in unitaImmobiliari)
                                    {
                                        unitaPerPersona.Add(new List<UnitaImmobiliareListaDTO> { unitaImmobiliareListaDTO });
                                    }
                                }
                                else if (parameters.TipoAccorpamento == TipoAccorpamentoRateEnum.Persona)
                                {
                                    unitaPerPersona.Add(unitaImmobiliari);
                                }
                                else if (parameters.TipoAccorpamento == TipoAccorpamentoRateEnum.Personalizzato)
                                {
                                    var unitaGroup = unitaImmobiliari.GroupBy(item => item.UnitaImmobiliarePrincipale);
                                    foreach (var unitaCustomGroup in unitaGroup)
                                    {
                                        unitaPerPersona.Add(unitaCustomGroup.ToList());
                                    }
                                }

                                unita.Add(personaContattoDTO.ID, unitaPerPersona);
                            }

                            var anteprima = new AnteprimaReportRipartoPersona(ripartoPersona, _condominio, _esercizio, personeSelezionate, unita, parameters, impostazioneReportDto, getReportKey(), _note);
                            anteprima.ShowDialog();
                            anteprima.Dispose();
                        }
                        else
                        {
                            CommonMessages.DisplayWarning("Non sono state trovate le impostazioni del report");
                        }
                    }
                }
                else
                {
                    CommonMessages.DisplayWarning($"Si sono verificati i seguenti errori nell'elaborazione del riparto:{Environment.NewLine}{form.DataSourceObject.Message}");
                    form.Dispose();
                }
            }
            else
                validationSummary1.ShowErrorSummary();
        }
        public void LoadData(CondominioDTO condominio, EsercizioDTO esercizio, TipoListaRate tipoLista, bool isAllowEmpty, bool rateAcconto, TipoAccorpamentoRateEnum tipo)
        {
            try
            {
                Clear();

                _condominio = condominio;
                _esercizio = esercizio;
                _tipo = tipo;
                _rateAcconto = rateAcconto;

                if (condominio != null && esercizio != null && listaRateSoggetti != null)
                {
                    loadConti();
                    _pianoRateale = getRateCondominiService().GetPianoRatealeByEsercizio(_esercizio.ID, false);
                    if (_pianoRateale != null &&  _pianoRateale.ID > 0)
                        _tipo = _pianoRateale.Tipo;

                    var form = new ExecuteLoadDataListAsync<RataSoggettoDTO>("Le rate sono in corso di caricamento ....." + Environment.NewLine + "Si prega di attendere.");
                    Func<List<RataSoggettoDTO>> loadDati = () => getRateCondominiService().GetByEsercizio(esercizio.ID);
                    form.LoadData(loadDati);
                    form.ShowDialog();

                    if (form.DataSourceObject == null)
                    {
                        ParentForm?.Close();
                        return;
                    }

                    _rateSoggetti = form.DataSourceObject;
                    form.Dispose();

                    var formSaldi = new ExecuteLoadDataObjectAsync<ResultSaldiCondomini>("I saldi dei condomini sono in corso di caricamento ....." + Environment.NewLine + "Si prega di attendere.");
                    Func<ResultSaldiCondomini> loadSaldi = () => getRateCondominiService().GetSaldiSoggetti(esercizio.ID, null, null, _tipo);
                    formSaldi.LoadData(loadSaldi);
                    formSaldi.ShowDialog();

                    if ((string.IsNullOrEmpty(formSaldi.DataSourceObject.Message) && formSaldi.DataSourceObject.Saldi != null) ||  !_isCreazione)
                    {

                        _saldiSoggetti = formSaldi.DataSourceObject.Saldi;
                        formSaldi.Dispose();
                        if (_rateSoggetti.Count > 0 || isAllowEmpty)
                        {
                            btnStampa.Visible = true;
                            btnConferma.Visible = true;
                            chkDataEmissione.Visible = true;
                            sceltaTipoLista.Visible = true;
                            listaRateSoggetti.Visible = true;

                            if (_isCreazione)
                            {
                                btnStampa.Visible = false;
                                nuovaDataPanel.Visible = false;
                            }
                            else
                            {
                                btnStampa.Visible = true;
                                nuovaDataPanel.Visible = true;
                            }

                            // Se è ancora a null carico la lista dei soggetti relativi all'esercizio.
                            if (_soggetti == null)
                                _soggetti = getRateCondominiService().GetPartecipanti(esercizio.ID, _tipo);

                            if (tipoLista == TipoListaRate.Pivot)
                            {
                                try
                                {
                                    var resultMessage = getRateCondominiService().ConvertRateSoggettiToPivot(_rateSoggetti, _saldiSoggetti, null, _allowInvertiSegno, _pianoRateale, _isCreazione);
                                    if (resultMessage.DataTable == null)
                                    {
                                        CommonMessages.DisplayWarning(string.Format("Si sono verificati i seguenti errori:{1}{0}{1}Si prega di riprovare", resultMessage.FatalMessage, Environment.NewLine));
                                        ParentForm?.Close();
                                        return;
                                    }
 
                                    listaRateSoggetti.DataSource = resultMessage.DataTable;
                                    setGridLayout(tipoLista);
                                    setRowsLayout();
                                }
                                catch (Exception ex)
                                {
                                    _log.ErrorFormat("Errore inaspettato durante il caricamento delle rate - DATA SOURCE - {0} - condominio:{1} - esercizio:{2}", ex, Utility.GetMethodDescription(), _condominio.ID, _esercizio.ID);
                                }
                            }
                            else if (tipoLista == TipoListaRate.Editabile)
                            {
                                listaRateSoggetti.DataSource = _rateSoggetti;

                                listaRateSoggetti.DisplayLayout.ValueLists.Clear();
                                listaRateSoggetti.DisplayLayout.ValueLists.Add(DataSourceHelper.GetValueList(_soggetti, "ID", "DisplayNominativo", "SoggettiCondominio"));
                                listaRateSoggetti.DisplayLayout.Bands[0].Columns["IdSoggettoCondominio"].ValueList = listaRateSoggetti.DisplayLayout.ValueLists["SoggettiCondominio"];
                                setGridLayout(tipoLista);
                            }

                            listaRateSoggetti.DisplayLayout.Bands[0].Summaries.Clear();
                            foreach (var column in listaRateSoggetti.DisplayLayout.Bands[0].Columns)
                            {
                                if (column.DataType == typeof (decimal))
                                    DataGridHelper.AddSummary(listaRateSoggetti.DisplayLayout.Bands[0], column.Key, "c");
                            }
                        }
                        else
                        {
                            listaRateSoggetti.DataSource = new List<RataSoggettoDTO>();
                            CommonMessages.DisplayWarning("Non sono presenti rate.");
                            var parentForm = _parentForm as MainContabilita;
                            if (parentForm != null)
                                parentForm.ToClose = true;
                            else if (ParentForm != null)
                                ((MainContabilita) ParentForm).ToClose = true;
                        }

                        listaRateSoggetti.PerformAction(UltraGridAction.FirstRowInBand);

                        loadPianoRateale();
                    }
                    else
                    {
                        CommonMessages.DisplayWarning($"Si sono verificati degli errori nel caricamento dei saldi:{Environment.NewLine}{formSaldi.DataSourceObject.Message}");
                        formSaldi.Dispose();
                    }
                }

            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato durante il caricamento dei dati del piano rateale - 1 - {0} - condominio:{1} - esercizio:{2}", ex, Utility.GetMethodDescription(), _condominio.ID, _esercizio.ID);
                throw;
            }
        }
Exemple #30
0
        private void btnRicalcoloModelliClick(object sender, EventArgs e)
        {
            if (_condominio != null)
            {
                if (CommonMessages.DisplayConfirm("Sei sicuro di volere ricalcolare le spese per tutti i modelli?") == DialogResult.Yes)
                {
                    try
                    {
                        var form = new ExecuteLoadDataObjectAsync<IList<string>>("Il ricalcolo delle spese è in corso di esecuzione ....." + Environment.NewLine + "Si prega di attendere.");
                        Func<IList<string>> loadDati = () => getModelloContabileService().RicalcoloRipartizioneSpeseByCondominio(_condominio.ID);
                        form.LoadData(loadDati);
                        form.ShowDialog();

                        if (form.DataSourceObject != null)
                        {
                            var messageList = form.DataSourceObject;
                            if (messageList.Count > 0)
                            {
                                var message = messageList.Aggregate(string.Empty, (current, singleMessage) => current + (" - " + singleMessage + Environment.NewLine));
                                CommonMessages.DisplayWarning("Si sono verificati i seguenti errori nel ricalcolo delle spese:" + Environment.NewLine + message);
                            }
                            else
                                CommonMessages.DisplayComplete("Le spese sono state correttamente ricalcolate");
                        }

                        form.Dispose();
                    }
                    catch (Exception ex)
                    {
                        _log.ErrorFormat("Errore nel ricalcolo dei modelli - {0} - esercizio:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), _esercizio.ID, Security.Login.Instance.CurrentLogin().Azienda);                     
                        throw;
                    }
                }
            }
        }