public string ClearCalcoloAddebito(Esercizio esercizio, TipoUtenza tipoUtenza)
        {
            try
            {
                var message = string.Empty;

                // ==================================================
                //  Elimino eventuali vecchi riparti
                // ==================================================
                var testate = _daoFactory.GetTestataRipartoBolletteDao().GetByEsercizioTipoUtenza(esercizio.ID, tipoUtenza.ID);
                foreach (var item in testate)
                {
                    foreach (var ripartoBollette in item.Riparto)
                        ripartoBollette.Testata = null;
                    item.Riparto.Clear();
                    _daoFactory.GetTestataRipartoBolletteDao().Delete(item);
                }

                return message;
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato nella CLEAR del calcolo dell'addebito bolletta - {0} - esercizio:{1} - tipo utenza:{2}", ex, Library.Utility.GetMethodDescription(), esercizio != null ? esercizio.ID.ToString() : "<NULL>", tipoUtenza);
                throw;
            }
        }
Ejemplo n.º 2
0
 public Utenza(TipoUtenza tipo, string numero, Fornitore fornitore, Condominio condominio, DatiBancariCondomini coordinateBancarie)
 {
     Fornitore = fornitore;
     Condominio = condominio;
     Tipo = tipo;
     Numero = numero;
     CoordinateBancarie = coordinateBancarie;
 }
        public IList<ImportiDTO> CalcolaAddebito(Esercizio esercizio, TipoUtenza tipoUtenza, IList<LetturaContatoreCalcoloDTO> consumi, string descrizioneMovimentoAcqua, string descrizioneMovimentoRiscaldamento, int? idContoAcquaRiscaldata, int? idContoRiscaldamento, int? idContoMillesimiSpalo, decimal? tariffaRiscaldamentoAcqua, decimal? tariffaAcquaFredda, bool salvaRiparto, DateTime dataRegistrazione, bool clearRiparto)
        {
            try
            {
                _ripartoBollette.Clear();
                var importiAddebito = new List<ImportiDTO>();

                if (consumi.Count > 0 && esercizio != null)
                {
                    TestataRipartoBollette testata = null;

                    // ==================================================
                    //  Elimino eventuali vecchi riparti
                    // ==================================================
                    if (clearRiparto && salvaRiparto)
                        ClearCalcoloAddebito(esercizio, tipoUtenza);
                    else
                        testata = _daoFactory.GetTestataRipartoBolletteDao().GetByEsercizioTipoUtenza(esercizio.ID, tipoUtenza.ID).FirstOrDefault();


                    // ==================================================
                    //  Raggruppo per unità per calcolare i consumi totali
                    // ==================================================
                    // Raggruppo le letture per unità immobiliare
                    var letturePerUnita = (from item in consumi
                                           group item by item.IdUnitaImmobiliare into g
                                           select new ConsumoUnita(g.Key, g.Sum(item => item.Valore.GetValueOrDefault()), g.Count())).ToList();

                    // ==================================================
                    //  Calcolo addebiti per unità
                    // ==================================================
                    importiAddebito = new List<ImportiDTO>(letturePerUnita.Count());
                    if (testata == null)
                    {
                        testata = new TestataRipartoBollette(esercizio, tipoUtenza, dataRegistrazione)
                        {
                            DescrizioneMovimentoAcqua = descrizioneMovimentoAcqua,
                            DescrizioneMovimentoRiscaldamento = descrizioneMovimentoRiscaldamento
                        };
                    }
                    if (idContoAcquaRiscaldata != null)
                        testata.ContoAcquaRiscaldamento = _daoFactory.GetContoDao().GetById(idContoAcquaRiscaldata.GetValueOrDefault(), false);
                    if (idContoRiscaldamento != null)
                        testata.ContoRiscaldamento = _daoFactory.GetContoDao().GetById(idContoRiscaldamento.GetValueOrDefault(), false);
                    if (idContoMillesimiSpalo != null)
                        testata.ContoSpalo = _daoFactory.GetContoDao().GetById(idContoMillesimiSpalo.GetValueOrDefault(), false);
                    if (tariffaRiscaldamentoAcqua != null)
                        testata.TariffaRiscaldamentoAcqua = tariffaRiscaldamentoAcqua;
                    if (tariffaAcquaFredda != null)
                        testata.TariffaAcquaFredda = tariffaAcquaFredda;
                    _daoFactory.GetTestataRipartoBolletteDao().SaveOrUpdate(testata);

                    foreach (var consumoUnita in letturePerUnita)
                    {
                        try
                        {
                            var unita = _daoFactory.GetUnitaImmobiliareDao().GetById(consumoUnita.IdUnitaImmobiliare, false);
                            if (salvaRiparto)
                            {
                                var riparto = new RipartoBollette(testata, unita);
                                _ripartoBollette.Add(riparto);
                                _daoFactory.GetRipartoBolletteDao().SaveOrUpdate(riparto);
                            }

                            //===============================
                            // CONSUMO
                            //===============================
                            var importoConsumo = consumoUnita.ConsumoTotale*tariffaAcquaFredda;

                            //===============================
                            // TOTALI
                            //===============================
                            importiAddebito.Add(new ImportiDTO(unita.ID, importoConsumo.GetValueOrDefault()));

                        }
                        catch (Exception ex)
                        {
                            _log.ErrorFormat("Errore inaspettato nel calcolo dell'addebito bolletta - UNITA' IMMOBILIARE {0} - unità immobiliare:{1}", ex, Library.Utility.GetMethodDescription(), consumoUnita.IdUnitaImmobiliare);
                            throw;
                        }
                    }
                }

                return importiAddebito;
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato nel calcolo dell'addebito bolletta - {0} - esercizio:{1} - tipo utenza:{2}", ex, Library.Utility.GetMethodDescription(), esercizio != null ? esercizio.ID.ToString() : "<NULL>", tipoUtenza);
                throw;
            }
        }
