public SpesaInfoDTO SalvaMovimento(RipartizioneSpeseDTO ripartizione, MovimentoContabileDTO movimentoAvere, List<MovimentoContabileDTO> movimentiDare, int? idMovimentoBancario)
        {
            var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
            var movimentoContabileService = _windsorRepository.GetContainer(_info.Azienda).Resolve<IMovimentiContabiliService>();
            var ripartizioneSpeseService = _windsorRepository.GetContainer(_info.Azienda).Resolve<IRipartizioneSpeseService>();
            var protocolloService = _windsorRepository.GetContainer(_info.Azienda).Resolve<IProtocolloService>();
            var archiviazioneService = _windsorRepository.GetContainer(_info.Azienda).Resolve<IArchiviazioneOtticaService>();
            var persistenceContextService = _windsorRepository.GetContainer(_info.Azienda).Resolve<Data.IPersistenceContext>();

            var index = 0;
            movimentoAvere.NumeroRiga = index+1;
            movimentoAvere.Descrizione = ripartizione.Descrizione;

            if (movimentoAvere.Importo > 0)
                movimentoAvere.Segno = "A";
            else
            {
                movimentoAvere.Segno = "D";
                movimentoAvere.Importo = movimentoAvere.Importo * -1;
            }

            int? idEsercizio = null;
            try
            {
                var esercizio = daoFactory.GetEsercizioDao().GetById(ripartizione.Testata.IdEsercizio.GetValueOrDefault(), true);

                if (esercizio.Stato == StatoEsercizioEnum.Aperto)
                {
                    idEsercizio = esercizio.ID;
                    var numeroRegistrazione = esercizio.ProgressivoRegistrazioneContabile;
                    ripartizione.Testata.Movimenti = new MovimentoContabileDTO[movimentiDare.Count + 1];
                    ripartizione.Testata.Movimenti[0] = movimentoAvere;
                    numeroRegistrazione++;
                    movimentoAvere.NumeroRegistrazione = numeroRegistrazione;

                    // Salvo eventuali valori del movimento patrimoniale originale
                    if(movimentoAvere.ID > 0)
                    {
                        var movimento = daoFactory.GetMovimentoContabileDao().Find(movimentoAvere.ID, false);
                        if (movimento?.EvasioneBancaria != null)
                            movimentoAvere.IdEvasione = movimento.EvasioneBancaria.ID;
                    }

                    if (!(ripartizione.Testata.IdModelloRipartizione > 0))
                    {
                        foreach (var movimentoEconomico in movimentiDare)
                        {
                            index++;
                            numeroRegistrazione++;

                            if (movimentoEconomico.Importo < 0)
                            {
                                movimentoEconomico.Importo = movimentoEconomico.Importo*-1;
                                movimentoEconomico.Segno = "A";
                            }
                            else
                                movimentoEconomico.Segno = "D";

                            movimentoEconomico.IsMovimentoEconomico = true;
                            movimentoEconomico.NumeroRegistrazione = numeroRegistrazione;
                            movimentoEconomico.Causale = movimentoAvere.Causale;
                            movimentoEconomico.IdFornitore = movimentoAvere.IdFornitore;
                            if (string.IsNullOrEmpty(movimentoEconomico.Descrizione) && !esercizio.CondominioRiferimento.DescrizioneSpeseAutomatica)
                                movimentoEconomico.Descrizione = ripartizione.Descrizione;
                            movimentoEconomico.IdTestata = ripartizione.Testata.ID;
                            ripartizione.Testata.Movimenti[index] = movimentoEconomico;

                            // ---------------------------------------------------------------------
                            // Aggiorno addebiti per lotto, stabile o scala
                            // ---------------------------------------------------------------------
                            var spesePersonali = false;
                            if (movimentoEconomico.ID > 0)
                            {
                                var movimento = daoFactory.GetMovimentoContabileDao().Find(movimentoEconomico.ID, false);
                                if (movimento != null)
                                {
                                    movimentoEconomico.LottiAddebito = movimento.LottiAddebito;
                                    movimentoEconomico.StabiliAddebito = movimento.StabiliAddebito;
                                    movimentoEconomico.GruppiAddebito = movimento.GruppiAddebito;
                                    spesePersonali = movimento.ContoRiferimento.IsSpesePersonali;
                                }
                            }

                            // ---------------------------------------------------------------------
                            //  Verifico se è stata eseguita una ripartizione personalizzata
                            // ---------------------------------------------------------------------
                            var key = ripartizioneSpeseService.GetKey(movimentoEconomico);

                            movimentoEconomico.IsRipartoPersonalizzato = false;

                            // Lasciare la valorizzazione di NumeroRiga DOPO il GetKey altrimenti la chiave NON viene trovata per i movimenti con più di 1 conto economico
                            movimentoEconomico.NumeroRiga = index + 1;

                            if (ripartizione.UnitaImmobiliari != null && ripartizione.UnitaImmobiliari.ContainsKey(key))
                            {
                                movimentoEconomico.LottiAddebito = getLottiAddebito(ripartizione, key);
                                movimentoEconomico.StabiliAddebito = getStabiliAddebito(ripartizione, key);
                                movimentoEconomico.GruppiAddebito = getGruppiAddebito(ripartizione, key);

                                var unita = ripartizione.UnitaImmobiliari[key];
                                var isPersonalizzato = unita.Count(item => item.Selezionato) < unita.Length;

                                // Considero il movimento come ripartito personalmente se non sono presenti specifici riparti per lotto, stabile o scala e non si tratta di un conto di spese personali
                                if (isPersonalizzato && !spesePersonali && string.IsNullOrEmpty(movimentoEconomico.LottiAddebito) && string.IsNullOrEmpty(movimentoEconomico.StabiliAddebito) && string.IsNullOrEmpty(movimentoEconomico.GruppiAddebito))
                                    movimentoEconomico.IsRipartoPersonalizzato = true;
      
                                var conto = daoFactory.GetContoDao().GetById(movimentoEconomico.IdConto.Value, false);
                                if (conto.IsSpesePersonali || movimentoEconomico.IsRipartoPersonalizzato)
                                {
                                    movimentoEconomico.DettaglioRipartizione = new SpeseUnitaDTO[unita.Length];

                                    // -----------------------------------------------------------
                                    // Per le unità ricalcolo gli importi
                                    // -----------------------------------------------------------
                                    var instanceModificata = getInstanceModificata(ripartizione, key);
                                    if (!string.IsNullOrEmpty(instanceModificata) && instanceModificata != "U")
                                        GetRipartizioneByMovimento(movimentoEconomico, esercizio.ID, ripartizione);
                                    else
                                    {
                                        movimentoEconomico.DettaglioRipartizione = new SpeseUnitaDTO[movimentoEconomico.DettaglioRipartizione.Length];
                                        var unitaSelected = ripartizione.UnitaImmobiliari[key];
                                        for (var i = 0; i < unitaSelected.Length; i++)
                                        {
                                            if (unitaSelected[i].Selezionato)
                                            {
                                                var spesaUnitaDto = new SpeseUnitaDTO { ID = 0, IdMovimentoRiferimento = movimentoEconomico.ID, Importo = unitaSelected[i].Importo };
                                                if (unitaSelected[i].IdSoggettoCondominio > 0)
                                                    spesaUnitaDto.IdSoggetto = unitaSelected[i].IdSoggettoCondominio;
                                                else
                                                    spesaUnitaDto.IdUnitaRiferimento = unitaSelected[i].ID;
                                                movimentoEconomico.DettaglioRipartizione[i] = spesaUnitaDto;
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }

                    // -------------------------------------------
                    // Elimino vecchia testata
                    // -------------------------------------------
                    int? oldProtocollo = null;
                    int? oldAnnoArchiviazione = null;
                    var oldTipoTestata = TipoTestataMovimentoContabileEnum.Undefined;
                    AddebitoCompetenza addebito = null;
                    var testataOld = daoFactory.GetTestataMovimentoContabileDao().Find(ripartizione.Testata.ID, false);
                    if (testataOld != null)
                    {
                        if (testataOld.AddebitoCompetenze.Count > 0)
                            addebito = Library.IesiGenericCollections<AddebitoCompetenza>.GetByIndex(testataOld.AddebitoCompetenze, 0);

                        oldProtocollo = testataOld.NumeroProtocollo;
                        oldAnnoArchiviazione = testataOld.AnnoArchiviazioneOttica;
                        testataOld.EsercizioRiferimento = null;

                        // ------------------------------------------------------------------------
                        //  Nel caso si tratti di un movimento generato automaticamente dalla procedura solleciti
                        //  elimino la relazione tra sollecito e movimento contabile.
                        //  Solo per le vecchie versioni di addebito competenze solleciti
                        // ------------------------------------------------------------------------
                        if (testataOld.Tipo == TipoTestataMovimentoContabileEnum.Automatica)
                        {
                            oldTipoTestata = testataOld.Tipo;

                            // per impostare correttamente la descrizione della testata
                            movimentoAvere.Descrizione = testataOld.Descrizione;

                            var solleciti = daoFactory.GetSollecitoDao().GetByTestataMovimentoContabile(testataOld.ID);
                            foreach (var sollecito in solleciti)
                                sollecito.MovimentoEconomico = null;

                            ripartizione.Testata.Tipo = testataOld.Tipo;
                        }

                        daoFactory.GetTestataMovimentoContabileDao().Delete(testataOld);

                        ripartizione.Testata.ID = 0;
                        foreach (var movDto in ripartizione.Testata.Movimenti)
                        {
                            if (movDto != null)
                                movDto.ID = 0;
                        }
                    }

                    // -------------------------------------------
                    // Creo nuova testata
                    // -------------------------------------------
                    var rep = new TestataMovimentoContabileRepository(_info, _windsorRepository, null);
                    var testata = rep.ManageDomainEntity(ripartizione.Testata);
                    if (testata == null || movimentoAvere == null)
                    {
                        if (testata == null)
                        {
                            _log.ErrorFormat("Errore inaspettato nel salvataggio (UPDATE) del movimento - TESTATA NULL - {0} - esercizio:{1} - azienda:{2}", Library.Utility.GetMethodDescription(), idEsercizio.GetValueOrDefault(), _info.Azienda);
                            persistenceContextService.RollbackAndCloseSession(Security.Login.Instance.CurrentLogin().LoginName);
                            persistenceContextService.BeginTransaction(Security.Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
                            return new SpesaInfoDTO { Id = 0, NumeroProtocollo = 0, IdentificativoArchiviazione = null, StampaEtichettaArchiviazione = false, Message = "Errore inaspettato nel salvataggio del movimento, si prega di riprovare." };
                        }

                        if (movimentoAvere == null)
                        {
                            _log.ErrorFormat("Errore inaspettato nel salvataggio (UPDATE) del movimento - MOVIMENTO AVERE NULL - {0} - esercizio:{1} - azienda:{2}", Library.Utility.GetMethodDescription(), idEsercizio.GetValueOrDefault(), _info.Azienda);
                            persistenceContextService.RollbackAndCloseSession(Security.Login.Instance.CurrentLogin().LoginName);
                            persistenceContextService.BeginTransaction(Security.Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
                            return new SpesaInfoDTO { Id = 0, NumeroProtocollo = 0, IdentificativoArchiviazione = null, StampaEtichettaArchiviazione = false, Message = "Errore inaspettato nel salvataggio del movimento, si prega di riprovare." };
                        }
                    }

                    testata.Descrizione = movimentoAvere.Descrizione;
                    if (oldProtocollo != null)
                        testata.NumeroProtocollo = oldProtocollo;
                    if (oldAnnoArchiviazione != null)
                        testata.AnnoArchiviazioneOttica = oldAnnoArchiviazione;
                    if (oldTipoTestata != TipoTestataMovimentoContabileEnum.Undefined)
                        testata.Tipo = oldTipoTestata;

                    // Aggiorno eventuali addebiti di competenze esistenti
                    if (addebito != null)
                    {
                        addebito.TestataMovimento = testata;
                        IList<MovimentoContabile> movimentiEconomici = testata.Movimenti.Where(item => item.IsEconomico()).ToList();
                        IList<DettaglioAddebitoCompetenza> dettagliAddebito = addebito.Dettaglio.ToList();
                        if (movimentiEconomici.Count == dettagliAddebito.Count)
                        {
                            for (var i = 0; i < dettagliAddebito.Count; i++)
                                dettagliAddebito[i].MovimentoContabile = movimentiEconomici[i];
                        }
                        else
                        {
                            throw new InvalidDataException("Non è possibile aggiornare direttamente un movimento contabile generato da un addebito di competenze");
                            //foreach (var dettaglioAddebito in addebito.Dettaglio)
                            //    dettaglioAddebito.MovimentoContabile = null;
                        }
                    }

                    // ======================================================================================
                    //  Evasione Movimenti
                    // ======================================================================================
                    if (idMovimentoBancario != null)
                    {
                        IList<MovimentoContabile> movimentiContabili = (from movimento in testata.Movimenti where !movimento.IsEconomico() select movimento).ToList();
                        IList<int> idMovimentiBancari = new List<int> {idMovimentoBancario.GetValueOrDefault()};
                        movimentoContabileService.EvadiMovimento($"Evasione automatica registrazione movimento contabile del {ripartizione.Testata.DataRegistrazione.GetValueOrDefault():d}", movimentiContabili, idMovimentiBancari, null, null);
                    }

                    // =====================================================================================================
                    //  Se presente applico il modello di ripartizione, altrimenti ricalcolo valori o l'intera ripartizione
                    // =====================================================================================================
                    if (ripartizione.Testata.IdModelloRipartizione > 0)
                    {
                        var tipo = TipoMovimentoEnum.Spesa;
                        if (movimentoAvere.Segno == "D")
                            tipo = TipoMovimentoEnum.Accredito;

                        // NON VIENE PIù RICALCOLATA LE RIPARTIZIONE, SARA' CALCOLATA IN FASE DI BILANCIO
                        ripartizioneSpeseService.ApplyModello(testata, ripartizione.Testata.IdModelloRipartizione.Value, movimentoAvere.Importo.Value, tipo, false);

                        // Ripristino le descrizioni precedenti se presenti
                        foreach (var dto in movimentiDare)
                        {
                            if (!string.IsNullOrEmpty(dto.Descrizione))
                            {
                                var movimento = (from item in testata.Movimenti
                                                 where item.NumeroRiga == dto.NumeroRiga
                                                 select item).SingleOrDefault();
                                if (movimento != null)
                                    movimento.Descrizione = dto.Descrizione;
                            }
                        }
                    }
                    else
                    {
                        // Salvataggio modello
                        testata.ModelloRipartizione = SalvaModelloRipartizioneContabile(ripartizione, testata, movimentiDare, movimentoAvere.Importo.Value);
                    }

                    // =====================================================================================================
                    // Salvataggio progressivo registrazione
                    // =====================================================================================================
                    esercizio.ProgressivoRegistrazioneContabile = numeroRegistrazione;

                    // =====================================================================================================
                    // Registrazione dell'eventuale arrotondamento
                    // =====================================================================================================
                    if (testata.Movimenti.FirstOrDefault() != null)
                        movimentoContabileService.SetMovimentoArrotondamento(null, testata, testata.Movimenti.FirstOrDefault().Causale, null);

                    // ======================================================================================
                    //  Recupero il numero di protocollo e l'identificativo di archiviazione
                    // ======================================================================================
                    int protocollo;
                    if (testata.NumeroProtocollo.GetValueOrDefault() == 0)
                    {
                        {
                            var progressivo = protocolloService.GetProgressivo(TipoProtocollo.Fattura,
                                esercizio.DataApertura.GetValueOrDefault().Year,
                                testata.EsercizioRiferimento.CondominioRiferimento);
                            if (progressivo.Progressivo != null)
                            {
                                protocollo = progressivo.Progressivo.Value;
                                testata.NumeroProtocollo = protocollo;
                                testata.AnnoArchiviazioneOttica = esercizio.DataApertura.GetValueOrDefault().Year;
                            }
                            else
                                return new SpesaInfoDTO
                                {
                                    Id = 0,
                                    IdentificativoArchiviazione = null,
                                    NumeroProtocollo = 0,
                                    StampaEtichettaArchiviazione = false,
                                    Message = progressivo.Message
                                };
                        }
                    }
                    else
                    {
                        protocollo = testata.NumeroProtocollo.Value;
                    }

                    var identificativoArchiviazione = archiviazioneService.GetIdentificativoArchiviazione(testata);

                    var movimentoPatrimoniale = (from item in testata.Movimenti
                                                 where item.NumeroRiga == movimentoAvere.NumeroRiga
                                                 select item).FirstOrDefault();
                    var idMovimentoPatrimoniale = 0;
                    if (movimentoPatrimoniale != null)
                        idMovimentoPatrimoniale = movimentoPatrimoniale.ID;

                    var impostazioni = daoFactory.GetImpostazioniAziendaDao().GetByAzienda(esercizio.CondominioRiferimento.Azienda.ID);
                    if (impostazioni == null)
                    {
                        impostazioni = new ImpostazioniAzienda(daoFactory.GetAziendaDao().GetById(esercizio.CondominioRiferimento.Azienda.ID, false));
                        daoFactory.GetImpostazioniAziendaDao().SaveOrUpdate(impostazioni);
                    }

                    var stampaEtichetta = false;
                    var etichettatrice = string.Empty;
                    var tipoEichetta = "Testo";
                    int? trayEtichettatriceAttivazioneOttica = null;
                    if (impostazioni != null)
                    {
                        stampaEtichetta = impostazioni.UtilizzoEtichettatriceArchiviazioneOtticaMovimenti && testata.IsAbilitataArchiviazioneOttica;
                        etichettatrice = impostazioni.EtichettatriceArchiviazioneOttica;
                        tipoEichetta = impostazioni.TipoEtichettaArchiviazioneOttica;
                        trayEtichettatriceAttivazioneOttica = impostazioni.TrayEtichettatriceAttivazioneOttica;
                    }

                    return new SpesaInfoDTO
                    {
                        Id = idMovimentoPatrimoniale,
                        NumeroProtocollo = testata.NumeroProtocollo.Value,
                        IdentificativoArchiviazione = identificativoArchiviazione,
                        StampaEtichettaArchiviazione = stampaEtichetta,
                        EtichettatriceArchiviazione = etichettatrice,
                        TipoEtichettaArchiviazione = tipoEichetta,
                        TrayEtichettatriceAttivazioneOttica = trayEtichettatriceAttivazioneOttica
                    };
                }
                return new SpesaInfoDTO
                {
                    Id = 0,
                    NumeroProtocollo = 0,
                    IdentificativoArchiviazione = null,
                    StampaEtichettaArchiviazione = false,
                    Message = "La registrazione non è possibile perchè relativo ad un esercizio chiuso."
                };
            }
            catch (Exception ex)
            {
                var message = ex.ToString().StartsWith("NHibernate.StaleObjectStateException") ? "Un altro utente ha confermato un movimento." : "Errore inaspettato nell'attribuzione del numero di registrazione, probabilmente determinato da un conflitto di aggiornamento";
                
                _log.ErrorFormat("Errore inaspettato nel salvataggio (UPDATE) del movimento - {0} - idMovimentoAvere:{1} - esercizio:{2} - azienda:{3}", ex, Library.Utility.GetMethodDescription(), movimentoAvere.ID, idEsercizio.GetValueOrDefault(), _info.Azienda);
                persistenceContextService.RollbackAndCloseSession(Security.Login.Instance.CurrentLogin().LoginName);
                persistenceContextService.BeginTransaction(Security.Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
                return new SpesaInfoDTO { Id = 0, NumeroProtocollo = 0, IdentificativoArchiviazione = null, StampaEtichettaArchiviazione = false, Message = message };
            }

        }
        public RipartizioneSpeseDTO GetRipartizioneByModello(int idEsercizio, int idTestataMovimentoContabile, int idModello, int idCausale, decimal importo, TipoMovimentoEnum tipo)
        {

            var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
            var ripartizioneSpeseService = _windsorRepository.GetContainer(_info.Azienda).Resolve<IRipartizioneSpeseService>();

            var testataRep = new TestataMovimentoContabileRepository(_info, _windsorRepository, null);
            var ripartizione = new RipartizioneSpeseDTO();
            try
            {
                var testata = daoFactory.GetTestataMovimentoContabileDao().Find(idTestataMovimentoContabile, false);
                if (testata != null)
                    ripartizioneSpeseService.ApplyModello(testata, idModello, importo, tipo, false);
                else
                    testata = ripartizioneSpeseService.ApplyModello(idEsercizio, idModello, idCausale, importo, tipo, false);

                if(testata != null)
                    ripartizione.Testata = testataRep.GetByDomainEntity(testata);
                else
                    _log.WarnFormat("Testata a NULL - {0} - esercizio:{1} - modello:{2} - testataMovimentoContabile:{3}", Library.Utility.GetMethodDescription(), idEsercizio, idModello, idTestataMovimentoContabile);

                return ripartizione;

                // --------------------------------------
                // Lotti
                // --------------------------------------
                var esercizio = daoFactory.GetEsercizioDao().GetById(idEsercizio, false);
                var lotti = new Dictionary<string, BusinessInstanceSelectedDTO[]>(testata.Movimenti.Count);
                foreach (var movimento in testata.Movimenti)
                {
                    var key = ripartizioneSpeseService.GetKey(movimento);
                    var tbLotti = ripartizioneSpeseService.GetLottiDataSource(key, movimento.ContoRiferimento.ID, esercizio.CondominioRiferimento.ID, null);
                    lotti.Add(key, getListaDto(tbLotti)); 
                }
                ripartizione.Lotti = lotti;

                // --------------------------------------
                // Stabili
                // --------------------------------------
                var stabili = new Dictionary<string, BusinessInstanceSelectedDTO[]>(testata.Movimenti.Count);
                foreach (var movimento in testata.Movimenti)
                {
                    string key = ripartizioneSpeseService.GetKey(movimento);
                    var tbStabili = ripartizioneSpeseService.GetStabiliDataSource(key, movimento.ContoRiferimento.ID, esercizio.CondominioRiferimento.ID, null);
                    stabili.Add(key, getListaDto(tbStabili));
                }
                ripartizione.Stabili = stabili;

                // --------------------------------------
                // Gruppi
                // --------------------------------------
                var gruppi = new Dictionary<string, BusinessInstanceSelectedDTO[]>(testata.Movimenti.Count);
                foreach (var movimento in testata.Movimenti)
                {
                    var key = ripartizioneSpeseService.GetKey(movimento);
                    var tbGruppi = ripartizioneSpeseService.GetGruppiDataSource(key, movimento.ContoRiferimento.ID, esercizio.CondominioRiferimento.ID, null);
                    gruppi.Add(key, getListaDto(tbGruppi));
                }
                ripartizione.Gruppi = gruppi;
                
                // --------------------------------------
                // Unità Immobiliari
                // --------------------------------------
                var unita = new Dictionary<string, UnitaImmobiliareSelectedDTO[]>(testata.Movimenti.Count);
                foreach (var movimento in testata.Movimenti)
                {
                    var key = ripartizioneSpeseService.GetKey(movimento);
                    var tbUnita = ripartizioneSpeseService.GetUnitaDataSource(key, movimento.ContoRiferimento.ID, esercizio.CondominioRiferimento.ID, testata.EsercizioRiferimento);

                    unita.Add(key, getListaUnitaDto(tbUnita, movimento.ContoRiferimento));
                }
                ripartizione.UnitaImmobiliari = unita;

                return ripartizione;
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore nel caricamento delle ripartizioni spese - {0} - esercizio:{1} - modello:{2} - testataMovimentoContabile:{3}", ex, Library.Utility.GetMethodDescription(), idEsercizio, idModello, idTestataMovimentoContabile);
                throw;
            }
        }
        public RipartizioneSpeseDTO GetRipartizioneByMovimentoEsistente(MovimentoContabileDTO movimentoDto, int idEsercizio, RipartizioneSpeseDTO ripartizione, int? idContoDetrazione = null)
        {
            var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
            var esercizio = daoFactory.GetEsercizioDao().GetById(idEsercizio, false);
            var ripartizioneSpeseService = _windsorRepository.GetContainer(_info.Azienda).Resolve<IRipartizioneSpeseService>();
            var repTestata = new TestataMovimentoContabileRepository(_info, _windsorRepository, null);

            IRipartizioneSpesa movimento = null;
            if (movimentoDto.Stato == "RIPARTIZIONE")
                movimento = daoFactory.GetRipartizioneSpesaDao().Find(movimentoDto.ID, false); 
            else
                movimento = daoFactory.GetMovimentoContabileDao().Find(movimentoDto.ID, false);
            
            var movimentoContabile = movimento as MovimentoContabile;
            if(movimento != null)
            {
                try
                {
                    var key = ripartizioneSpeseService.GetKey(movimentoDto);

                    if (ripartizione == null)
                        ripartizione = new RipartizioneSpeseDTO();

                    if (movimentoContabile != null)
                    {
                        key = ripartizioneSpeseService.GetKey(movimentoContabile);
                        if (movimentoContabile.Testata != null)
                            ripartizione.Testata = repTestata.GetByDomainEntity(movimentoContabile.Testata);
                    }
                    else if (movimentoDto.Stato != "RIPARTIZIONE")
                    {
                        _log.ErrorFormat("Trovato movimento contabile senza testata associata - {0} - id:{1}", Library.Utility.GetMethodDescription(), movimento.ID);
                    }

                    // -----------------------------------------------
                    // Recupero eventuali filtri di selezione
                    // -----------------------------------------------
                    // Gruppi
                    int[] gruppiSelezionati = null;
                    if (!string.IsNullOrEmpty(movimento.GruppiAddebito))
                    {
                        var gruppiAddebito = movimento.GruppiAddebito.Split('&');
                        gruppiSelezionati = new int[gruppiAddebito.Length];
                        for (var i = 0; i < gruppiAddebito.Length; i++)
                        {
                            if (!string.IsNullOrEmpty(gruppiAddebito[i]))
                                gruppiSelezionati[i] = int.Parse(gruppiAddebito[i]);
                        }
                    }

                    // Lotti
                    int[] lottiSelezionati = null;
                    if (!string.IsNullOrEmpty(movimento.LottiAddebito))
                    {
                        string[] lottiAddebito = movimento.LottiAddebito.Split('&');
                        lottiSelezionati = new int[lottiAddebito.Length];
                        for (var i = 0; i < lottiAddebito.Length; i++)
                        {
                            if (!string.IsNullOrEmpty(lottiAddebito[i]))
                                lottiSelezionati[i] = int.Parse(lottiAddebito[i]);
                        }
                    }

                    // Stabili
                    int[] stabiliSelezionati = null;
                    if (!string.IsNullOrEmpty(movimento.StabiliAddebito))
                    {
                        var stabiliAddebito = movimento.StabiliAddebito.Split('&');
                        stabiliSelezionati = new int[stabiliAddebito.Length];
                        for (var i = 0; i < stabiliAddebito.Length; i++)
                        {
                            if (!string.IsNullOrEmpty(stabiliAddebito[i]))
                                stabiliSelezionati[i] = int.Parse(stabiliAddebito[i]);
                        }
                    }

                    if (movimentoContabile == null || movimentoContabile.Testata != null)
                    {
                        var conto = daoFactory.GetContoDao().Find(movimentoDto.IdConto.GetValueOrDefault(), false);
                        if (conto != null)
                        {
                            Conto contoDetrazione = null;
                            if (idContoDetrazione != null)
                            {
                                contoDetrazione = daoFactory.GetContoDao().Find(idContoDetrazione.GetValueOrDefault(), false);
                                conto = contoDetrazione;
                            }

                            ripartizione.UnitaImmobiliari[key] = getListaUnitaDto(ripartizioneSpeseService.GetUnitaDataSourceByMovimento(key, movimento, contoDetrazione), conto);
                            ripartizione.Lotti[key] = getListaDto(ripartizioneSpeseService.GetLottiDataSource(key, movimentoDto.IdConto, esercizio.CondominioRiferimento.ID, lottiSelezionati));
                            ripartizione.Stabili[key] = getListaDto(ripartizioneSpeseService.GetStabiliDataSource(key, movimentoDto.IdConto, esercizio.CondominioRiferimento.ID, stabiliSelezionati));
                            ripartizione.Gruppi[key] = getListaDto(ripartizioneSpeseService.GetGruppiDataSource(key, movimentoDto.IdConto, esercizio.CondominioRiferimento.ID, gruppiSelezionati));
                        }
                    }

                    return ripartizione;
                }
                catch (Exception ex)
                {
                    _log.ErrorFormat("Errore nel caricamento delle ripartizioni spese - {0}", ex, Library.Utility.GetMethodDescription());
                    throw;
                }                
            }

            return ripartizione;
        }
Esempio n. 4
0
		public string IsAllowDeleteTestataMovimentoContabile(int idTestata, UserInfo userinfo)
		{
			var windsorRep = new WindsorConfigRepository();
			try
			{
				windsorRep.BeginTransaction(userinfo);
                var repo = new TestataMovimentoContabileRepository(userinfo, windsorRep, null);
                var item = repo.IsAllowDelete(idTestata);
				windsorRep.Commit();
				return item;
			}
			catch (Exception ex)
			{
                _log.ErrorFormat("Errore nel controllo della autorizzazione per la eliminazione della testata dei movimenti contabili - {0} - idTestata:{1}", ex, Utility.GetMethodDescription(), idTestata);
				windsorRep.Rollback();
				throw;
			}
		}
Esempio n. 5
0
		public string DeleteTestataMovimentoContabile(int idTestata, UserInfo userinfo)
		{
            var retryCount = 5;
            var success = false;
            var windsorRep = new WindsorConfigRepository();
            string item = null;
            while (retryCount >= 0 && !success)
            {
                try
                {
                    windsorRep.BeginTransaction(userinfo);
                    var repo = new TestataMovimentoContabileRepository(userinfo, windsorRep, null);
                    item = repo.Delete(idTestata);
                    windsorRep.Commit();
                    success = true;
                }
                catch (Exception ex)
                {
                    _log.ErrorFormat("Errore nella eliminazione della testata dei movimenti contabili: - TENTATIVO:{0} - {1} - idTestata:{2} - azienda:{3} - number:{4}", ex, (6 - retryCount), Utility.GetMethodDescription(), idTestata, userinfo.Azienda, getExceptionId(ex));

                    windsorRep.Rollback();
                    if (!isRetryException(ex))
                        throw;

                    // Add delay here if you wish. 
                    System.Threading.Thread.Sleep(1000 * (6 - retryCount));
                    retryCount--;
                    _log.InfoFormat("Eliminazione della testata dei movimenti contabili: - INIZIO TENTATIVO:{0} - {1} - idTestata:{2} - azienda:{3}", (6 - retryCount), Utility.GetMethodDescription(), idTestata, userinfo.Azienda);
                }
            }

            if (!success)
                windsorRep.Rollback();

            return item;
		}
Esempio n. 6
0
        public TestataMovimentoContabileGenericoDTO GetTestataMovimentoContabileGenericoById(int idTestata, UserInfo userinfo)
		{
			var windsorRep = new WindsorConfigRepository();
			try
			{
				windsorRep.BeginTransaction(userinfo);
                var repo = new TestataMovimentoContabileRepository(userinfo, windsorRep, null);
                var item = repo.GetGenericoById(idTestata);
				windsorRep.Commit();
				return item;
			}
			catch (Exception ex)
			{
                _log.ErrorFormat("Errore nella lettura delle testate generiche dei movimenti contabili - {0} - testata:{1}", ex, Utility.GetMethodDescription(), idTestata);
				windsorRep.Rollback();
				throw;
			}
		}