Exemple #1
0
        public IList<TestataSollecitoDTO> GetSolleciti(int? idEsercizio, Dictionary<int, TipoIndirizzo> idCondomini, bool groupByPersone, DateTime? dataRate, DateTime? dataVersamenti, decimal? importoLimite, decimal? importoCompetenza, DateTime dataSollecito, bool stampaProprietario, int? idBanca, int idModelloLettera, string testoModelloLettera, DateTime? dataRegistrazioneContabile, int? idConto, int? idSottoConto, bool storico, bool sollecitaProprietarioConduzione)
        {
            try
            {
                var solleciti = new List<TestataSollecitoDTO>(idCondomini.Count);
                var listaSolleciti = new List<Sollecito>(idCondomini.Count);

                Esercizio esercizio = null;
                if (idEsercizio != null)
                    esercizio = _daoFactory.GetEsercizioDao().GetById(idEsercizio.Value, false);

                var dataFinale = new DateTime(DateTime.Today.Year, 12, 31);

                var modello = _daoFactory.GetModelloLetteraTestoDao().Find(idModelloLettera, false);

                // ==========================================================================================
                //  Leggo subito tutti i soggetti le rate e i versamenti
                // ==========================================================================================
                var idCondominiList = idCondomini.Select(item => item.Key).ToList();

                // rate
                var rateSoggetti = !groupByPersone ? _daoFactory.GetRataSoggettoDao().GetByEsercizioSoggetti(idEsercizio, null, idCondominiList, dataRate) : _daoFactory.GetRataSoggettoDao().GetByEsercizioPersone(idEsercizio, null, idCondominiList, dataRate);

                // soggetti
                IList<SoggettoCondominio> soggetti = null;
                IList<SoggettoCondominio> soggettiStampa = null;
                IList<Persona> persone = null;
                if (!groupByPersone)
                    soggetti = _daoFactory.GetSoggettoCondominioDao().GetAttiviByEsercizioSoggetti(esercizio, idCondominiList);
                else
                {
                    persone = _daoFactory.GetPersonaDao().GetAttiviByEsercizioSoggetti(esercizio, idCondominiList);
                    soggettiStampa = esercizio != null ? _daoFactory.GetSoggettoCondominioDao().GetAttiviByEsercizio(esercizio, dataFinale) : _daoFactory.GetSoggettoCondominioDao().GetAttiviByAzienda(modello.Azienda.ID);
                }

                // versamenti
                IList<VersamentoSoggetto> versamentiSoggetto;
                IList<VersamentiRate> versamentiRate;
                if (!groupByPersone)
                {
                    versamentiSoggetto = _daoFactory.GetVersamentoSoggettoDao().GetByEsercizioSoggetti(idEsercizio, idCondominiList);
                    versamentiRate = _daoFactory.GetVersamentiRateDao().GetByEsercizioSoggetti(idEsercizio, idCondominiList);
                }
                else
                {
                    versamentiSoggetto = _daoFactory.GetVersamentoSoggettoDao().GetByEsercizioPersone(idEsercizio, idCondominiList);
                    versamentiRate = _daoFactory.GetVersamentiRateDao().GetByEsercizioPersone(idEsercizio, idCondominiList);
                }

                DatiBancariCondomini bancaSollecito = null;
                if (idBanca != null)
                    bancaSollecito = _daoFactory.GetDatiBancariCondominiDao().Find(idBanca.Value, false);

                // ==========================================================================================
                //  Loop per i soggetti per generare i dati di stampa
                // ==========================================================================================
                foreach (var kvp in idCondomini)
                {
                    var id = kvp.Key;

                    try
                    {
                        SoggettoCondominio soggetto = null;
                        Persona persona = null;
                        if (soggetti != null)
                            soggetto = soggetti.FirstOrDefault(item => item.ID == kvp.Key) ?? _daoFactory.GetSoggettoCondominioDao().Find(id, false);
                        else if (persone != null)
                            persona = persone.FirstOrDefault(item => item.ID == kvp.Key) ?? _daoFactory.GetPersonaDao().Find(id, false);

                        if (persona == null && soggetto == null)
                        {
                            _log.ErrorFormat("Non trovata persona/soggetto - {0} - id:{1} - idCondomini:{2}", Utility.GetMethodDescription(), id, idEsercizio.GetValueOrDefault(), idCondomini != null ? string.Join(",", idCondomini.SelectMany(item => item.Key.ToString())) : "<NULL>");
                            continue;
                        }

                        var rateScadute = !groupByPersone ? rateSoggetti.Where(item => item.Soggetto.ID == kvp.Key).ToList() : rateSoggetti.Where(item => item.Soggetto.Persona.ID == kvp.Key).ToList();

                        // -----------------------------
                        // Calcolo importi
                        // -----------------------------
                        var importoScaduto = rateScadute.Sum(rata => rata.Importo);
                        var importoVersato = rateScadute.Sum(rata => rata.GetImportoVersato(dataVersamenti));

                        decimal importoVersatoSenzaRata;
                        IList<VersamentoSoggetto> altriVersamenti;
                        IList<VersamentiRate> altriVersamentiRate;
                        if (soggetto != null)
                        {
                            altriVersamenti = versamentiSoggetto.Where(item => item.Soggetto.ID == kvp.Key).ToList();
                            altriVersamentiRate = versamentiRate.Where(item => item.Versamento.Soggetto.ID == kvp.Key).ToList();
                            importoVersatoSenzaRata = altriVersamenti.Sum(versamento => versamento.Importo) - altriVersamentiRate.Sum(item => item.Importo);
                        }
                        else
                        {
                            altriVersamenti = versamentiSoggetto.Where(item => item.Soggetto.Persona.ID == kvp.Key).ToList();
                            altriVersamentiRate = versamentiRate.Where(item => item.Versamento.Soggetto.Persona.ID == kvp.Key).ToList();
                            importoVersatoSenzaRata = altriVersamenti.Sum(versamento => versamento.Importo) - altriVersamentiRate.Sum(item => item.Importo);
                        }

                        var importoDaSollecitare = importoScaduto - importoVersato - importoVersatoSenzaRata;

                        if (importoLimite == null || Math.Abs(importoDaSollecitare) >= importoLimite.Value)
                        {
                            if (persona == null)
                                persona = soggetto.Persona;
                            var condominio = soggetto != null ? soggetto.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.CondominioRiferimento : persona.SoggettiCondominio.Select(item => item.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.CondominioRiferimento).FirstOrDefault();

                            var recapito = _personaService.GetRecapito(persona, kvp.Value);

                            if (bancaSollecito == null)
                                bancaSollecito = condominio.DatiBancariPrincipale;

                            var testata = new TestataSollecitoDTO
                            {
                                Nominativo = getNominativoPresso(persona, soggetto, recapito),
                                Indirizzo = recapito != null ? recapito.GetIndirizzoCompleto() : string.Empty,
                                Cap = recapito.Cap,
                                Comune = recapito.ComuneDisplayName,
                                Titolo = Decodifica.Instance.GetElement("TitoloPersona", persona.Titolo).Descrizione,
                                ImportoCompetenza = importoCompetenza,
                                DataLettera = dataSollecito,
                                DataRate = dataRate.GetValueOrDefault(),
                                StampaProprietario = stampaProprietario,
                                GroupByPersona = groupByPersone,
                                OggettoLettera = string.IsNullOrEmpty(modello.Oggetto) ? string.Empty : modello.Oggetto.Trim(),
                                TestoLettera = formattaTestoLettera(condominio, bancaSollecito, string.IsNullOrEmpty(testoModelloLettera) ? modello.Testo : testoModelloLettera.Trim()),
                            };

                            if (soggetto != null)
                            {
                                testata.Id = soggetto.ID;
                                testata.IdSoggettoCondominio = soggetto.ID;
                                testata.IdPersona = soggetto.Persona.ID;
                                testata.IdUnitaImmobiliare = soggetto.UnitaImmobiliare.ID;
                                testata.Interno = soggetto.UnitaImmobiliare.InternoCompleto;
                                testata.Piano = soggetto.UnitaImmobiliare.Piano;
                                testata.Ordine = soggetto.UnitaImmobiliare.Ordine.GetValueOrDefault();
                                testata.DescrizioneUnitaImmobiliare = soggetto.UnitaImmobiliare.Descrizione;
                                testata.Subalterno = soggetto.UnitaImmobiliare.Subalterno;
                            }
                            else if (persona != null)
                            {
                                testata.Id = persona.ID;
                                testata.IdPersona = persona.ID;
                            }

                            var righeCondominio = condominio.IndirizzoCompleto.Split('&');
                            testata.DescrizioneCompletaCondominio = $"Condominio: {righeCondominio[0]}{Environment.NewLine}{righeCondominio[1]} - {righeCondominio[2]} - {righeCondominio[3]}";

                            // Se la stampa è per persona e viee richiesta la stampa per conoscenza al proprietario occorre leggere il soggettocondominio (soggettoStampa) bugid#8573
                            var soggettoStampa = soggetto;
                            if (soggettoStampa == null && persona != null)
                                soggettoStampa = soggettiStampa.Where(item => item.Persona.ID == persona.ID).OrderBy(item => item.UnitaImmobiliare.TipoUnitaImmobiliare.ID).FirstOrDefault();

                            if (stampaProprietario && soggettoStampa != null && soggettoStampa.Tipo == TipoSoggetto.Conduttore)
                            {
                                var proprietario = soggettoStampa.UnitaImmobiliare.GetProprietarioPrincipale(dataFinale) ??
                                                   soggettoStampa.UnitaImmobiliare.Proprietari.OrderByDescending(item => item.DataInizio.GetValueOrDefault()).FirstOrDefault();
                                if (proprietario != null)
                                    testata.NominativoProprietario = proprietario.DisplayName;

                                if (proprietario != null)
                                {
                                    var recapitoProprietario = _personaService.GetRecapito(proprietario.Persona, kvp.Value);
                                    if (recapitoProprietario != null)
                                    {
                                        testata.IndirizzoProprietario = recapitoProprietario.GetIndirizzoCompleto();
                                        testata.ComuneProprietario = recapitoProprietario.ComuneDisplayName;
                                        testata.CapProprietario = recapitoProprietario.Cap;
                                    }
                                }
                            }

                            if (recapito.Comune != null)
                                testata.Provincia = recapito.Comune.ProvinciaAppartenenza.Codice;

                            // ----------------------------------------------
                            //  Dettaglio Rate
                            // ----------------------------------------------
                            decimal importoTotaleDaVersare = 0;

                            // Rate con versamenti
                            foreach (var rata in rateScadute)
                            {
                                try
                                {
                                    var dettaglio = new DettaglioSollecitoDTO
                                    {
                                        Id = rata.ID,
                                        DataScadenza = rata.DataScadenza,
                                        IdTestataSollecito = testata.Id,
                                        ProgressivoRata = rata.PianoRatealeDettaglio?.Progressivo ?? rata.Progressivo,
                                        Importo = rata.Importo,
                                        ImportoPagato = rata.GetImportoVersato(dataVersamenti),
                                        CodiceRata = rata.ID,
                                        IdEsercizio = rata.Esercizio.ID,
                                        IdSoggetto = rata.Soggetto.ID,
                                        DescrizioneSoggetto = rata.Soggetto.DisplayName,
                                        DescrizioneEsercizio = rata.Esercizio.DisplayName
                                    };

                                    if (groupByPersone)
                                    {
                                        dettaglio.IdUnitaImmobiliare = rata.Soggetto.UnitaImmobiliare.ID;
                                        dettaglio.Interno = rata.Soggetto.UnitaImmobiliare.InternoCompleto;
                                        dettaglio.Piano = rata.Soggetto.UnitaImmobiliare.Piano;
                                        dettaglio.Ordine = rata.Soggetto.UnitaImmobiliare.Ordine.GetValueOrDefault();
                                        dettaglio.DescrizioneUnitaImmobiliare = rata.Soggetto.UnitaImmobiliare.TipoUnitaImmobiliare.Descrizione + " - " + rata.Soggetto.UnitaImmobiliare.Descrizione;
                                        dettaglio.Subalterno = rata.Soggetto.UnitaImmobiliare.Subalterno;
                                    }

                                    if (soggetto?.PercentualeRiferimento != null)
                                        dettaglio.PercentualePossesso = Convert.ToInt32(soggetto.PercentualeRiferimento.Value);
                                    dettaglio.ImportoDaVersare = dettaglio.Importo - dettaglio.ImportoPagato;

                                    if (rata.Versamenti.Count > 0)
                                        dettaglio.DataUltimoPagamento = IesiGenericCollections<VersamentiRate>.GetByIndex(rata.Versamenti, rata.Versamenti.Count - 1).Versamento.Data;

                                    testata.Dettagli.Add(dettaglio);
                                    importoTotaleDaVersare += dettaglio.ImportoDaVersare;
                                }
                                catch (Exception ex)
                                {
                                    _log.ErrorFormat("Errore inaspettato nel calcolo del sollecito per soggetto - DETTAGLIO RATE CON VERSAMENTI - {0} - soggetto:{1} - rata:{2}", ex, Utility.GetMethodDescription(), id, rata.ID);
                                    throw;
                                }
                            }

                            // Versamenti senza rate associate
                            // TODO: elaborare versamenti rate e versamentisoggetto per ottenere una lista dei versamenti fuori piano rateale
                            foreach (var versamento in altriVersamenti)
                            {
                                try
                                {
                                    var versamento1 = versamento;
                                    var importoPagato = versamento.Importo - altriVersamentiRate.Where(item => item.Versamento.ID == versamento1.ID).Sum(item => item.Importo);
                                    if (importoPagato > 0)
                                    {
                                        var dettaglio = new DettaglioSollecitoDTO
                                        {
                                            DataScadenza = DateTime.MaxValue,
                                            DataUltimoPagamento = versamento.Data,
                                            IdTestataSollecito = testata.Id,
                                            ImportoPagato = importoPagato,
                                            IdEsercizio = versamento.Esercizio.ID,
                                            IdSoggetto = versamento.Soggetto.ID,
                                            DescrizioneSoggetto = versamento.Soggetto.DisplayName,
                                            DescrizioneEsercizio = versamento.Esercizio.DisplayName,
                                            ImportoDaVersare = importoPagato * -1
                                        };

                                        if (groupByPersone)
                                        {
                                            dettaglio.IdUnitaImmobiliare = versamento.Soggetto.UnitaImmobiliare.ID;
                                            dettaglio.Interno = versamento.Soggetto.UnitaImmobiliare.InternoCompleto;
                                            dettaglio.Piano = versamento.Soggetto.UnitaImmobiliare.Piano;
                                            dettaglio.Ordine = versamento.Soggetto.UnitaImmobiliare.Ordine.GetValueOrDefault();
                                            dettaglio.DescrizioneUnitaImmobiliare = versamento.Soggetto.UnitaImmobiliare.TipoUnitaImmobiliare.Descrizione + " - " + versamento.Soggetto.UnitaImmobiliare.Descrizione;
                                            dettaglio.Subalterno = versamento.Soggetto.UnitaImmobiliare.Subalterno;
                                        }

                                        if (soggetto?.PercentualeRiferimento != null)
                                            dettaglio.PercentualePossesso = Convert.ToInt32(soggetto.PercentualeRiferimento.Value);

                                        testata.Dettagli.Add(dettaglio);
                                        importoTotaleDaVersare -= dettaglio.ImportoPagato;
                                    }
                                }
                                catch (Exception ex)
                                {
                                    _log.ErrorFormat("Errore inaspettato nel calcolo del sollecito per soggetto - VERSAMENTO SENZA RATE ASSOCIATE - {0} - Id:{1} - versamento:{2}", ex, Utility.GetMethodDescription(), id, versamento.ID);
                                    throw;
                                }
                            }

                            testata.ImportoTotaleDaVersare = importoTotaleDaVersare;
                            testata.TipoIndirizzo = kvp.Value;
                            solleciti.Add(testata);
                            
                            // ================================================================================
                            //  Se richiesto aggiungo per i proprietari le rate di conduzione
                            // ================================================================================
                            if (sollecitaProprietarioConduzione)
                            {
                                if (soggetto != null)
                                {
                                    var conduttori = soggetto.UnitaImmobiliare.Conduttori;
                                    if (conduttori.Count > 0)
                                    {
                                        var idConduttori = new List<int>(conduttori.Count);
                                        idConduttori.AddRange(conduttori.Select(soggettoCondominio => soggettoCondominio.ID));
                                        var rateConduttori = _rateService.GetRataByEsercizioSoggetti(idEsercizio, idConduttori, dataRate, false);
                                        var versamentiConduttori = _versamentiService.GetVersamentiByEsercizioSoggetti(idEsercizio, idConduttori);

                                        var importoCompetenzaConduzione = rateConduttori.Sum(item => item.Importo.GetValueOrDefault());
                                        var importoVersatoConduzione = versamentiConduttori.Sum(item => item.Importo);
                                        testata.ImportoCompetenza += importoCompetenzaConduzione;
                                        testata.ImportoTotaleDaVersare += (importoCompetenzaConduzione - importoVersatoConduzione);

                                        // Dettaglio rate
                                        IList<VersamentoSoggetto> versamentiElaborati = new List<VersamentoSoggetto>();
                                        foreach (var rataSoggettoDTO in rateConduttori)
                                        {
                                            var dettaglio = new DettaglioSollecitoDTO
                                            {
                                                Id = rataSoggettoDTO.ID,
                                                DataScadenza = rataSoggettoDTO.DataScadenza,
                                                IdTestataSollecito = testata.Id,
                                                ProgressivoRata = rataSoggettoDTO.Progressivo,
                                                Importo = rataSoggettoDTO.Importo.GetValueOrDefault(),
                                                ImportoPagato = rataSoggettoDTO.ImportoPagato.GetValueOrDefault(),
                                                CodiceRata = rataSoggettoDTO.ID,
                                                IdEsercizio = rataSoggettoDTO.IdEsercizio,
                                                IdSoggetto = rataSoggettoDTO.IdSoggettoCondominio,
                                                DescrizioneSoggetto = rataSoggettoDTO.DescrizioneSoggettoCondominio,
                                                DescrizioneEsercizio = rataSoggettoDTO.DescrizioneEsercizio
                                            };

                                            if (groupByPersone)
                                            {
                                                dettaglio.IdUnitaImmobiliare = rataSoggettoDTO.IdUnitaImmobiliare;
                                                dettaglio.Ordine = rataSoggettoDTO.OrdineUnitaImmobiliare;
                                                dettaglio.DescrizioneUnitaImmobiliare = rataSoggettoDTO.DescrizioneUnitaImmobiliare;
                                                dettaglio.Subalterno = rataSoggettoDTO.Subalterno;
                                            }

                                            if (soggetto?.PercentualeRiferimento != null)
                                                dettaglio.PercentualePossesso = Convert.ToInt32(soggetto.PercentualeRiferimento.Value);
                                            dettaglio.ImportoDaVersare = dettaglio.Importo - dettaglio.ImportoPagato;

                                            var rata = _daoFactory.GetRataSoggettoDao().Find(rataSoggettoDTO.ID, false);
                                            if (rata != null && rata.Versamenti.Count > 0)
                                            {
                                                foreach (var rateVersamenti in rata.Versamenti)
                                                    versamentiElaborati.Add(rateVersamenti.Versamento);

                                                dettaglio.DataUltimoPagamento = IesiGenericCollections<VersamentiRate>.GetByIndex(rata.Versamenti, rata.Versamenti.Count - 1).Versamento.Data;
                                            }

                                            testata.Dettagli.Add(dettaglio);
                                        }
                                        
                                        // Versamenti fuori piano rateale
                                        foreach (var versamentoSoggetto in versamentiConduttori)
                                        {
                                            if (!versamentiElaborati.Contains(versamentoSoggetto) && versamentoSoggetto.Importo > 0)
                                            {
                                                var dettaglioVersamento = new DettaglioSollecitoDTO
                                                {
                                                    DataScadenza = DateTime.MaxValue,
                                                    DataUltimoPagamento = versamentoSoggetto.Data,
                                                    IdTestataSollecito = testata.Id,
                                                    ImportoPagato = versamentoSoggetto.Importo,
                                                    IdEsercizio = versamentoSoggetto.Esercizio.ID,
                                                    IdSoggetto = versamentoSoggetto.Soggetto.ID,
                                                    DescrizioneSoggetto = versamentoSoggetto.Soggetto.DisplayName,
                                                    DescrizioneEsercizio = versamentoSoggetto.Esercizio.DisplayName,
                                                    ImportoDaVersare = versamentoSoggetto.Importo * -1
                                                };

                                                if (groupByPersone)
                                                {
                                                    dettaglioVersamento.IdUnitaImmobiliare = versamentoSoggetto.Soggetto.UnitaImmobiliare.ID;
                                                    dettaglioVersamento.Interno = versamentoSoggetto.Soggetto.UnitaImmobiliare.InternoCompleto;
                                                    dettaglioVersamento.Piano = versamentoSoggetto.Soggetto.UnitaImmobiliare.Piano;
                                                    dettaglioVersamento.Ordine = versamentoSoggetto.Soggetto.UnitaImmobiliare.Ordine.GetValueOrDefault();
                                                    dettaglioVersamento.DescrizioneUnitaImmobiliare = versamentoSoggetto.Soggetto.UnitaImmobiliare.TipoUnitaImmobiliare.Descrizione + " - " + versamentoSoggetto.Soggetto.UnitaImmobiliare.Descrizione;
                                                    dettaglioVersamento.Subalterno = versamentoSoggetto.Soggetto.UnitaImmobiliare.Subalterno;
                                                }

                                                testata.Dettagli.Add(dettaglioVersamento);
                                            }
                                        }
                                    }

                                }
                            }

                            // ================================================================
                            // Creo gli oggetti sollecito se richiesto
                            // ================================================================
                            if (storico)
                            {
                                var esercizioSollecito = (esercizio ?? _daoFactory.GetEsercizioDao().GetEsercizioCompetenza(condominio, DateTime.Today)) ?? _esercizioService.GetUltimoEsercizioOrdinario(condominio.ID);
                                if (esercizioSollecito != null)
                                {
                                    Sollecito sollecito;

                                    var testoLettera = testoModelloLettera;
                                    if (string.IsNullOrEmpty(testoLettera))
                                        testoLettera = modello.Testo;
                                    if (!string.IsNullOrEmpty(testoLettera))
                                        testoLettera = testoLettera.Trim();
                                    if (soggetto != null)
                                    {
                                        sollecito = new Sollecito(esercizioSollecito, soggetto, dataSollecito, dataRate.GetValueOrDefault(), importoLimite.GetValueOrDefault(), testata.ImportoTotaleDaVersare, bancaSollecito, modello.Oggetto, testoLettera)
                                        {
                                            ImportoCompetenza = importoCompetenza,
                                            TipoIndirizzo = kvp.Value,
                                            StampaProprietario = stampaProprietario,
                                            GroupByPersona = groupByPersone
                                        };
                                    }
                                    else
                                    {
                                        sollecito = new Sollecito(esercizioSollecito, persona, dataSollecito, dataRate.GetValueOrDefault(), importoLimite.GetValueOrDefault(), testata.ImportoTotaleDaVersare, bancaSollecito, modello.Oggetto, testoLettera)
                                        {
                                            ImportoCompetenza = importoCompetenza,
                                            TipoIndirizzo = kvp.Value,
                                            StampaProprietario = stampaProprietario,
                                            GroupByPersona = groupByPersone
                                        };
                                    }

                                    foreach (var dett in testata.Dettagli)
                                    {
                                        var dettaglio = new DettaglioSollecito(sollecito, dett.Importo, dett.ImportoDaVersare, dett.ImportoPagato)
                                        {
                                            DataUltimoPagamento = dett.DataUltimoPagamento
                                        };

                                        if (dett.DataScadenza != DateTime.MaxValue)
                                            dettaglio.DataScadenzaRata = dett.DataScadenza;

                                        if (dett.CodiceRata != null)
                                            dettaglio.Rata = rateSoggetti.FirstOrDefault(item => item.ID == dett.CodiceRata) ?? _daoFactory.GetRataSoggettoDao().GetById(dett.CodiceRata.Value, false);
                                    }
                                    listaSolleciti.Add(sollecito);
                                    _daoFactory.GetSollecitoDao().SaveOrUpdate(sollecito);
                                }
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        _log.ErrorFormat("Errore inaspettato nel calcolo del sollecito per soggetto - {0} - esercizio:{1} - soggetto:{2}", ex, Utility.GetMethodDescription(), idEsercizio, id);
                        throw;
                    }
                }

                // ================================================================================================================
                // Rimuovo eventuali dettagli con importo a 0
                // ================================================================================================================
                foreach (var testataSollecitoDTO in solleciti)
                {
                    var dettagliDaRimuovere = testataSollecitoDTO.Dettagli.Where(dettaglioSollecitoDTO => dettaglioSollecitoDTO.Importo == 0 && dettaglioSollecitoDTO.ImportoDaVersare == 0 && dettaglioSollecitoDTO.ImportoPagato == 0).ToList();

                    foreach (var dettaglioSollecitoDTO in dettagliDaRimuovere)
                        testataSollecitoDTO.Dettagli.Remove(dettaglioSollecitoDTO);
                }

                // ================================================================================================================
                // Creo i movimenti di addebito - una testata per ogni Esercizio (possibile solo se è stato richiesto lo STORICO)
                // ================================================================================================================
                try
                {
                    if (importoCompetenza > 0)
                    {
                        var sollecitiPerEsercizio = listaSolleciti.GroupBy(item => item.Esercizio);

                        foreach (var sollecitiEsercizio in sollecitiPerEsercizio)
                        {
                            var esercizioAddebito = sollecitiEsercizio.Key;
                            Conto contoAddebito = null;
                            SottoConto sottoContoAddebito = null;
                            if (idConto != null)
                            {
                                contoAddebito = _daoFactory.GetContoDao().Find(idConto.Value, false);
                                if (idSottoConto != null)
                                    sottoContoAddebito = _daoFactory.GetSottoContoDao().GetById(idSottoConto.Value, false);
                            }
                            if (contoAddebito == null)
                            {
                                sottoContoAddebito = _daoFactory.GetSottoContoDao().GetAddebitoCompetenzeByEsercizio(esercizioAddebito.ID, esercizioAddebito.CondominioRiferimento.ID);
                                if (sottoContoAddebito != null)
                                    contoAddebito = sottoContoAddebito.ContoRiferimento;
                            }

                            if (contoAddebito != null && esercizioAddebito != null)
                            {
                                var testata = _movimentiContabileService.SetMovimentiSollecito(esercizioAddebito, sollecitiEsercizio.ToList(), dataRegistrazioneContabile.GetValueOrDefault(), contoAddebito, sottoContoAddebito);

                                // -------------------------------------------
                                // Genero il protocollo di archiviazione
                                // -------------------------------------------
                                var progressivo = _protocolloService.GetProgressivo(TipoProtocollo.Fattura, testata.EsercizioRiferimento.DataApertura.GetValueOrDefault().Year, testata.EsercizioRiferimento.CondominioRiferimento);
                                if (progressivo.Progressivo != null)
                                {
                                    testata.NumeroProtocollo = progressivo.Progressivo.Value;
                                    testata.AnnoArchiviazioneOttica = testata.EsercizioRiferimento.DataApertura.GetValueOrDefault().Year;
                                }
                                else
                                {
                                    _log.ErrorFormat("Errore imprevisto nella generazione del protocollo di archiviazione - {0} - esercizio:{1} - testata:{2} - message:{3}", Utility.GetMethodDescription(), esercizioAddebito.ID, testata.ID, progressivo.Message);
                                }

                            }

                        }
                    }
                }
                catch (Exception ex)
                {
                    _log.ErrorFormat("Errore inaspettato nel calcolo del sollecito per soggetto - CREAZIONE MOVIMENTI CONTABILI - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), idEsercizio);
                    throw;
                }

                return solleciti;

            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato nel calcolo del sollecito per soggetto - CREAZIONE MOVIMENTI CONTABILI - {0} - esercizio:{1} - groupByPersone:{2} - dataRate:{3} - dataVersamenti:{4} - importoLimite:{5} - importoCompetenza:{6} - dataSollecito:{7} - stampaProprietario:{8} - idBanca:{9} - idModelloLettera:{10} - dataRegistrazioneContabile:{11} - idConto:{12} - idSottoConto:{13} - storico:{14} - esercizio:{15}", ex, Utility.GetMethodDescription(), idEsercizio.GetValueOrDefault(), groupByPersone, dataRate, dataVersamenti, importoLimite, importoCompetenza, dataSollecito, stampaProprietario, idBanca, idModelloLettera, dataRegistrazioneContabile, idConto, idSottoConto, storico, idEsercizio);
                throw;
            }

        }
Exemple #2
0
        public TestataSollecitoDTO GetById(int idSollecito)
        {
            try
            {
                var sollecito = _daoFactory.GetSollecitoDao().GetById(idSollecito, false);
                var persona = sollecito.Soggetto != null ? sollecito.Soggetto.Persona : sollecito.Persona;
                var recapito = _personaService.GetRecapito(persona, sollecito.TipoIndirizzo);
                var bancaSollecito = sollecito.Banca ?? sollecito.Esercizio.CondominioRiferimento.DatiBancariPrincipale;

                var testata = new TestataSollecitoDTO
                {
                    Id = sollecito.ID,
                    Cap = recapito.Cap,
                    IdCondominio = sollecito.Esercizio.CondominioRiferimento.ID,
                    IdEsercizio = sollecito.Esercizio.ID,
                    DescrizioneEsercizio = sollecito.Esercizio.DisplayName,
                    ImportoTotaleDaVersare = sollecito.ImportoDaVersare,
                    ImportoCompetenza = sollecito.ImportoCompetenza,
                    Indirizzo = recapito.GetIndirizzoCompleto(),
                    Nominativo = getNominativoPresso(persona, sollecito.Soggetto, recapito),
                    IdPersona = persona.ID,
                    Comune = recapito.ComuneDisplayName,
                    Provincia = recapito.Comune?.ProvinciaAppartenenza?.Codice,
                    DataLettera = sollecito.Data,
                    DataRate = sollecito.DataLimiteRate,
                    StampaProprietario = sollecito.StampaProprietario,
                    GroupByPersona = sollecito.GroupByPersona,
                    OggettoLettera = sollecito.OggettoLettera,
                    TestoLettera = formattaTestoLettera(sollecito.Esercizio.CondominioRiferimento, bancaSollecito, sollecito.TestoLettera),
                    IdBanca = sollecito.Banca?.ID ?? 0,
                    CodiceMovimentoEconomico = sollecito.MovimentoEconomico?.ID ?? 0,
                    CodiceTestataMovimentoEconomico = sollecito.MovimentoEconomico?.Testata.ID ?? 0,
                    NumeroDocumenti = sollecito.Documenti.Count
                };

                if(sollecito.Soggetto != null)
                {
                    testata.IdSoggettoCondominio = sollecito.Soggetto.ID;
                    testata.DescrizioneUnitaImmobiliare = sollecito.Soggetto.UnitaImmobiliare.Descrizione;
                    testata.IdUnitaImmobiliare = sollecito.Soggetto.UnitaImmobiliare.ID;
                    testata.Interno = sollecito.Soggetto.UnitaImmobiliare.InternoCompleto;
                    testata.Piano = sollecito.Soggetto.UnitaImmobiliare.Piano;
                    testata.Ordine = sollecito.Soggetto.UnitaImmobiliare.Ordine.GetValueOrDefault();
                    testata.Subalterno = sollecito.Soggetto.UnitaImmobiliare.Subalterno;
                }

                var righeCondominio = sollecito.Esercizio.CondominioRiferimento.IndirizzoCompleto.Split('&');
                testata.DescrizioneCompletaCondominio = $"Condominio: {righeCondominio[0]}{Environment.NewLine}{righeCondominio[1]} - {righeCondominio[2]} - {righeCondominio[3]}";

                if (sollecito.Soggetto != null && sollecito.Soggetto.Tipo == TipoSoggetto.Conduttore)
                {
                    var proprietario = sollecito.Soggetto.UnitaImmobiliare.GetProprietarioPrincipale(sollecito.Esercizio.DataChiusura);
                    var recapitoProprietario = _personaService.GetRecapito(proprietario.Persona, sollecito.TipoIndirizzo);
                    testata.NominativoProprietario = proprietario.DisplayName;
                    testata.IndirizzoProprietario = recapitoProprietario.GetIndirizzoCompleto();
                    testata.ComuneProprietario = recapitoProprietario.ComuneDisplayName;
                    testata.CapProprietario = recapitoProprietario.Cap;
                }

                string titolo = null;
                if(!string.IsNullOrEmpty(persona.Titolo))
                    titolo = Decodifica.Instance.GetElement("TitoloPersona", persona.Titolo).Descrizione;
                testata.Titolo = titolo;

                foreach (var dettaglio in sollecito.Dettaglio)
                {
                    var dett = new DettaglioSollecitoDTO
                    {
                        Id = dettaglio.ID,
                        CodiceRata = dettaglio.Rata?.ID ?? 0,
                        DataScadenza = dettaglio.DataScadenzaRata,
                        DataUltimoPagamento = dettaglio.DataUltimoPagamento,
                        Importo = dettaglio.ImportoRata,
                        ImportoDaVersare = dettaglio.ImportoDaVersare,
                        ImportoPagato = dettaglio.ImportoPagato,
                        IdTestataSollecito = testata.Id,
                        IdEsercizio = sollecito.Esercizio.ID,
                        DescrizioneEsercizio = sollecito.Esercizio.DisplayName,
                        ProgressivoRata = dettaglio.Rata?.Progressivo ?? 0
                    };

                    if (dettaglio.Rata != null)
                    {
                        dett.IdSoggetto = dettaglio.Rata.Soggetto.ID;
                        dett.DescrizioneSoggetto = dettaglio.Rata.Soggetto.DisplayName;
                    }

                    if (sollecito.Soggetto != null)
                    {
                        dett.IdUnitaImmobiliare = sollecito.Soggetto.UnitaImmobiliare.ID;
                        dett.DescrizioneUnitaImmobiliare = sollecito.Soggetto.UnitaImmobiliare.TipoUnitaImmobiliare.Descrizione + " - " + sollecito.Soggetto.UnitaImmobiliare.Descrizione;
                        dett.Ordine = sollecito.Soggetto.UnitaImmobiliare.Ordine.GetValueOrDefault();
                        dett.Interno = sollecito.Soggetto.UnitaImmobiliare.InternoCompleto;
                        dett.PercentualePossesso = Convert.ToInt32(sollecito.Soggetto.PercentualeRiferimento.GetValueOrDefault());
                        dett.Subalterno = sollecito.Soggetto.UnitaImmobiliare.Subalterno;
                    }

                    testata.Dettagli.Add(dett);
                }

                return testata;
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato nella lettura di un singolo sollecito - {0} - sollecito:{1}", ex, Utility.GetMethodDescription(), idSollecito);
                throw;
            }
        }
        private bool isItemSelected(TestataSollecitoDTO testataSollecitoDTO, DettaglioSollecitoDTO dettaglioSollecitoDTO, IEnumerable<RiepilogoRataSoggettoDTO> condomini)
        {
            bool result = false;
            if (_riepilogoRataVersateUC1.GetRaggruppamentoCondominio() == "E" && _riepilogoRataVersateUC1.GetRaggruppamentoSoggetto() == "S")
            {
                if (
                    condomini.Count(
                        item =>
                            item.IdSoggettoCondominio == dettaglioSollecitoDTO.IdSoggetto &&
                            item.IdEsercizio == dettaglioSollecitoDTO.IdEsercizio) > 0)
                    result = true;
            }
            else if (_riepilogoRataVersateUC1.GetRaggruppamentoCondominio() == "E" && _riepilogoRataVersateUC1.GetRaggruppamentoSoggetto() == "P")
            {
                if (
                    condomini.Count(
                        item =>
                            item.IdPersona == testataSollecitoDTO.IdPersona &&
                            item.IdEsercizio == dettaglioSollecitoDTO.IdEsercizio) > 0)
                    result = true;
            }
            else
            {
                result = true;
            }

            return result;
        }
 public List<DocumentoDTO> GetBySollecito(TestataSollecitoDTO sollecito)
 {
     var result = GetServiceClient().GetDocumentiBySollecito(sollecito.Id, GetUserInfo());
     CloseService();
     return result;
 }
Exemple #5
0
 private void listaSollecitiMouseUp(object sender, MouseEventArgs e)
 {
     _sollecitoClick = null;
     if (e.Button == MouseButtons.Right)
     {
         _rowClick = DataGridHelper.GetCellEvent(listaSolleciti, e);
         _sollecitoClick = DataGridHelper.GetCellEvent<TestataSollecitoDTO>(listaSolleciti, e);
         if (_sollecitoClick != null)
             contextMenuStrip1.Show(listaSolleciti, e.X, e.Y);
     }
 }
 public DocumentoDTO SetDocumentoSollecito(TestataSollecitoDTO sollecito, DocumentoDTO documento)
 {
     documento.IdCondominio = sollecito.IdCondominio;
     documento.IdSollecito = sollecito.Id;
     documento.Tipo = "Sollecito";
     return documento;
 }
 public List<DocumentoDTO> GetDocumentiBySollecito(TestataSollecitoDTO sollecito)
 {
     return _documentoService.GetBySollecito(sollecito);
 }