Ejemplo n.º 4
0
        public IList<ImportiDTO> CalcolaAddebito(Esercizio esercizio, TipoUtenza tipoUtenza, IList<LetturaContatoreCalcoloDTO> consumi, string descrizioneMovimentoAcqua, string descrizioneMovimentoRiscaldamento, int? idContoAcquaRiscaldata, int? idContoRiscaldamento, int? idContoMillesimiSpalo, decimal? tariffaRiscaldamentoAcqua, decimal? tariffaAcquaFredda, bool salvaRiparto, DateTime dataRegistrazione, bool clearRiparto)
        {
            try
            {
                var importiAddebito = new List<ImportiDTO>();
                _ripartoBollette = new List<RipartoBollette>();

                if (consumi.Count > 0 && esercizio != null)
                {
                    // ==================================================
                    //  Elimino eventuali vecchi riparti
                    // ==================================================
                    if (clearRiparto && salvaRiparto && _testataRipartoBollette == null)
                        ClearCalcoloAddebito(esercizio, tipoUtenza);
                    else
                        _testataRipartoBollette = _daoFactory.GetTestataRipartoBolletteDao().GetByEsercizioTipoUtenza(esercizio.ID, tipoUtenza.ID).FirstOrDefault();

                    // ==================================================
                    //  Individuo il tariffario da applicare
                    // ==================================================
                    var condominio = esercizio.CondominioRiferimento;
                    var tariffa = condominio.Indirizzo.Comune.TariffaAcqua;

                    if (tariffa == null)
                    {
                        var ex = new Exception($"Non è stata trovata nessuna tariffa per il comune: {condominio.Indirizzo.Comune.Descrizione}");
                        _log.ErrorFormat("Errore inaspettato nel calcolo dell'addebito bolletta - {0}", ex, Library.Utility.GetMethodDescription());
                        throw (ex);
                    }

                    // ==================================================
                    //  Raggruppo per unità per calcolare i consumi totali
                    // ==================================================
                    // Raggruppo i consumi per unità immobiliare
                    var consumiPerUnita = (from item in consumi
                                           group item by item.IdUnitaImmobiliare into g
                                           select new ConsumoUnita(g.Key, g.Sum(item => item.Valore.GetValueOrDefault()), g.Count())).ToList();

                    var fasceConsumo = _daoFactory.GetFasciaConsumoDettaglioDao().GetByTariffaTipo(tariffa, Sfera.Enums.TipoDettaglioBollettaEnum.Consumo);
                    var fasceConsumoQuotaFissa = _daoFactory.GetFasciaConsumoDettaglioDao().GetByTariffaTipo(tariffa, Sfera.Enums.TipoDettaglioBollettaEnum.QuotaFissa);

                    // ==================================================
                    //  Calcolo addebiti per unità
                    // ==================================================
                    importiAddebito = new List<ImportiDTO>(consumiPerUnita.Count);
                    if (_testataRipartoBollette == null)
                    {
                        _testataRipartoBollette = new TestataRipartoBollette(esercizio, tipoUtenza, dataRegistrazione)
                        {
                            DescrizioneMovimentoAcqua = descrizioneMovimentoAcqua,
                            DescrizioneMovimentoRiscaldamento = descrizioneMovimentoRiscaldamento
                        };
                    }

                    if(idContoAcquaRiscaldata != null)
                        _testataRipartoBollette.ContoAcquaRiscaldamento = _daoFactory.GetContoDao().GetById(idContoAcquaRiscaldata.GetValueOrDefault(), false);
                    if (idContoRiscaldamento != null)
                        _testataRipartoBollette.ContoRiscaldamento = _daoFactory.GetContoDao().GetById(idContoRiscaldamento.GetValueOrDefault(), false);
                    if (idContoMillesimiSpalo != null)
                        _testataRipartoBollette.ContoSpalo = _daoFactory.GetContoDao().GetById(idContoMillesimiSpalo.GetValueOrDefault(), false);
                    if (tariffaRiscaldamentoAcqua != null)
                        _testataRipartoBollette.TariffaRiscaldamentoAcqua = tariffaRiscaldamentoAcqua;
                    _daoFactory.GetTestataRipartoBolletteDao().SaveOrUpdate(_testataRipartoBollette);

                    foreach (var consumoUnita in consumiPerUnita)
                    {
                        try
                        {
                            var numeroResidenti = 2;
                            UnitaImmobiliare unita = null;
                            if (consumoUnita.IdUnitaImmobiliare > 0)
                            {
                                unita = _daoFactory.GetUnitaImmobiliareDao().GetById(consumoUnita.IdUnitaImmobiliare, false);
                                if (unita.NumeroResidenti > 0)
                                    numeroResidenti = unita.NumeroResidenti;
                            }

                            RipartoBollette riparto = null;
                            if (salvaRiparto)
                            {
                                riparto = new RipartoBollette(_testataRipartoBollette, unita) { ConsumoAcquaCalda = 0, ImportoAcquaCalda = 0 };
                                _ripartoBollette.Add(riparto);
                                _daoFactory.GetRipartoBolletteDao().SaveOrUpdate(riparto);
                            }

                            var fasceConsumoUnita = from item in fasceConsumo
                                                    where item.NumeroComponenti == numeroResidenti
                                                    orderby item.ValoreMinimo
                                                    select item;

                            //===============================
                            // CONSUMO
                            //===============================
                            // ----------------------------------------------------------------------------
                            // Loop per tutte le fasce per trovare i consumi da addebitare per ogni fascia
                            // ----------------------------------------------------------------------------
                            var consumoResiduo = (consumoUnita.ConsumoTotale * 1000) / consumoUnita.Giorni;
                            decimal importoConsumo = 0;
                            decimal consumoMassimoFasciaPrecedente = 0;
                            foreach (var dettaglioFascia in fasceConsumoUnita)
                            {
                                try
                                {
                                    if (consumoResiduo == 0)
                                        break;

                                    // tariffa per fascia attuale
                                    decimal importoTariffa = 0;
                                    var singolaTariffa = (from item in tariffa.Tariffe
                                                          where item.Tipo == Sfera.Enums.TipoDettaglioBollettaEnum.Consumo &&
                                                          item.FasciaConsumo.ID == dettaglioFascia.Fascia.ID
                                                          select item).SingleOrDefault();
                                    if (singolaTariffa != null)
                                        importoTariffa = singolaTariffa.Valore;

                                    // consumo (litri/gg) di competenza di questa fascia
                                    var consumoPerFascia = consumoResiduo;
                                    var consumoMassimoPerFascia = dettaglioFascia.ValoreMassimo - consumoMassimoFasciaPrecedente;
                                    if (consumoMassimoPerFascia < consumoPerFascia)
                                        consumoPerFascia = consumoMassimoPerFascia;

                                    // calcolo addebito (la tariffa è indicata per mc)
                                    var importoPerFascia = (consumoPerFascia * consumoUnita.Giorni) / 1000 * importoTariffa;
                                    importoConsumo += importoPerFascia;

                                    if (salvaRiparto)
                                        new RipartoBolletteDettaglio(riparto, dettaglioFascia, (consumoPerFascia * consumoUnita.Giorni) / 1000, importoPerFascia);

                                    consumoResiduo -= consumoPerFascia;
                                    consumoMassimoFasciaPrecedente = dettaglioFascia.ValoreMassimo;
                                }
                                catch (Exception ex)
                                {
                                    _log.ErrorFormat("Errore inaspettato nel calcolo dell'addebito bolletta - DETTAGLIO FASCIA - {0} - unità immobiliare:{1} - dettaglio fascia:{2}", ex, Library.Utility.GetMethodDescription(), consumoUnita.IdUnitaImmobiliare, dettaglioFascia.ID);
                                    throw;
                                }
                            }

                            //===============================
                            // Quota Fissa
                            //===============================
                            var quotaFissa = 0m;
                            if(unita != null && !unita.EsclusaAddebitoQuotaFissa)
                                quotaFissa = calcoloQuotaFissa(unita, consumoUnita.ConsumoTotale, fasceConsumoQuotaFissa);
                            if (riparto != null)
                                riparto.QuotaFissa = quotaFissa;

                            //===============================
                            // Fognatura
                            //===============================
                            decimal importoTariffaFognatura = 0;
                            var singolaTariffaFognatura = (from item in tariffa.Tariffe
                                                            where item.Tipo == Sfera.Enums.TipoDettaglioBollettaEnum.Fognatura
                                                            select item).SingleOrDefault();
                            if (singolaTariffaFognatura != null)
                                importoTariffaFognatura = singolaTariffaFognatura.Valore;
                            var importoFognatura = consumoUnita.ConsumoTotale*importoTariffaFognatura;
                            if (riparto != null)
                                riparto.Fognatura = importoFognatura;

                            //===============================
                            // Depurazione
                            //===============================
                            decimal importoTariffaDepurazione = 0;
                            var singolaTariffaDepurazione = (from item in tariffa.Tariffe
                                                                where item.Tipo == Sfera.Enums.TipoDettaglioBollettaEnum.Depurazione
                                                                select item).SingleOrDefault();
                            if (singolaTariffaDepurazione != null)
                                importoTariffaDepurazione = singolaTariffaDepurazione.Valore;
                            var importoDepurazione = consumoUnita.ConsumoTotale*importoTariffaDepurazione;
                            if (riparto != null)
                                riparto.Depurazione = importoDepurazione;

                            //===============================
                            // TOTALI
                            //===============================
                            var importoImponibile = importoConsumo + quotaFissa + importoFognatura + importoDepurazione;
                            var importoIva = importoImponibile * 0.10m;
                            if (riparto != null)
                                riparto.ImportoIva = importoIva;

                            importiAddebito.Add(new ImportiDTO(consumoUnita.IdUnitaImmobiliare, importoImponibile + importoIva));

                        }
                        catch (Exception ex)
                        {
                            _log.ErrorFormat("Errore inaspettato nel calcolo dell'addebito bolletta - UNITA' IMMOBILIARE {0} - unità immobiliare:{1}", ex, Library.Utility.GetMethodDescription(), consumoUnita.IdUnitaImmobiliare);
                            throw;
                        }
                    }
                }

                return importiAddebito;
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato nel calcolo dell'addebito bolletta - {0} - esercizio:{1} - tipo utenza:{2}", ex, Library.Utility.GetMethodDescription(), esercizio?.ID.ToString() ?? "<NULL>", tipoUtenza);
                throw;
            }
        }
        public AuthorizationMessages CalcoloRipartoAcqua(int idEsercizio, TipoUtenza tipoUtenza, int? idContoAcquaRiscaldata, int? idContoRiscaldamento, int? idContoMillesimiSpalo, string descrizioneMovimentoAcqua, string descrizioneMovimentoRiscaldamento, decimal? tariffaRiscaldamentoAcqua, decimal? tariffaAcquaFredda, IList<ParametriAddebitoMovimento> parametriAddebitoMovimenti, DateTime? dataRegistrazione)
        {
            try
            {
                if(!Library.Conversione.IsSqlSmallDateTime(dataRegistrazione.GetValueOrDefault()))
                    return new AuthorizationMessages("Non è possibile procedere al riparto delle bollette verificare la corettezza della data di registrazione: " + dataRegistrazione.GetValueOrDefault(), null);

                var fatalMessage = string.Empty;
                var warnMessage = string.Empty;
                var messaggioContatore = string.Empty;

                var esercizio = _daoFactory.GetEsercizioDao().GetById(idEsercizio, false);
                var utenze = _daoFactory.GetUtenzaDao().GetByCondominioTipo(esercizio.CondominioRiferimento, tipoUtenza).Where(item => item.IsAllowRipartoLetture()).ToList();
                var soggettiAttivi = _daoFactory.GetSoggettoCondominioDao().GetAttiviByEsercizio(esercizio, null);

                // ===========================================
                // Controllo presenza bollette
                // ===========================================
                var spesePresenti = false;
                var dictSpese = new Dictionary<int, IList<Spesa>>();
                foreach (var utenza in utenze)
                {
                    const string hql = "FROM Spesa SPE WHERE SPE.Utenza.RipartoLetture = 1 AND SPE.Utenza = :utenza AND SPE.EsercizioRiferimento = :esercizio";
                    var spese = _daoFactory.GetSpesaDao().GetByQuery(hql, new[] { new QueryParam("utenza", utenza), new QueryParam("esercizio", idEsercizio) });

                    // Controllo se tutte le bollette hanno la data di inizio e fine competenza
                    if (spese.Any(item => item.DataInizioCompetenza == null || item.DataFineCompetenza == null))
                    {
                        var speseSenzaCompetenza = spese.Where(item => item.DataInizioCompetenza == null || item.DataFineCompetenza == null);
                        fatalMessage = speseSenzaCompetenza.Aggregate(fatalMessage, (current, spesa) => current + ("Per La bolletta n." + spesa.NumeroDocumento + " del " + spesa.DataDocumento.GetValueOrDefault().ToShortDateString() + " non è stata definita la competenza." + Environment.NewLine));
                        _persistenceContext.RollbackAndCloseSession(Security.Login.Instance.CurrentLogin().LoginName);
                        _persistenceContext.BeginTransaction(Security.Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);

                        return new AuthorizationMessages(fatalMessage, warnMessage);
                    }

                    if (spese.Any(item => item.ImportoBolletta != 0))
                        spesePresenti = true;

                    dictSpese.Add(utenza.ID, spese);
                }
                if (!spesePresenti)
                {
                    fatalMessage += "Non sono presenti bollette da ripartire";
                    _persistenceContext.RollbackAndCloseSession(Security.Login.Instance.CurrentLogin().LoginName);
                    _persistenceContext.BeginTransaction(Security.Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
                    return new AuthorizationMessages(fatalMessage, warnMessage);
                }

                // ===========================================
                // Se non ci sono errori elaboro tutte le utenze
                // ===========================================
                foreach (var utenza in utenze)
                {
                    DateTime? dataInizialeSpese = null;
                    DateTime? dataFinaleSpese = null;
                    DateTime? dataInizialeLetture = null;
                    DateTime? dataFinaleLetture = null;

                    var spese = dictSpese[utenza.ID];
                    spesePresenti = spese.Any(item => item.ImportoBolletta != 0);
                    if (spesePresenti)
                    {
                        dataInizialeSpese = spese.Min(item => item.DataInizioCompetenza).Value;
                        dataFinaleSpese = spese.Max(item => item.DataFineCompetenza).Value;
                    }

                    var lettureDate = new List<LetturaContatore>();

                    // Verifico le letture dei contatori escludendo quelli che prevedono un riparto lineare
                    foreach (var contatore in utenza.Contatori.Where(item => !item.IsContaCalorie))
                        lettureDate.AddRange(GetLettureByEsercizio(idEsercizio, contatore.ID));

                    var datiPresenti = false;
                    if (lettureDate.Count > 0)
                    {
                        datiPresenti = true;
                        dataInizialeLetture = lettureDate.Min(item => item.Data);
                        dataFinaleLetture = lettureDate.Max(item => item.Data);
                    }

                    if (datiPresenti && spesePresenti)
                    {
                        // =========================================================
                        //  Calcolo consumi e addebiti la competenza delle bollette
                        // =========================================================
                        var consumiAcquaCaldaLista = new List<List<ConsumoUnita>>();
                        var consumiTotali = new List<LetturaContatoreCalcoloDTO>();

                        // Calcolo consumo per ogni contatore
                        var letturePerContatore = new Dictionary<int, IList<LetturaContatoreCalcoloDTO>>();
                        var consumiPerContatore = new Dictionary<int, IList<LetturaContatoreCalcoloDTO>>();
                        foreach (var contatore in utenza.Contatori)
                        {
                            try
                            {
                                DateTime dataIniziale;
                                DateTime dataFinale;
                                if (contatore.Tipo.TipoCalcolo != TipoCalcoloContatoreEnum.AcquaCalda)
                                {
                                    dataIniziale = dataInizialeSpese.Value;
                                    dataFinale = dataFinaleSpese.Value;
                                }
                                else
                                {
                                    dataIniziale = dataInizialeLetture.Value;
                                    dataFinale = dataFinaleLetture.Value;
                                }

                                var letture = getLettureCalcoloByContatoreData(contatore, dataIniziale, dataFinale);
                                letturePerContatore.Add(contatore.ID, letture);
                                var consumi = getConsumoGiornaliero(contatore.ID, letture, dataIniziale, dataFinale);

                                // Se non sono stati calcolati consumi per il contatore considerato memorizzo il messaggio per eventualmente visualizzarlo all'utente
                                if (consumi.Count == 0)
                                {
                                    messaggioContatore += "Non sono stati trovate sufficienti letture per il Contatore: " +
                                                          contatore.Codice + " - " + contatore.Descrizione + " - Utenza: " +
                                                          utenza.Numero + " - " + utenza.Descrizione;
                                }

                                consumiPerContatore.Add(contatore.ID, consumi);

                                if (contatore.Tipo.TipoCalcolo == TipoCalcoloContatoreEnum.AcquaCalda)
                                {
                                    // ==================================================
                                    //  Raggruppo per unità per calcolare i consumi totali
                                    // ==================================================
                                    // Raggruppo i consumi per unità immobiliare
                                    var consumiPerUnita = from item in consumi
                                                          group item by item.IdUnitaImmobiliare
                                                              into g
                                                              select new ConsumoUnita(g.Key, g.Sum(item => item.Valore.GetValueOrDefault()), g.Count());

                                    consumiAcquaCaldaLista.Add(consumiPerUnita.ToList());
                                }

                                foreach (var consumo in consumi)
                                {
                                    var consumoTotale = (from item in consumiTotali
                                                         where
                                                             item.IdUnitaImmobiliare == consumo.IdUnitaImmobiliare &&
                                                             item.Data == consumo.Data
                                                         select item).SingleOrDefault();
                                    if (consumoTotale != null)
                                        consumoTotale.Valore += consumo.Valore;
                                    else
                                        consumiTotali.Add(consumo);
                                }
                            }
                            catch (Exception ex)
                            {
                                _log.ErrorFormat("Errore durante il calcolo del consumo giornaliero (SINGOLO CONTATORE) - {0} - contatore:{1}", ex, Library.Utility.GetMethodDescription(), contatore.ID);
                                throw;
                            }
                        }

                        // Con la somma dei consumi giornalieri per contatore calcolo l'addebito
                        var addebitiCalcolati = _calcoliUtenzaService.CalcolaAddebito(esercizio, tipoUtenza, consumiTotali, descrizioneMovimentoAcqua, descrizioneMovimentoRiscaldamento, idContoAcquaRiscaldata, idContoRiscaldamento, idContoMillesimiSpalo, tariffaRiscaldamentoAcqua, tariffaAcquaFredda, true, dataRegistrazione.GetValueOrDefault());

                        // Se non sono riuscito a calcolare addebiti il riparto è fallito, visualizzo eventuali messaggi relativi ai singoli contatori come messaggi fatal
                        if (addebitiCalcolati.Count == 0)
                        {
                            fatalMessage += messaggioContatore;
                            messaggioContatore = null;
                        }
                        else
                        {
                            warnMessage += messaggioContatore;
                            messaggioContatore = null;
                        }

                        // Aggiorno letture utilizzate
                        foreach (var riparto in _calcoliUtenzaService.GetRipartoBollette())
                        {
                            foreach (var kvp in consumiPerContatore)
                            {
                                try
                                {
                                    // -----------------------------------------------------------------------------------
                                    // Se il contatore è condominiale non lo considero nei consumi dei contatori divisionali, viceversa per i conumi del contatore condominiale
                                    var contatore = _daoFactory.GetContatoreDao().GetById(kvp.Key, false);
                                    if (contatore.IsCondominiale && riparto.UnitaImmobiliare != null)
                                        continue;
                                    if (!contatore.IsCondominiale && riparto.UnitaImmobiliare == null)
                                        continue;
                                    // -----------------------------------------------------------------------------------

                                    var lettureUtilizzate = letturePerContatore[kvp.Key];

                                    // =================================================================
                                    // Lettura iniziale
                                    // =================================================================
                                    var riparto1 = riparto;

                                    var listaLettureIniziali = new SortedList<int, LetturaContatoreCalcoloDTO>();
                                    foreach (
                                        var letturaContatoreCalcoloDTO in
                                            lettureUtilizzate.Where(
                                                item =>
                                                (item.IdUnitaImmobiliare < 0 && riparto1.UnitaImmobiliare == null) ||
                                                (item.IdUnitaImmobiliare == riparto1.UnitaImmobiliare.ID)))
                                        listaLettureIniziali.Add(
                                            Math.Abs(
                                                (esercizio.DataApertura.GetValueOrDefault() -
                                                 letturaContatoreCalcoloDTO.Data).Days), letturaContatoreCalcoloDTO);
                                    var letturaIniziale = listaLettureIniziali.Values.FirstOrDefault();

                                    if (letturaIniziale == null)
                                    {
                                        var idUnitaImmobiliare = "<NULL>";
                                        if (riparto.UnitaImmobiliare != null)
                                            idUnitaImmobiliare = riparto.UnitaImmobiliare.ID.ToString();
                                        
                                        _log.Error("Le letture non sono sufficienti per poter effettuare il riparto: " + Library.Utility.GetMethodDescription() + " - Lettura Iniziale - idUnitaImmobiliare: " + idUnitaImmobiliare + " - idEsercizio: " + idEsercizio + " - tipoUtenza: " + tipoUtenza);

                                        _persistenceContext.RollbackAndCloseSession(
                                            Security.Login.Instance.CurrentLogin().LoginName);
                                        _persistenceContext.BeginTransaction(
                                            Security.Login.Instance.CurrentLogin().LoginName,
                                            IsolationLevel.ReadUncommitted);

                                        return new AuthorizationMessages("Le letture non sono sufficienti per poter effettuare il riparto" + Environment.NewLine + fatalMessage, warnMessage);
                                    }

                                    var valoreLetturaIniziale = letturaIniziale.Valore.GetValueOrDefault();
                                    var tipoLetturaIniziale = TipoLetturaEnum.Effettiva;

                                    // =================================================================
                                    // Lettura finale
                                    // =================================================================

                                    var listaLettureFinali = new SortedList<int, LetturaContatoreCalcoloDTO>();
                                    foreach (
                                        var letturaContatoreCalcoloDTO in
                                            lettureUtilizzate.Where(
                                                item =>
                                                (item.IdUnitaImmobiliare < 0 && riparto1.UnitaImmobiliare == null) ||
                                                (item.IdUnitaImmobiliare == riparto1.UnitaImmobiliare.ID)))
                                        listaLettureFinali.Add(
                                            Math.Abs(
                                                (esercizio.DataChiusura.GetValueOrDefault() -
                                                 letturaContatoreCalcoloDTO.Data).Days), letturaContatoreCalcoloDTO);
                                    var letturaFinale = listaLettureFinali.Values.FirstOrDefault();

                                    if (letturaFinale == null)
                                    {
                                        var idUnitaImmobiliare = "<NULL>";
                                        if (riparto.UnitaImmobiliare != null)
                                            idUnitaImmobiliare = riparto.UnitaImmobiliare.ID.ToString();

                                        
                                        _log.Error("Le letture non sono sufficienti per poter effettuare il riparto: " +
                                                   Library.Utility.GetMethodDescription() +
                                                   " - Lettura Finale - idUnitaImmobiliare: " + idUnitaImmobiliare +
                                                   " - idEsercizio: " + idEsercizio + " - tipoUtenza: " + tipoUtenza);

                                        _persistenceContext.RollbackAndCloseSession(
                                            Security.Login.Instance.CurrentLogin().LoginName);
                                        _persistenceContext.BeginTransaction(
                                            Security.Login.Instance.CurrentLogin().LoginName,
                                            IsolationLevel.ReadUncommitted);

                                        return
                                            new AuthorizationMessages(
                                                "Le letture non sono sufficienti per poter effettuare il riparto" +
                                                Environment.NewLine + fatalMessage, warnMessage);
                                    }

                                    var valoreLetturaFinale = letturaFinale.Valore.GetValueOrDefault();
                                    var tipoLetturaFinale = TipoLetturaEnum.Effettiva;
                                    //if (letturaFinale.Data < dataFinaleTotale)
                                    //{
                                    //    var riparto2 = riparto;
                                    //    var consumoPresunto = (from item in kvp.Value
                                    //                           where item.IdUnitaImmobiliare == riparto2.UnitaImmobiliare.ID && item.Data >= letturaFinale.Data && item.Data < dataFinaleTotale
                                    //                           select item).Sum(item => item.Valore.GetValueOrDefault());
                                    //    valoreLetturaFinale += consumoPresunto;
                                    //    tipoLetturaFinale = TipoLetturaEnum.Presunta;
                                    //}

                                    // =================================================================
                                    // Lettura cambio contatore
                                    // =================================================================
                                    LetturaContatoreCalcoloDTO letturaCambioContatore = null;
                                    var letturaPrecedente = letturaIniziale;
                                    var lettureInizialeFinale =
                                        lettureUtilizzate.Where(
                                            item =>
                                            (item.IdUnitaImmobiliare < 0 && riparto1.UnitaImmobiliare == null) ||
                                            (item.IdUnitaImmobiliare == riparto1.UnitaImmobiliare.ID) &&
                                            item.Data >= letturaIniziale.Data && item.Data <= letturaFinale.Data)
                                                         .OrderBy(item => item.Data);
                                    foreach (var letturaContatoreCalcoloDTO in lettureInizialeFinale)
                                    {
                                        if (letturaContatoreCalcoloDTO.Valore < letturaPrecedente.Valore)
                                            letturaCambioContatore = letturaPrecedente;
                                        letturaPrecedente = letturaContatoreCalcoloDTO;
                                    }

                                    var lettura = new RipartoBolletteLetture(riparto, _daoFactory.GetContatoreDao().GetById(kvp.Key, false), valoreLetturaIniziale, tipoLetturaIniziale, valoreLetturaFinale, tipoLetturaFinale)
                                        {
                                            DataLetturaIniziale = letturaIniziale.Data,
                                            DataLetturaFinale = letturaFinale.Data
                                        };
                                    if (letturaCambioContatore != null)
                                    {
                                        lettura.LetturaCambioContatore =
                                            letturaCambioContatore.Valore.GetValueOrDefault();
                                        lettura.DataLetturaCambioContatore = letturaCambioContatore.Data;
                                    }
                                    _daoFactory.GetRipartoBolletteLettureDao().SaveOrUpdate(lettura);
                                }
                                catch (Exception ex)
                                {
                                    _log.Error(
                                        "Errore durante il calcolo del riparto acqua di una bolletta (Singolo Dettaglio) - " +
                                        Library.Utility.GetMethodDescription() + " - key:" + kvp.Key +
                                        " - idEsercizio: " + idEsercizio + " - tipoUtenza: " + tipoUtenza +
                                        " - idContoAcquaRiscaldata:" + idContoAcquaRiscaldata.GetValueOrDefault() +
                                        " - idContoRiscaldamento:" + idContoRiscaldamento.GetValueOrDefault() +
                                        " - idContoMillesimiSpalo:" + idContoMillesimiSpalo.GetValueOrDefault() +
                                        " - descrizioneMovimentoAcqua:" + descrizioneMovimentoAcqua +
                                        " - descrizioneMovimentoRiscaldamento:" + descrizioneMovimentoRiscaldamento +
                                        " - tariffaRiscaldamentoAcqua:" + tariffaRiscaldamentoAcqua +
                                        " - dataRegistrazione:" + dataRegistrazione , ex);
                                    throw;
                                }
                            }
                        }

                        // ===================================================================================
                        //  Riparto separatamente le singole Bollette in percentuale sull'importo complessivo
                        // ===================================================================================
                        //const string hql = "FROM RipartoBollette RIP WHERE RIP.Esercizio = :esercizio";

                        var addebitiContatoriDivisionali = addebitiCalcolati.Where(item => item.Id > 0).ToList();
                        Conto contoMillesimiSpalo = null;
                        if (idContoMillesimiSpalo != null)
                            contoMillesimiSpalo = _daoFactory.GetContoDao().GetById(
                                idContoMillesimiSpalo.Value, false);
                        fatalMessage = spese.Select(spesa => setRipartoBolletta(spesa, addebitiContatoriDivisionali, contoMillesimiSpalo, spese.Sum(item => item.ImportoBolletta.GetValueOrDefault()), _calcoliUtenzaService.GetRipartoBollette(), soggettiAttivi)).Where(messaggio => !string.IsNullOrEmpty(messaggio)).Aggregate(fatalMessage, (current, messaggio) => current + (messaggio + Environment.NewLine));

                        // =========================================================
                        //  Calcolo costi di riscaldamento dell'Acqua
                        // =========================================================
                        // Merge tra tutte le lista di consumo acqua calda
                        // ------------------------------------------------
                        var consumiAcquaCalda = new List<ConsumoUnita>();
                        if (consumiAcquaCaldaLista.Count > 0)
                        {
                            consumiAcquaCalda = consumiAcquaCaldaLista[0];
                            foreach (var t in consumiAcquaCaldaLista)
                            {
                                foreach (var consumo in t)
                                {
                                    var primoConsumo = (from item in consumiAcquaCalda
                                                        where item.IdUnitaImmobiliare == consumo.IdUnitaImmobiliare
                                                        select item).SingleOrDefault();
                                    if (primoConsumo.IdUnitaImmobiliare > 0)
                                        primoConsumo.ConsumoTotale += consumo.ConsumoTotale;
                                    else
                                        consumiAcquaCalda.Add(consumo);
                                }
                            }
                        }

                        // Calcolo importo del riscaldamento
                        // ------------------------------------------------
                        if (tipoUtenza.IsAcqua && idContoRiscaldamento != null && idContoAcquaRiscaldata != null && tariffaRiscaldamentoAcqua != null)
                        {
                            // Elimino testate di vecchi riparti
                            foreach (var testata in esercizio.TestateContabiliRipartoAcqua)
                            {
                                testata.EsercizioRiferimento.TestateContabili.Remove(testata);
                                testata.EsercizioRiferimento = null;
                                testata.EsercizioRipartoAcqua = null;
                            }
                            esercizio.TestateContabiliRipartoAcqua.Clear();

                            var testataRiparto = new TestataRipartoBollette(esercizio, tipoUtenza, dataRegistrazione)
                                {
                                    DescrizioneMovimentoAcqua = descrizioneMovimentoAcqua,
                                    DescrizioneMovimentoRiscaldamento = descrizioneMovimentoRiscaldamento
                                };
                            if (idContoAcquaRiscaldata != null)
                                testataRiparto.ContoAcquaRiscaldamento =_daoFactory.GetContoDao().GetById(idContoAcquaRiscaldata.GetValueOrDefault(), false);
                            if (idContoRiscaldamento != null)
                                testataRiparto.ContoRiscaldamento = _daoFactory.GetContoDao().GetById(idContoRiscaldamento.GetValueOrDefault(), false);
                            if (idContoMillesimiSpalo != null)
                                testataRiparto.ContoSpalo = _daoFactory.GetContoDao().GetById(idContoMillesimiSpalo.GetValueOrDefault(), false);
                            if (tariffaRiscaldamentoAcqua != null)
                                testataRiparto.TariffaRiscaldamentoAcqua = tariffaRiscaldamentoAcqua;

                            var importiRiscaldamento = new List<ImportiDTO>(consumiAcquaCalda.Count);
                            var ripartoBollette = _calcoliUtenzaService.GetRipartoBollette();
                            foreach (var consumo in consumiAcquaCalda)
                            {
                                var riparto = (from item in ripartoBollette
                                                where item.UnitaImmobiliare.ID == consumo.IdUnitaImmobiliare
                                                select item).SingleOrDefault();
                                if (riparto != null)
                                {
                                    riparto.ConsumoAcquaCalda += consumo.ConsumoTotale;
                                    riparto.ImportoAcquaCalda += consumo.ConsumoTotale*tariffaRiscaldamentoAcqua;
                                }
                                else
                                {
                                    new RipartoBollette(testataRiparto, _daoFactory.GetUnitaImmobiliareDao().GetById(consumo.IdUnitaImmobiliare, false))
                                    {
                                        ConsumoAcquaCalda = consumo.ConsumoTotale,
                                        ImportoAcquaCalda = consumo.ConsumoTotale*tariffaRiscaldamentoAcqua
                                    };
                                }

                                importiRiscaldamento.Add(new ImportiDTO(consumo.IdUnitaImmobiliare, consumo.ConsumoTotale*tariffaRiscaldamentoAcqua.Value));
                            }
                            var newTestata = _movimentoContabileService.SetMovimentiRiscaldamentoAcqua(esercizio, idContoAcquaRiscaldata.Value, idContoRiscaldamento.Value, descrizioneMovimentoAcqua, descrizioneMovimentoRiscaldamento, importiRiscaldamento, dataRegistrazione.Value);
                            newTestata.EsercizioRipartoAcqua = esercizio;
                            esercizio.TestateContabiliRipartoAcqua.Add(newTestata);
                        }

                        // =========================================================
                        //  Calcolo importi contatori condominiali
                        // =========================================================
                        // Elimino testate di vecchi riparti
                        foreach (var testata in esercizio.TestateContabiliRipartoContatoreCondominiale)
                        {
                            testata.EsercizioRiferimento = null;
                            testata.EsercizioRipartoContatoreCondominiale = null;
                        }
                        esercizio.TestateContabiliRipartoContatoreCondominiale.Clear();

                        // Elimino parametri contatore condominiale
                        var parametriCondominiale =
                            _daoFactory.GetTestataRipartoContatoreCondominialeDao().GetByEsercizio(idEsercizio);
                        foreach (var testataRipartoContatoreCondominiale in parametriCondominiale)
                            _daoFactory.GetTestataRipartoContatoreCondominialeDao()
                                        .Delete(testataRipartoContatoreCondominiale);

                        var addebitiContatoriCondominiali = addebitiCalcolati.Where(item => item.Id < 0).ToList();
                        foreach (var importiDTO in addebitiContatoriCondominiali)
                        {
                            var dto = importiDTO;
                            var parametriMovimento =
                                parametriAddebitoMovimenti.FirstOrDefault(item => item.Id == dto.Id*-1);
                            var contoAddebito = _daoFactory.GetContoDao().GetById(parametriMovimento.IdConto, false);
                            var sottoContoAddebito =
                                _daoFactory.GetSottoContoDao().GetById(parametriMovimento.IdSottoConto, false);

                            var importoTotaleBollette = spese.Sum(item => item.ImportoBolletta.GetValueOrDefault());
                            var contiAddebito = new Dictionary<string, decimal>();
                            foreach (var spesa in spese)
                            {
                                foreach (var movimento in spesa.MovimentiBollette)
                                {
                                    var key = getKeyContoSottoconto(movimento.ContoRiferimento, movimento.SottoContoRiferimento);
                                    if (contiAddebito.ContainsKey(key))
                                        contiAddebito[key] += movimento.GetImportoConSegno().GetValueOrDefault();
                                    else
                                        contiAddebito.Add(key, movimento.GetImportoConSegno().GetValueOrDefault());
                                }
                            }

                            var importiAccredito = new List<ImportoMovimento>();
                            foreach (var importoConto in contiAddebito)
                            {
                                var contoAry = importoConto.Key.Split('|');

                                var idConto = int.Parse(contoAry[0]);
                                int? idSottoConto = null;
                                if (int.Parse(contoAry[1]) > 0)
                                    idSottoConto = int.Parse(contoAry[1]);

                                var importo = (importiDTO.Importo*importoConto.Value)/importoTotaleBollette;
                                importiAccredito.Add(new ImportoMovimento(idConto, idSottoConto, importo));
                            }
                            var testataMovimentiCondominiali = _movimentoContabileService.SetMovimentiContatoreCondominiale(esercizio, importiAccredito, addebitiContatoriDivisionali, dataRegistrazione.GetValueOrDefault(), contoAddebito, sottoContoAddebito, parametriMovimento.Descrizione);
                            testataMovimentiCondominiali.EsercizioRipartoContatoreCondominiale = esercizio;
                            esercizio.TestateContabiliRipartoContatoreCondominiale.Add(testataMovimentiCondominiali);

                            // salvo i parametri di riparto del contatore condominiale 
                            var parametriRipartoContatore =
                                _daoFactory.GetTestataRipartoContatoreCondominialeDao()
                                            .GetByEsercizioContatore(esercizio.ID, importiDTO.Id);
                            foreach (var ripartoContatoreCondominiale in parametriRipartoContatore)
                                _daoFactory.GetTestataRipartoContatoreCondominialeDao()
                                            .Delete(ripartoContatoreCondominiale);

                            var testataRipartoContatoreCondominiale = new TestataRipartoContatoreCondominiale(esercizio, _daoFactory.GetContatoreDao().GetById(importiDTO.Id*-1, false), contoAddebito, sottoContoAddebito, parametriMovimento.Descrizione);
                            _daoFactory.GetTestataRipartoContatoreCondominialeDao().SaveOrUpdate(testataRipartoContatoreCondominiale);
                        }

                    }
                    else
                    {
                        if (spesePresenti)
                        {
                            var messageSpese = spese.Aggregate(string.Empty, (current, spesa) => current + (string.Format(" - n.{0} del {1} - utenza:{2}", spesa.NumeroDocumento, spesa.DataDocumento.GetValueOrDefault().ToShortDateString(), spesa.Utenza.Numero) + Environment.NewLine));
                            fatalMessage += "Non sono presenti letture sufficienti per ripartire le seguenti bollette:" + Environment.NewLine + messageSpese;
                        }
                        else
                        {
                            warnMessage += string.Format("Per l'utenza: '{0}' non sono presenti bollette da ripartire", utenza.Descrizione.Trim());
                        }
                    }
                }

                return new AuthorizationMessages(fatalMessage, warnMessage);
            }
            catch (Exception ex)
            {
                _log.Error("Errore inaspettato durante la ripartizione delle bollette - " + Library.Utility.GetMethodDescription() + " - idEsercizio: " + idEsercizio + " - tipoUtenza: " + tipoUtenza + " - idContoAcquaRiscaldata:" + idContoAcquaRiscaldata.GetValueOrDefault() + " - idContoRiscaldamento:" + idContoRiscaldamento.GetValueOrDefault() + " - idContoMillesimiSpalo:" + idContoMillesimiSpalo.GetValueOrDefault() + " - descrizioneMovimentoAcqua:" + descrizioneMovimentoAcqua + " - descrizioneMovimentoRiscaldamento:" + descrizioneMovimentoRiscaldamento + " - tariffaRiscaldamentoAcqua:" + tariffaRiscaldamentoAcqua + " - dataRegistrazione:" + dataRegistrazione, ex);
                throw;
            }
        }
Ejemplo n.º 6
0
 /// <summary>
 /// Crea una Testata di movimento contabile valida
 /// </summary>
 public TestataRipartoBollette(Esercizio esercizio, TipoUtenza tipoUtenza, DateTime? dataRegistrazione)
 {
     Esercizio = esercizio;
     DataRegistrazione = dataRegistrazione;
     TipoUtenza = tipoUtenza;
 }