Пример #1
0
        /// <summary>
        /// Crea una Spesa Unità valida
        /// </summary>
        public SpeseUnita(decimal? importo, UnitaImmobiliare unita, SoggettoCondominio soggettoCondominio, MovimentoContabile movimento)
        {
            _importo = importo;
            _unitaRiferimento = unita;
            _soggettoCondominio = soggettoCondominio;

            if (movimento != null)
            {
                _movimentoRiferimento = movimento;
                _movimentoRiferimento.DettaglioRipartizione.Add(this);
            }
        }
        private string insert(MovimentoContabileDTO dto, out MovimentoContabile item)
        {
            var message = string.Empty;

            item = null;
            try
            {
                var daoFactory = _windsorConfigRepository.GetContainer(_info.Azienda).Resolve<IDaoFactory>();

                CausaleContabile causale = null;
                if(dto.Causale != null)
                    causale = daoFactory.GetCausaleContabileDao().Find(dto.Causale.ID, false);
                if (causale == null)
                {
                    var idCausale = "<NULL>";
                    if (dto.Causale != null)
                        idCausale = dto.Causale.ID.ToString(CultureInfo.InvariantCulture);

                    _log.WarnFormat("Non è definito la causale per un movimento da inserire - {0}  - causale:{1} - azienda:{2}", Utility.GetMethodDescription(), idCausale, _info.Azienda);
                    return "Non è definita la causale";
                }

                if (dto.NumeroRiga == null)
                    dto.NumeroRiga = 1;

                DettaglioSpesa dettaglio = null;
                var importo = Math.Round(dto.Importo.GetValueOrDefault(), 2);
                var segno = dto.Segno;
                if (importo < 0)
                {
                    segno = invertiSegno(segno);
                    importo = importo*-1;
                }

                var conto = daoFactory.GetContoDao().Find(dto.IdConto.GetValueOrDefault(), false);
                if (conto == null)
                {
                    _log.WarnFormat("Non è definito il conto per un movimento da inserire - {0}  - conto:{1} - azienda:{2}", Utility.GetMethodDescription(), dto.IdConto.GetValueOrDefault(), _info.Azienda);
                    return "Non è definito il conto economico";
                }

                if (dto.IdDettaglio != null)
                {
                    dettaglio = daoFactory.GetDettaglioSpesaDao().GetById(dto.IdDettaglio.GetValueOrDefault(), false);
                    item = new MovimentoContabile(_testata, dettaglio, causale, dto.NumeroRiga, conto, importo, segno);
                }
                else
                    item = new MovimentoContabile(_testata, causale, dto.NumeroRiga, conto, importo, segno);
                item.PercentualeProprieta = dto.PercentualeProprieta;

                setSottoConto(dto, item, daoFactory);

                if (dto.IdFornitore != null)
                    item.FornitoreRiferimento = daoFactory.GetFornitoreDao().GetById(dto.IdFornitore.Value, false);
                item.Descrizione = dto.Descrizione;
                item.NumeroAssegno = dto.NumeroAssegno;
                item.Note = dto.Note;

                item.GruppiAddebito = dto.GruppiAddebito;
                item.LottiAddebito = dto.LottiAddebito;
                item.StabiliAddebito = dto.StabiliAddebito;

                if (dto.IsMovimentoEconomico != null)
                    item.IsMovimentoEconomico = dto.IsMovimentoEconomico.GetValueOrDefault();

                if(dto.IdMovimentoStorno > 0)
                {
                    var movimentoStorno = daoFactory.GetMovimentoContabileDao().Find(dto.IdMovimentoStorno.GetValueOrDefault(), false);
                    if(movimentoStorno != null)
                    {
                        movimentoStorno.LottiAddebito = item.LottiAddebito;
                        movimentoStorno.StabiliAddebito = item.StabiliAddebito;
                        movimentoStorno.GruppiAddebito = item.GruppiAddebito;
                        movimentoStorno.FornitoreRiferimento = item.FornitoreRiferimento;
                        movimentoStorno.ContoRiferimento = item.ContoRiferimento;
                        movimentoStorno.SottoContoRiferimento = item.SottoContoRiferimento;
                        item.MovimentoStorno = movimentoStorno;
                    }
                }

                // TODO: La valorizzazione del NumeroRegistrazione deve essere spostata nel Domain Model
                if (dto.NumeroRegistrazione != null)
                    item.NumeroRegistrazione = dto.NumeroRegistrazione;
                else
                {
                    try
                    {
                        if(dettaglio != null)
                        {
                            var esercizio = daoFactory.GetEsercizioDao().GetById(dettaglio.SpesaRiferimento.EsercizioRiferimento.ID, true);
                            var numeroRegistrazione = esercizio.ProgressivoRegistrazioneContabile;
                            numeroRegistrazione++;
                            item.NumeroRegistrazione = numeroRegistrazione;
                            esercizio.ProgressivoRegistrazioneContabile = numeroRegistrazione;
                        }
                    }
                    catch (Exception ex)
                    {
                        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.Error("Errore inaspettato nel salvataggio (UPDATE) del numero di registrazione - " + Utility.GetMethodDescription(), ex);

                        var persistenceContext = _windsorConfigRepository.GetContainer(_info.Azienda).Resolve<IPersistenceContext>();
                        persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
                        persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);

                        return message;
                    }
                }

                if (dto.IdEvasione != null)
                    item.EvasioneBancaria = daoFactory.GetEvasioneBancariaDao().Find(dto.IdEvasione.GetValueOrDefault(), false);

                // ===========================================================================================
                // BUGID#2159 - COMMENTATO: Con la nuova funzione di riparto aggregato gli oggetti SpeseUnita 
                //              dovono essere usati SOLO per le spese personali o quando sono usate ripartizioni
                //              personalizzate
                // ===========================================================================================
                //if (dto.DettaglioRipartizione != null)
                try
                {
                    if (item.ContoRiferimento == null)
                    {
                        message = "Non è stato definito il conto di addebito";

                        _log.ErrorFormat("Conto a NULL - {0}", Utility.GetMethodDescription());

                        var persistenceContext = _windsorConfigRepository.GetContainer(_info.Azienda).Resolve<IPersistenceContext>();
                        persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
                        persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);

                        return message;
                    }

                    if ((item.ContoRiferimento.IsSpesePersonali || dto.IsRipartoPersonalizzato) && dto.DettaglioRipartizione != null)
                    {
                        var rep = new SpeseUnitaRepository(item, _info, _windsorConfigRepository);
                        foreach (var t in dto.DettaglioRipartizione)
                        {
                            if (t != null)
                            {
                                try
                                {
                                    rep.ManageDomainEntity(t);
                                }
                                catch (Exception ex)
                                {

                                    _log.Error("Errore nell'inserimento della testata del movimento: " + Utility.GetMethodDescription() + " - 1", ex);
                                    throw;
                                }
                            }
                        }
                    }

                }
                catch (Exception ex)
                {
                    _log.ErrorFormat("Errore nel salvataggio del movimento - (ManageDomainEntity) - {0}  - azienda:{1}", ex, Utility.GetMethodDescription(), _info.Azienda);
                    throw;
                }

                item.IsRipartoPersonalizzato = dto.IsRipartoPersonalizzato;

                daoFactory.GetMovimentoContabileDao().SaveOrUpdate(item);
            }
            catch(Exception ex)
            {
                _log.Error("Errore nel salvataggio del movimento: " + Utility.GetMethodDescription(), ex);
                throw;
            }
            return message;
        }
Пример #3
0
        public MovimentoContabile SetMovimentiStornoPagamento(Pagamento pag, decimal importo, DateTime dataRegistrazione)
        {
            try
            {
                var esercizio = _daoFactory.GetEsercizioDao().GetEsercizioCompetenza(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento, dataRegistrazione);
                var message = IsAllowDataRegistrazione(new List<int> { pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
                if (message.Count == 0)
                {
                    var numeroRiga = 0;
                    var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("SS");

                    // ================================================
                    // Testata
                    // ================================================
                    var testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null);
                    _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);

                    // ================================================
                    // Debiti VS Fornitori
                    // ================================================
                    numeroRiga++;

                    var segno = "A";
                    if (importo < 0)
                    {
                        segno = "D";
                        importo = importo * -1;
                    }

                    var movimentoPatrimoniale = new MovimentoContabile(testata, pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento, causale, numeroRiga,
                                                                       _daoFactory.GetContoDao().GetByCodice(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.ID, 
                                                                       pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoFornitori()), importo, segno)
                    {
                        Descrizione = "Storno Fatt. n." + pag.ScadenzaRiferimento.SpesaRiferimento.NumeroDocumento + " del " + pag.ScadenzaRiferimento.SpesaRiferimento.DataDocumento.GetValueOrDefault().ToShortDateString()
                    };
                    _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);

                    // ================================================
                    // Conto Patrimoniale
                    // ================================================
                    numeroRiga++;

                    var movimentoBancario = new MovimentoContabile(testata, causale, numeroRiga, pag.Conto, importo, invertiSegno(segno))
                    {
                        Descrizione = movimentoPatrimoniale.Descrizione,
                        FornitoreRiferimento = pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento,
                        SottoContoRiferimento = pag.SottoConto,
                        ContoCorrenteBancario = pag.ContoCorrenteBancario
                    };

                    pag.MovimentoContabileStorno = movimentoBancario;

                    _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoBancario);

                    return movimentoBancario;
                }

                var ex = new InvalidDataException(string.Format("La data di registrazione {0:d} non è valida", dataRegistrazione));

                _log.ErrorFormat("Data di registrazione non valida - {0} - data:{1} - pagamento:{2} - importo:{3}", ex, Utility.GetMethodDescription(), dataRegistrazione, pag.ID, importo);
                throw ex;

            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato nella funzione - {0} - data:{1} - pagamento:{2} - importo:{3}", ex, Utility.GetMethodDescription(), dataRegistrazione, pag.ID, importo);
                throw;
            }
        }
Пример #4
0
        public TestataMovimentoContabile SetMovimentiInserimentoSpesa(Spesa spesa, TestataMovimentoContabile testata, DateTime dataRegistrazione)
        {
            var message = IsAllowDataRegistrazione(new List<int> {spesa.EsercizioRiferimento.CondominioRiferimento.ID}, spesa.EsercizioRiferimento, dataRegistrazione);

            if (message.Count == 0)
            {
                _daoFactory.GetSpesaDao().SaveOrUpdate(spesa);

                var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("IF");
                if (testata == null)
                    testata = new TestataMovimentoContabile(spesa.EsercizioRiferimento, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null);
                testata.SpesaRiferimento = spesa;
                _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);

                // ------------------------------------------------
                // Conto economico
                // ------------------------------------------------
                var numeroRiga = 0;
                var importoEconomico = 0m;
                foreach (var dettaglio in spesa.Dettagli)
                {
                    if (numeroRiga == 0)
                        testata.Descrizione = dettaglio.GetDescrizione();
                    foreach (var movimento in dettaglio.Movimenti)
                    {
                        movimento.Testata = testata;
                        movimento.IsMovimentoEconomico = true;
                        testata.Movimenti.Add(movimento);
                        numeroRiga++;
                        movimento.NumeroRiga = numeroRiga;

                        if (movimento.Importo < 0)
                            _log.WarnFormat("Presente importo movimento con segno negativo - {0} - movimento:{1}", Utility.GetMethodDescription(), movimento.ID);

                        importoEconomico += Math.Round(movimento.GetImportoPerSpesa(true).GetValueOrDefault(), 2);
                        _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimento);
                    }
                }

                foreach (var movimento in spesa.MovimentiBollette)
                {
                    movimento.Testata = testata;
                    movimento.IsMovimentoEconomico = true;
                    testata.Movimenti.Add(movimento);
                    numeroRiga++;
                    movimento.NumeroRiga = numeroRiga;

                    if (movimento.GetImportoConSegno() < 0)
                    {
                        movimento.Segno = "A";
                        movimento.Importo = movimento.GetImportoConSegno()*-1;
                    }

                    importoEconomico += movimento.Importo.GetValueOrDefault();
                    _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimento);
                }

                // ------------------------------------------------
                // Debiti VS Fornitori
                // ------------------------------------------------
                var importoTotale = spesa.ImportoLordo + spesa.AltreSpeseEsenti.GetValueOrDefault();
                var importoTotaleArrotondato = Math.Round(importoTotale, 2);

                numeroRiga++;
                var segno = "A";
                if (importoTotale < 0)
                {
                    segno = "D";
                    importoTotaleArrotondato = importoTotaleArrotondato*-1;
                }
                var movimentoPatrimoniale = new MovimentoContabile(testata, spesa.FornitoreRiferimento, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(spesa.EsercizioRiferimento.ID, spesa.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoFornitori()), importoTotaleArrotondato, segno)
                {
                    Descrizione = $"Fatt. n. {spesa.NumeroDocumento} del {spesa.DataDocumento.GetValueOrDefault():d}"
                };
                _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);

                // ------------------------------------------------
                // Eventuale arrotondamento
                // ------------------------------------------------
                if (spesa.TipoDocumento == "NOTACC" || spesa.ImportoLordo < 0)
                    importoTotaleArrotondato = importoTotaleArrotondato*-1;
                setMovimentoArrotondamento(importoTotaleArrotondato, importoEconomico, numeroRiga, spesa, testata, causale, null);

                return testata;
            }

            var ex = new InvalidDataException($"La data di registrazione {dataRegistrazione:d} non è valida");
            _log.ErrorFormat("Data di registrazione non valida - {0} - data:{1} - spesa:{2} - dataRegistrazione:{3}", ex, Utility.GetMethodDescription(), dataRegistrazione, spesa.ID, dataRegistrazione);
            throw ex;
        }
Пример #5
0
        public void DeleteSingoloMovimento(MovimentoContabile mov)
        {
            try
            {
                if(mov != null)
                {
                    if (mov.Testata != null)
                    {
                        mov.Testata.Movimenti.Remove(mov);
                        mov.Testata = null;
                    }

                    if (mov.ContoRiferimento != null)
                    {
                        mov.ContoRiferimento.Movimenti.Remove(mov);
                        mov.ContoRiferimento = null;
                    }

                    if (mov.CondominoRiferimento != null)
                    {
                        mov.CondominoRiferimento.Movimenti.Remove(mov);
                        mov.CondominoRiferimento = null;
                    }

                    if (mov.EvasioneBancaria != null)
                    {
                        mov.EvasioneBancaria.MovimentiContabili.Remove(mov);
                        mov.EvasioneBancaria = null;
                    }

                    if (mov.FornitoreRiferimento != null)
                    {
                        mov.FornitoreRiferimento.MovimentiContabili.Remove(mov);
                        mov.FornitoreRiferimento = null;
                    }

                    if (mov.ContoCorrenteBancario != null)
                    {
                        mov.ContoCorrenteBancario.MovimentiContabili.Remove(mov);
                        mov.ContoCorrenteBancario = null;
                    }

                    if (mov.DettaglioRiferimento != null)
                    {
                        mov.DettaglioRiferimento.Movimenti.Remove(mov);
                        mov.DettaglioRiferimento = null;
                    }

                    if(mov.Spesa != null)
                    {
                        mov.Spesa.MovimentiBollette.Remove(mov);
                        mov.Spesa = null;
                    }

                    mov.DettaglioRipartizione.Clear();

                    _daoFactory.GetMovimentoContabileDao().Delete(mov);
                }
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato durante la cancellazione di un singolo movimento - {0} - id:{1}", ex, Utility.GetMethodDescription(), mov.ID);
                throw;
            }
        }
Пример #6
0
        public TestataResult SetBilancioApertura(TestataMovimentoContabileGestioneDTO testataDto)
        {
            try
            {
                if(testataDto.DataRegistrazione == null)
                    throw new InvalidDataException("Non è definita la data di registrazione");

                var message = string.Empty;
                var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("AB");
                var numeroRiga = 0;

                var esercizio = _daoFactory.GetEsercizioDao().GetById(testataDto.CodiceEsercizio, false);
                var saldiCondomini = _daoFactory.GetSaldoSoggettoDao().GetByEsercizioStabileScala(esercizio, null, null);

                // Controllo correttezza importi
                TestataMovimentoContabile testata = null;
                if (testataDto.Movimenti.Sum(mov => mov.ImportoDare.GetValueOrDefault()) != testataDto.Movimenti.Sum(mov => mov.ImportoAvere.GetValueOrDefault()))
                    message = "Il totale Dare:" + testataDto.Movimenti.Sum(mov => mov.ImportoDare.GetValueOrDefault()).ToString("c") + " non corrisponde col totale Avere:" + testataDto.Movimenti.Sum(mov => mov.ImportoAvere.GetValueOrDefault()).ToString("c") + Environment.NewLine;
                else if (testataDto.DataRegistrazione == null)
                    message = "Deve essere definita la data di registrazione" + Environment.NewLine;
                else
                {
                    foreach (var movimentoDto in testataDto.Movimenti)
                    {
                        if (movimentoDto.Stato == "U")
                        {
                            var conto = _daoFactory.GetContoDao().GetById(movimentoDto.IdConto.GetValueOrDefault(), false);
                            if (conto.Codice == _pianoContiService.GetCodiceContoVersamentiCondomini() && saldiCondomini.Count == 0)
                            {
                                message = "Prima di registrare il bilancio di apertura occorre inserire i saldi iniziali dei condomini" + Environment.NewLine;
                                break;
                            }
                        }
                    }
                }

                if(string.IsNullOrEmpty(message))
                {
                    // controllo data registrazione
                    var messageData = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, testataDto.DataRegistrazione.GetValueOrDefault());
                    if (messageData.Count > 0)
                    {
                        _log.WarnFormat("Data di registrazione non valida - {0} - data:{1} - esercizio:{2}", Utility.GetMethodDescription(), testataDto.DataRegistrazione.GetValueOrDefault(), esercizio.ID);
                        return new TestataResult(null, messageData.Aggregate(message, (current, mess) => current + (mess + Environment.NewLine)));
                    }

                    const string hql = "FROM Esercizio ES WHERE ES.CondominioRiferimento = :condominio AND ES.DataApertura >= :data AND ES.DataChiusura <= :data AND ES.Gestione = :gestione";
                    var listaEsercizi = _daoFactory.GetEsercizioDao().GetByQuery(hql, new[] { new QueryParam("condominio", esercizio.CondominioRiferimento), new QueryParam("data", testataDto.DataRegistrazione.Value), new QueryParam("gestione", Conversione.ToHQLParameter(GestioneEsercizioEnum.Ordinario)) });
                    if (listaEsercizi.Count == 1)
                        esercizio = listaEsercizi[0];

                    testata = _daoFactory.GetTestataMovimentoContabileDao().Find(testataDto.ID, false);
                    if (testata == null)
                    {
                        testata = new TestataMovimentoContabile(esercizio, testataDto.DataRegistrazione.Value, TipoTestataMovimentoContabileEnum.Automatica, null) {AperturaBilancio = true};
                        _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
                    }
                    else
                    {
                        testata.EsercizioRiferimento = esercizio;
                        testata.DataRegistrazione = testataDto.DataRegistrazione.Value;
                    }

                    testata.Descrizione = testataDto.Descrizione;
                    foreach (var movimentoDto in testataDto.Movimenti)
                    {
                        if (movimentoDto.Stato == "U")
                        {
                            var conto = _daoFactory.GetContoDao().GetById(movimentoDto.IdConto.GetValueOrDefault(), false);
                            string segno;
                            decimal importo;
                            if (movimentoDto.ImportoAvere > 0)
                            {
                                importo = movimentoDto.ImportoAvere.GetValueOrDefault();
                                segno = "A";
                            }
                            else
                            {
                                importo = movimentoDto.ImportoDare.GetValueOrDefault();
                                segno = "D";
                            }
                            
                            // =========================================================================================
                            // Per il conto versamenti SOLO ESERCIZIO ORDINARIO spalmo l'importo in base ai versamenti dei singoli condomini
                            // Elimino tutti i movimenti presenti
                            // =========================================================================================
                            MovimentoContabile movimento = null;
                            if (conto.Codice == _pianoContiService.GetCodiceContoVersamentiCondomini() && conto.EsercizioRiferimento == null)
                            {
                                // elimino i movimenti
                                var movimentiOld = testata.Movimenti.Where(item => item.ContoRiferimento.Codice == _pianoContiService.GetCodiceContoVersamentiCondomini()).ToList();
                                bool deleteOriginalMovimento = movimentoDto.ID > 0;
                                foreach (var movimentoContabile in movimentiOld)
                                {
                                    if (movimentoContabile.ID == movimentoDto.ID)
                                        deleteOriginalMovimento = false;
                                    DeleteSingoloMovimento(movimentoContabile);
                                }
                                if(deleteOriginalMovimento)
                                    DeleteSingoloMovimento(_daoFactory.GetMovimentoContabileDao().Find(movimentoDto.ID, false));

                                // creo i nuovi movimenti
                                foreach (var saldoSoggetto in saldiCondomini)
                                {
                                    var importoCondomino = saldoSoggetto.Importo;

                                    segno = "D";
                                    if (importoCondomino < 0)
                                    {
                                        segno = "A";
                                        importoCondomino = importoCondomino*-1;
                                    }
                                    numeroRiga++;
                                    movimento = new MovimentoContabile(testata, causale, numeroRiga, conto, importoCondomino, segno) {Descrizione = movimentoDto.Descrizione};
                                    if (string.IsNullOrEmpty(movimento.Descrizione))
                                        movimento.Descrizione = string.Format("Apertura Conto {0}", saldoSoggetto.Soggetto.DisplayName);
                                    movimento.CondominoRiferimento = saldoSoggetto.Soggetto;
                                    _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimento);
                                    testata.Movimenti.Add(movimento);
                                }
                            }
                            else
                            {
                                movimento = _daoFactory.GetMovimentoContabileDao().Find(movimentoDto.ID, false);
                                if (movimento == null)
                                {
                                    numeroRiga++;
                                    movimento = new MovimentoContabile(testata, causale, numeroRiga, conto, importo, segno) {Descrizione = movimentoDto.Descrizione};
                                    if (string.IsNullOrEmpty(movimento.Descrizione))
                                        movimento.Descrizione = "Apertura Conto";
                                    if (movimentoDto.IdFornitore != null && movimentoDto.IdFornitore.GetValueOrDefault() > 0)
                                        movimento.FornitoreRiferimento = _daoFactory.GetFornitoreDao().GetById(movimentoDto.IdFornitore.Value, false);
                                    _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimento);
                                    testata.Movimenti.Add(movimento);
                                }
                                else
                                {
                                    numeroRiga++;
                                    movimento.Segno = segno;
                                    movimento.Importo = importo;
                                    movimento.ContoRiferimento = conto;
                                    movimento.NumeroRiga = numeroRiga;
                                    movimento.Descrizione = movimentoDto.Descrizione;
                                    if (movimentoDto.IdFornitore != null && movimentoDto.IdFornitore.GetValueOrDefault() > 0)
                                        movimento.FornitoreRiferimento = _daoFactory.GetFornitoreDao().GetById(movimentoDto.IdFornitore.Value, false);

                                    testata.Movimenti.Add(movimento);
                                }
                            }

                            if (movimento != null)
                            {
                                movimentoDto.IdMovimentoRiferimento = movimento.ID;

                                if (movimentoDto.IdSpesa > 0)
                                    movimento.Spesa = _daoFactory.GetSpesaDao().GetById(movimentoDto.IdSpesa, false);

                                if (movimentoDto.IdSottoConto != null)
                                {
                                    if (movimentoDto.IdSottoConto > 0)
                                    {
                                        if (movimento.ContoRiferimento.Codice != _pianoContiService.GetCodiceContoFornitori() && movimento.ContoRiferimento.Codice != _pianoContiService.GetCodiceContoRitenuta() && movimento.ContoRiferimento.Codice != _pianoContiService.GetCodiceContoVersamentiCondomini() && movimento.ContoRiferimento.Codice != _pianoContiService.GetCodiceContoRateCondomini())
                                        {
                                            var sottoConto = _daoFactory.GetSottoContoDao().GetById(movimentoDto.IdSottoConto.Value, false);
                                            movimento.SottoContoRiferimento = sottoConto;
                                        }
                                    }
                                    else
                                    {
                                        try
                                        {
                                            if (movimento.ContoRiferimento != null && !string.IsNullOrEmpty(movimento.ContoRiferimento.Codice))
                                            {
                                                if (movimento.ContoRiferimento.Codice == _pianoContiService.GetCodiceContoBancario())
                                                {
                                                    var banca = _daoFactory.GetDatiBancariCondominiDao().Find(movimentoDto.IdSottoConto.Value * -1, false);
                                                    if (banca != null)
                                                        movimento.ContoCorrenteBancario = banca;
                                                }
                                                else if (movimento.ContoRiferimento.Codice == _pianoContiService.GetCodiceContoVersamentiCondomini())
                                                {
                                                    var soggettoCondominio = _daoFactory.GetSoggettoCondominioDao().Find(movimentoDto.IdSottoConto.Value*-1, false);
                                                    if (soggettoCondominio != null)
                                                        movimento.CondominoRiferimento = soggettoCondominio;
                                                }
                                            }
                                        }
                                        catch (Exception ex)
                                        {
                                            _log.ErrorFormat("Errore imprevisto - CONTO CORRENTE - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), esercizio.ID);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }

                return new TestataResult(testata, message);
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato durante l'aggiornamento della quadratura iniziale dei contabili - {0}", ex, Utility.GetMethodDescription());
                throw;
            }
        }
Пример #7
0
        public TestataMovimentoContabile SetMovimentiAddebitoCompetenze(AddebitoCompetenzaDTO addebito)
        {
            try
            {
                // se la testata è automatica non è possibile aggiornare gli importi nel dettaglio, se manuale è possibile l'aggiornamento.
                // per ora la testata viene inserita come manuale.
                TestataMovimentoContabile testata;
                var esercizio = _daoFactory.GetEsercizioDao().Find(addebito.IdEsercizio, false);
                var dataRegistrazione = addebito.DataRegistrazioneMovimentoContabile;

                // controllo data registrazione
                var messageData = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
                if (messageData.Count == 0)
                {
                    testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Manuale, null) {Descrizione = addebito.Descrizione, IsAllowUpdate = true};

                    var causale = _daoFactory.GetCausaleContabileDao().Find(addebito.IdCausale, false) ?? _daoFactory.GetCausaleContabileDao().GetByCodice("IA");
                    var numeroRiga = 0;

                    // Contropartita
                    numeroRiga++;
                    var contoContropartita = _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, "913");
                    new MovimentoContabile(testata, causale, numeroRiga, contoContropartita, addebito.Dettaglio.Sum(item => item.Importo), "A") {Descrizione = addebito.Descrizione};

                    foreach (var item in addebito.Dettaglio)
                    {
                        try
                        {
                            if (item.Importo != 0)
                            {
                                numeroRiga++;

                                var conto = _daoFactory.GetContoDao().Find(item.IdConto, false);
                                if (conto != null)
                                {
                                    SottoConto sottoConto = null;
                                    if (item.IdSottoConto != null)
                                        sottoConto = _daoFactory.GetSottoContoDao().GetById(item.IdSottoConto.Value, false);
                                    var soggetto = _daoFactory.GetSoggettoCondominioDao().Find(item.IdCondomino.GetValueOrDefault(), false);
                                    if (soggetto != null)
                                    {
                                        var movimento = new MovimentoContabile(testata, causale, numeroRiga, conto, item.Importo, "D")
                                        {
                                            SottoContoRiferimento = sottoConto,
                                            Descrizione = item.DescrizioneMovimentoContabile,
                                            CondominoRiferimento = soggetto
                                        };

                                        switch (soggetto.Tipo)
                                        {
                                            case TipoSoggetto.Proprietario:
                                                movimento.PercentualeProprieta = 1;
                                                break;
                                            case TipoSoggetto.Conduttore:
                                                movimento.PercentualeProprieta = 0;
                                                break;
                                        }

                                        movimento.IsRipartoPersonalizzato = true;
                                        new SpeseUnita(item.Importo, null, soggetto, movimento);

                                        var dettaglio = _daoFactory.GetDettaglioAddebitoCompetenzaDao().Find(item.ID, false);
                                        if (dettaglio != null)
                                        {
                                            dettaglio.MovimentoContabile = movimento;
                                            dettaglio.Soggetto = soggetto;
                                        }
                                    }
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            
                            _log.Fatal(
                                "Errore inaspettato nella creazione del movimento di addebito competenze per sollecito - SINGOLO SOGGETTO - " +
                                Utility.GetMethodDescription() + " - id:" + item.ID + " - importo:" +
                                item.Importo + " - soggetto:" + item.IdCondomino + " - conto:" + item.IdConto +
                                " - sottoconto:" + item.IdSottoConto.GetValueOrDefault() + " - addebito:" + addebito.ID +
                                " - IdEsercizio:" + addebito.IdEsercizio, ex);
                            throw;
                        }

                    }

                    var addebitoItem = _daoFactory.GetAddebitoCompetenzaDao().Find(addebito.ID, false);
                    if (addebitoItem != null)
                        addebitoItem.TestataMovimento = testata;

                    _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
                }
                else
                {
                    var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", dataRegistrazione));
                    
                    _log.Fatal("Data di registrazione non valida - " + Utility.GetMethodDescription() + " - data:" + dataRegistrazione + " - addebito:" + addebito.ID + " - IdEsercizio:" + addebito.IdEsercizio, ex);
                    throw ex;
                }

                return testata;
            }
            catch (Exception ex)
            {
                
                _log.Fatal("Errore inaspettato nella creazione del movimento di addebito competenze per sollecito - " + Utility.GetMethodDescription() + " - addebito:" + addebito.ID + " - IdEsercizio:" + addebito.IdEsercizio, ex);
                throw;
            }
        }
Пример #8
0
        public TestataMovimentoContabile SetMovimentiSollecito(Esercizio esercizio, IList<Sollecito> solleciti, DateTime dataRegistrazione, Conto conto, SottoConto sottoconto)
        {
            try
            {
                // controllo data registrazione
                var message = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
                if (message.Count > 0)
                {
                    var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", dataRegistrazione));
                    _log.FatalFormat("Data di registrazione non valida - {0} - data:{1} - conto:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), dataRegistrazione, conto.ID, esercizio.ID);
                    throw ex;
                }

                var testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null)
                {
                    Descrizione = "Addebito solleciti del " + dataRegistrazione.ToShortDateString(),
                    IsAllowUpdate = true
                };

                var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("IA");
                var numeroRiga = 0;

                // Contropartita
                numeroRiga++;
                var contoContropartita = _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, "913");
                new MovimentoContabile(testata, causale, numeroRiga, contoContropartita, solleciti.Sum(item => item.ImportoCompetenza.GetValueOrDefault()), "A");

                foreach (var soll in solleciti)
                {
                    numeroRiga++;
                    var movimento = new MovimentoContabile(testata, causale, numeroRiga, conto, soll.ImportoCompetenza, "D") {SottoContoRiferimento = sottoconto};
                    if (soll.Soggetto != null)
                        movimento.CondominoRiferimento = soll.Soggetto;
                    soll.MovimentoEconomico = movimento;

                    movimento.IsRipartoPersonalizzato = true;

                    var soggetto = soll.Soggetto ?? soll.Persona.SoggettiCondominio.FirstOrDefault(item => item.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.CondominioRiferimento.ID == soll.Esercizio.CondominioRiferimento.ID);
                    if (soggetto != null)
                    {
                        movimento.CondominoRiferimento = soggetto;
                        switch (soggetto.Tipo)
                        {
                            case TipoSoggetto.Proprietario:
                                movimento.PercentualeProprieta = 1;
                                break;
                            case TipoSoggetto.Conduttore:
                                movimento.PercentualeProprieta = 0;
                                break;
                        }
                        new SpeseUnita(soll.ImportoCompetenza, null, soggetto, movimento);
                    }
                }

                _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);

                return testata;
            }
            catch (Exception ex)
            {
                
                _log.Fatal("Errore inaspettato nella creazione del movimento di addebito competenze per sollecito - " + Utility.GetMethodDescription() + " - IdEsercizio:" + esercizio.ID.ToString(), ex);
                throw;
            }
        }
Пример #9
0
        public TestataMovimentoContabile SetMovimentiSingolaRata(RataSoggetto rata, decimal importo, SoggettoCondominio soggetto, Esercizio esercizio, TestataMovimentoContabile testata, DateTime dataRegistrazione)
        {
            return null;
            var numeroRiga = 0;
            var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("ER");

            var message = IsAllowDataRegistrazione(new List<int> {esercizio.CondominioRiferimento.ID}, esercizio, dataRegistrazione);
            if (message.Count > 0)
            {
                _log.ErrorFormat("Tentativo di registrazione con data esterno all'intervallo consentito - {0} - rata:{1} - importo:{2} - soggetto:{3} - esercizio:{4}", Utility.GetMethodDescription(), rata.ID, importo, soggetto.ID, esercizio.ID);
                throw new InvalidDataException(string.Format("Tentativo di registrazione con data esterno all'intervallo consentito - data:{0}", dataRegistrazione.ToShortDateString()));
            }

            // ------------------------------------------------
            // Testata
            // ------------------------------------------------
            if (testata == null)
            {
                testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null);
                _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
            }
            else
                numeroRiga = testata.Movimenti.Max(mov => mov.NumeroRiga.GetValueOrDefault());

            // ------------------------------------------------
            // Rata
            // ------------------------------------------------
            numeroRiga++;
            var movimentoPatrimoniale = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoRateCondomini()), importo, "A") {CondominoRiferimento = soggetto};
            string descrizioneRata;
            if (rata != null)
                descrizioneRata = "Rata n." + rata.PianoRatealeDettaglio.Progressivo;
            else
                descrizioneRata = "Rata";
            movimentoPatrimoniale.Descrizione = descrizioneRata + " - " + movimentoPatrimoniale.CondominoRiferimento.DisplayName;
            _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);

            // ------------------------------------------------
            // Crediti V/S Condomini
            // ------------------------------------------------
            numeroRiga++;
            var movimentoPatrimonialeCrediti = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoVersamentiCondomini()), importo, "D")
            {
                CondominoRiferimento = soggetto,
                Descrizione = movimentoPatrimoniale.Descrizione
            };
            _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimonialeCrediti);

            return testata;
        }
Пример #10
0
        public void SetMovimentiRitenutaPagataAltroAmministratore(Spesa spesa, DateTime dataRegistrazione)
        {
            try
            {
                if (spesa.EsercizioRiferimento == null)
                {
                    _log.ErrorFormat("Errore inaspettato nella creazione del movimento di ritenuta pagata da altro amministratore - TESTATA - {0} - spesa:{1}", Utility.GetMethodDescription(), spesa.ID);
                    throw (new Exception("Non è definito l'esercizio di competenza per la spesa"));
                }

                var numeroRiga = 0;
                var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("VR");

                // ------------------------------------------------
                // Testata
                // ------------------------------------------------
                TestataMovimentoContabile testata;
                try
                {
                    testata = new TestataMovimentoContabile(spesa.EsercizioRiferimento, DateTime.Today, TipoTestataMovimentoContabileEnum.Automatica, null)
                    {
                        DataRegistrazione = dataRegistrazione,
                        SpesaRiferimento = spesa
                    };
                    _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
                }
                catch (Exception ex)
                {
                    var countScadenze = string.Empty;
                    if (spesa.Scadenze != null)
                        countScadenze = spesa.Scadenze.Count.ToString();

                    _log.ErrorFormat("Errore inaspettato nella creazione del movimento di ritenuta pagata da altro amministratore - TESTATA - {0} - spesa:{1} - scadenze:{2}", ex, Utility.GetMethodDescription(), spesa.ID, countScadenze);
                    throw;
                }

                // ------------------------------------------------
                // Ritenuta
                // ------------------------------------------------
                numeroRiga++;

                MovimentoContabile movimentoPatrimoniale;
                var segnoRitenuta = "A";
                try
                {

                    var importoRitenuta = spesa.ImportoRitenuta.GetValueOrDefault();
                    if (spesa.ImportoRitenuta < 0)
                    {
                        segnoRitenuta = "D";
                        importoRitenuta = importoRitenuta*-1;
                    }

                    var contoRitenuta = _daoFactory.GetContoDao().GetByCodice(spesa.EsercizioRiferimento.ID, spesa.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoRitenuta());
                    if (contoRitenuta != null)
                    {
                        try
                        {
                            movimentoPatrimoniale = new MovimentoContabile(testata, causale, numeroRiga, contoRitenuta, importoRitenuta, segnoRitenuta)
                            {
                                FornitoreRiferimento = spesa.FornitoreRiferimento,
                                Descrizione = "Ritenuta Fatt. n." + spesa.NumeroDocumento + " del " + spesa.DataDocumento.GetValueOrDefault().ToShortDateString()
                            };
                            _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);
                        }
                        catch (Exception ex)
                        {
                            _log.ErrorFormat("Errore inaspettato nella creazione del movimento di ritenuta pagata da altro amministratore - RITENUTA INT - {0} - spesa:{1}", ex, Utility.GetMethodDescription(), spesa.ID);
                            throw;
                        }
                    }
                    else
                    {
                        _log.FatalFormat("Errore inaspettato nella creazione del movimento di ritenuta pagata da altro amministratore - RITENUTA - {0} - spesa:{1}", Utility.GetMethodDescription(), spesa.ID);
                        throw (new InvalidDataException("Non trovato il conto per la registrazione delle Ritenute di Acconto"));
                    }

                }
                catch (Exception ex)
                {
                    _log.ErrorFormat("Errore inaspettato nella creazione del movimento di ritenuta pagata da altro amministratore - RITENUTA EXT - {0} - spesa:{1}", ex, Utility.GetMethodDescription(), spesa.ID);
                    throw;
                }

                // ------------------------------------------------
                // Conto Patrimoniale
                // ------------------------------------------------
                numeroRiga++;
                var segno = "D";
                if (segnoRitenuta == "D")
                    segno = "A";

                var contoPatrimonialeAltreSpese = _daoFactory.GetContoDao().GetByCodice(spesa.EsercizioRiferimento.ID, spesa.EsercizioRiferimento.CondominioRiferimento.ID, "909");
                if (contoPatrimonialeAltreSpese != null)
                {
                    try
                    {
                        var movimentoSpeseNonCompetenza = new MovimentoContabile(testata, causale, numeroRiga, contoPatrimonialeAltreSpese, movimentoPatrimoniale.Importo, segno)
                        {
                            FornitoreRiferimento = movimentoPatrimoniale.FornitoreRiferimento,
                            Descrizione = movimentoPatrimoniale.Descrizione
                        };
                        _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoSpeseNonCompetenza);
                    }
                    catch (Exception ex)
                    {
                        _log.ErrorFormat("Errore inaspettato nella creazione del movimento di ritenuta pagata da altro amministratore - PATRIMONIALE - {0} - spesa:{1}", ex, Utility.GetMethodDescription(), spesa.ID);
                        throw;
                    }
                }
                else
                {
                    _log.ErrorFormat("Errore inaspettato nella creazione del movimento di ritenuta pagata da altro amministratore - PATRIMONIALE - {0} - spesa:{1}", Utility.GetMethodDescription(), spesa.ID);
                    throw (new InvalidDataException("Non trovato il conto (909) patrimoniale per la registrazione delle Ritenute di Acconto"));
                }
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato nella creazione del movimento di ritenuta pagata da altro amministratore - {0} - spesa:{1}", ex, Utility.GetMethodDescription(), spesa.ID);
                throw;
            }
        }
Пример #11
0
        public TestataMovimentoContabile SetMovimentiRitenuta(Pagamento pagamento, Ritenuta ritenuta, Conto contoPatrimoniale, int? idSottoConto, DateTime dataRegistrazione, string descrizione, string descrizioneAddebitoInteressi, string descrizioneAddebitoSanzioni, decimal? importo)
        {
            var esercizio = _daoFactory.GetEsercizioDao().GetEsercizioCompetenza(pagamento.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento, dataRegistrazione);
            if (esercizio == null || esercizio.Stato == StatoEsercizioEnum.Chiuso)
            {
                throw new InvalidDataException(string.Format("La data di registrazione {0:d} del versamento della ritenuta per {1:c} non è valida per il condominio:'{2}' perchè non è stato trovato un esercizio aperto di competenza", dataRegistrazione, ritenuta.Importo, pagamento.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.DisplayName));
            }

            var message = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
            if (message.Count == 0)
            {
                var numeroRiga = 0;
                var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("VR");

                var importoRitenuta = ritenuta.Importo.GetValueOrDefault();
                if (importo != null)
                    importoRitenuta = importo.Value;
                importoRitenuta = Math.Round(importoRitenuta, 2);

                // ------------------------------------------------
                // Testata
                // ------------------------------------------------
                var testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null) { SpesaRiferimento = pagamento.ScadenzaRiferimento.SpesaRiferimento };
                _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);

                var contoRitenuta = _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoRitenuta());

                var spesa = pagamento.ScadenzaRiferimento.SpesaRiferimento;
                var firstDettaglio = spesa.Dettagli.FirstOrDefault();
                TestataMovimentoContabile testataFattura = null;
                if (firstDettaglio != null)
                {
                    var firstMovimento = firstDettaglio.Movimenti.FirstOrDefault();
                    if (firstMovimento != null)
                        testataFattura = firstMovimento.Testata;
                }

                // ------------------------------------------------
                // Interessi per Ravvedimento Operoso
                // ------------------------------------------------
                if (ritenuta.ImportoInteressi > 0)
                {
                    if (testataFattura != null && !testataFattura.AperturaBilancio)
                    {
                        foreach (var dettaglio in spesa.Dettagli)
                        {
                            if (dettaglio.Movimenti.Count > 0)
                            {

                                foreach (var movimento in dettaglio.Movimenti)
                                {
                                    var importoMovimento = movimento.GetImportoConSegno().GetValueOrDefault();
                                    if (movimento.ContoRiferimento.Tipo == TipoContoEconomicoEnum.Patrimoniale)
                                        importoMovimento = importoMovimento * -1;

                                    numeroRiga++;
                                    var interesseCompetenza = ritenuta.ImportoInteressi.GetValueOrDefault();
                                    if (spesa.ImportoLordo != 0)
                                        interesseCompetenza = (ritenuta.ImportoInteressi.GetValueOrDefault() * importoMovimento) / spesa.ImportoLordo;
                                    var movimentoInteresse = new MovimentoContabile(testata, causale, numeroRiga, movimento.ContoRiferimento, interesseCompetenza, "D")
                                    {
                                        SottoContoRiferimento = movimento.SottoContoRiferimento,
                                        FornitoreRiferimento = movimento.FornitoreRiferimento
                                    };

                                    if (!string.IsNullOrEmpty(descrizioneAddebitoInteressi))
                                        movimentoInteresse.Descrizione = descrizioneAddebitoInteressi.Replace("<DescrizioneSpesa>", movimento.GetDescrizione());

                                    _ripartizioneService.CloneRipartizioneByMovimento(movimentoInteresse, movimento);

                                    _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoInteresse);
                                }
                            }
                            else
                            {
                                numeroRiga++;
                                var movimentoInteresse = new MovimentoContabile(testata, causale, numeroRiga, contoRitenuta, ritenuta.ImportoInteressi, "D")
                                {
                                    FornitoreRiferimento = spesa.FornitoreRiferimento,
                                    Descrizione = "Interesse versamento ritenuta"
                                };

                                _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoInteresse);
                            }

                        }                        
                    }
                    else
                    {
                        numeroRiga++;
                        var sottoContoInteressiSanzioni = _daoFactory.GetSottoContoDao().GetInteressiSanzioniByEsercizio(testata.EsercizioRiferimento.ID, testata.EsercizioRiferimento.CondominioRiferimento.ID);
                        if (sottoContoInteressiSanzioni != null)
                        {
                            var movimentoInteresse = new MovimentoContabile(testata, causale, numeroRiga, sottoContoInteressiSanzioni.ContoRiferimento, ritenuta.ImportoInteressi, "D")
                            {
                                SottoContoRiferimento = sottoContoInteressiSanzioni,
                                FornitoreRiferimento = spesa.FornitoreRiferimento,
                                Descrizione = "Interesse versamento ritenuta"
                            };

                            _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoInteresse);
                        }
                        else
                        {
                            ritenuta.ImportoInteressi = 0;
                        }
                        
                    }

                }

                // ------------------------------------------------
                // Sanzione per Ravvedimento Operoso
                // ------------------------------------------------
                if (ritenuta.ImportoSanzione > 0)
                {
                    if (testataFattura != null && !testataFattura.AperturaBilancio)
                    {
                        foreach (var dettaglio in spesa.Dettagli)
                        {
                            if (dettaglio.Movimenti.Count > 0)
                            {

                                foreach (var movimento in dettaglio.Movimenti)
                                {
                                    var importoMovimento = movimento.GetImportoConSegno().GetValueOrDefault();
                                    if (movimento.ContoRiferimento.Tipo == TipoContoEconomicoEnum.Patrimoniale)
                                        importoMovimento = importoMovimento*-1;

                                    numeroRiga++;
                                    var sanzioneCompetenza = ritenuta.ImportoSanzione.GetValueOrDefault();
                                    if (spesa.ImportoLordo != 0)
                                        sanzioneCompetenza = (ritenuta.ImportoSanzione.GetValueOrDefault()*
                                                              importoMovimento)/spesa.ImportoLordo;
                                    var movimentoSanzione = new MovimentoContabile(testata, causale, numeroRiga,
                                        movimento.ContoRiferimento, sanzioneCompetenza, "D")
                                    {
                                        SottoContoRiferimento = movimento.SottoContoRiferimento,
                                        FornitoreRiferimento = movimento.FornitoreRiferimento
                                    };

                                    if (!string.IsNullOrEmpty(descrizioneAddebitoSanzioni))
                                        movimentoSanzione.Descrizione = descrizioneAddebitoSanzioni.Replace("<DescrizioneSpesa>", movimento.GetDescrizione());

                                    _ripartizioneService.CloneRipartizioneByMovimento(movimentoSanzione, movimento);

                                    _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoSanzione);
                                }
                            }
                            else
                            {
                                numeroRiga++;
                                var movimentoSanzione = new MovimentoContabile(testata, causale, numeroRiga, contoRitenuta, ritenuta.ImportoSanzione, "D")
                                {
                                    FornitoreRiferimento = spesa.FornitoreRiferimento,
                                    Descrizione = "Sanzione versamento ritenuta"
                                };

                                _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoSanzione);
                            }
                        }
                    }
                    else
                    {
                        numeroRiga++;
                        var sottoContoInteressiSanzioni = _daoFactory.GetSottoContoDao().GetInteressiSanzioniByEsercizio(testata.EsercizioRiferimento.ID, testata.EsercizioRiferimento.CondominioRiferimento.ID);
                        if (sottoContoInteressiSanzioni != null)
                        {
                            var movimentoSanzione = new MovimentoContabile(testata, causale, numeroRiga, sottoContoInteressiSanzioni.ContoRiferimento, ritenuta.ImportoSanzione, "D")
                            {
                                SottoContoRiferimento = sottoContoInteressiSanzioni,
                                FornitoreRiferimento = spesa.FornitoreRiferimento,
                                Descrizione = "Sanzione versamento ritenuta"
                            };

                            _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoSanzione);
                        }
                        else
                        {
                            ritenuta.ImportoSanzione = 0;
                        }
                    }
                }

                // ------------------------------------------------
                // Ritenuta
                // ------------------------------------------------
                numeroRiga++;
                var movimentoPatrimoniale = new MovimentoContabile(testata, causale, numeroRiga, contoRitenuta, importoRitenuta, "D")
                {
                    FornitoreRiferimento = pagamento.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento,
                    Descrizione = "Ritenuta " + pagamento.GetDescrizione()
                };
                if (!string.IsNullOrEmpty(descrizione))
                    movimentoPatrimoniale.Descrizione += " - " + descrizione;
                _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);

                // ------------------------------------------------
                // Conto Patrimoniale
                // ------------------------------------------------
                numeroRiga++;

                var movimentoBancario = new MovimentoContabile(testata, causale, numeroRiga, contoPatrimoniale, importoRitenuta + ritenuta.ImportoInteressi.GetValueOrDefault() + ritenuta.ImportoSanzione.GetValueOrDefault(), "A")
                {
                    FornitoreRiferimento = movimentoPatrimoniale.FornitoreRiferimento,
                    Descrizione = movimentoPatrimoniale.Descrizione
                };
                _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoBancario);

                if (idSottoConto != null)
                {
                    if (idSottoConto > 0)
                        movimentoBancario.SottoContoRiferimento = _daoFactory.GetSottoContoDao().GetById(idSottoConto.Value, false);
                    if (idSottoConto < 0)
                        movimentoBancario.ContoCorrenteBancario = _daoFactory.GetDatiBancariCondominiDao().GetById(idSottoConto.Value*-1, false);
                }

                if (contoPatrimoniale.Codice == _pianoContiService.GetCodiceContoBancario() &&
                    movimentoBancario.ContoCorrenteBancario == null)
                    movimentoBancario.ContoCorrenteBancario = esercizio.CondominioRiferimento.DatiBancariPrincipale;

                testata.Descrizione = movimentoPatrimoniale.Descrizione;
                ritenuta.MovimentoContabilePagamento = movimentoBancario;

                return testata;
            }

            var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", dataRegistrazione));
            
            _log.FatalFormat("Data di registrazione non valida - {0} - data:{1} - pagamento:{2} - conto:{3}", ex, Utility.GetMethodDescription(), dataRegistrazione, pagamento.ID, contoPatrimoniale.ID);
            throw ex;
        }
Пример #12
0
        public void SetMovimentiInteressiSanzioni(Spesa spesa)
        {
            try
            {
                foreach (var pag in spesa.Pagamenti)
                {
                    try
                    {
                        var movimentiDaEliminare = _daoFactory.GetMovimentoContabileDao().GetInteressiSanzioniByPagamento(pag.ID);
                        if (movimentiDaEliminare.Count > 0)
                        {
                            var testata = movimentiDaEliminare[0].Testata;
                            var causale = movimentiDaEliminare[0].Causale;
                            var numeroRiga = testata.Movimenti.Max(item => item.NumeroRiga.GetValueOrDefault()) + 1;

                            // ------------------------------------------------
                            // Interessi per Ravvedimento Operoso
                            // ------------------------------------------------
                            try
                            {
                                if (pag.RitenutaAcconto.ImportoInteressi > 0)
                                {
                                    var descrizioneAddebitoInteressi = string.Empty;
                                    var movimentoInteresseOld = movimentiDaEliminare.FirstOrDefault(item => item.TipoInteresseSanzione == TipoInteresseSanzioneEnum.Interesse);
                                    if (movimentoInteresseOld != null)
                                        descrizioneAddebitoInteressi = movimentoInteresseOld.Descrizione;

                                    foreach (var dettaglio in spesa.Dettagli)
                                    {
                                        foreach (var movimento in dettaglio.Movimenti)
                                        {
                                            var importoMovimento = movimento.GetImportoConSegno().GetValueOrDefault();
                                            if (movimento.ContoRiferimento.Tipo == TipoContoEconomicoEnum.Patrimoniale)
                                                importoMovimento = importoMovimento * -1;

                                            var interesseCompetenza = (pag.RitenutaAcconto.ImportoInteressi.GetValueOrDefault() * importoMovimento) / spesa.ImportoLordo;
                                            var movimentoInteresse = new MovimentoContabile(testata, causale, numeroRiga, movimento.ContoRiferimento, interesseCompetenza, "D")
                                            {
                                                SottoContoRiferimento = movimento.SottoContoRiferimento,
                                                FornitoreRiferimento = movimento.FornitoreRiferimento,
                                                Descrizione = descrizioneAddebitoInteressi.Replace("<DescrizioneSpesa>", movimento.GetDescrizione()),
                                                TipoInteresseSanzione = TipoInteresseSanzioneEnum.Interesse,
                                                PagamentoInteresseSanzione = pag
                                            };
                                            // "Interessi ravv. operoso - " + movimento.GetDescrizione();
                                            _ripartizioneService.CloneRipartizioneByMovimento(movimentoInteresse, movimento);

                                            _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoInteresse);
                                        }
                                    }
                                }
                            }
                            catch (Exception ex)
                            {
                                _log.ErrorFormat("Errore inaspettato durante la scrittura dei movimenti per interessi  e sanzioni (SINGOLO PAGAMENTO - INTERESSI) - {0} - pagamento:{1} - spesa:{2}", ex, Utility.GetMethodDescription(), pag.ID, spesa.ID);
                                throw;
                            }

                            // ------------------------------------------------
                            // Sanzione per Ravvedimento Operoso
                            // ------------------------------------------------
                            try
                            {
                                if (pag.RitenutaAcconto.ImportoSanzione > 0)
                                {
                                    var movimentoSanzioneOld = movimentiDaEliminare.FirstOrDefault(item => item.TipoInteresseSanzione == TipoInteresseSanzioneEnum.Sanzione);
                                    if (movimentoSanzioneOld != null)
                                    {
                                        var descrizioneAddebitoSanzioni = movimentoSanzioneOld.Descrizione;

                                        foreach (var dettaglio in spesa.Dettagli)
                                        {
                                            foreach (var movimento in dettaglio.Movimenti)
                                            {
                                                var importoMovimento = movimento.GetImportoConSegno().GetValueOrDefault();
                                                if (movimento.ContoRiferimento.Tipo == TipoContoEconomicoEnum.Patrimoniale)
                                                    importoMovimento = importoMovimento * -1;

                                                var sanzioneCompetenza = (pag.RitenutaAcconto.ImportoSanzione.GetValueOrDefault() * importoMovimento) / spesa.ImportoLordo;
                                                var movimentoSanzione = new MovimentoContabile(testata, causale, numeroRiga, movimento.ContoRiferimento, sanzioneCompetenza, "D")
                                                                            {
                                                                                SottoContoRiferimento = movimento.SottoContoRiferimento,
                                                                                FornitoreRiferimento = movimento.FornitoreRiferimento,
                                                                                Descrizione = descrizioneAddebitoSanzioni.Replace("<DescrizioneSpesa>", movimento.GetDescrizione()),
                                                                                TipoInteresseSanzione = TipoInteresseSanzioneEnum.Sanzione,
                                                                                PagamentoInteresseSanzione = pag
                                                                            };
                                                //"Sanzione ravv. operoso - " + movimento.GetDescrizione();
                                                _ripartizioneService.CloneRipartizioneByMovimento(movimentoSanzione, movimento);

                                                _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoSanzione);
                                            }
                                        }
                                    }
                                }
                            }
                            catch (Exception ex)
                            {
                                _log.ErrorFormat("Errore inaspettato durante la scrittura dei movimenti per interessi  e sanzioni (SINGOLO PAGAMENTO - SANZIONE) - {0} - pagamento:{1} - spesa:{2}", ex, Utility.GetMethodDescription(), pag.ID, spesa.ID);
                                throw;
                            }

                            // ------------------------------------------------
                            // Cancello i vecchi movimenti
                            // ------------------------------------------------
                            try
                            {
                                foreach (var mov in movimentiDaEliminare)
                                {
                                    try
                                    {
                                        DeleteSingoloMovimento(mov);
                                    }
                                    catch (Exception ex)
                                    {
                                        _log.ErrorFormat("Errore inaspettato durante la scrittura dei movimenti per interessi  e sanzioni (SINGOLO PAGAMENTO - CANCELLAZIONE VECCHI MOVIMENTI - SINGOLO MOVIMENTO) - {0} - pagamento:{1} - spesa:{2} - movimento:{3}", ex, Utility.GetMethodDescription(), pag.ID, spesa.ID, mov.ID);
                                        throw;
                                    }
                                }
                            }
                            catch (Exception ex)
                            {
                                _log.ErrorFormat("Errore inaspettato durante la scrittura dei movimenti per interessi  e sanzioni (SINGOLO PAGAMENTO - CANCELLAZIONE VECCHI MOVIMENTI) - {0} - pagamento:{1} - spesa:{2}", ex, Utility.GetMethodDescription(), pag.ID, spesa.ID);
                                throw;
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        _log.ErrorFormat("Errore inaspettato durante la scrittura dei movimenti per interessi  e sanzioni (SINGOLO PAGAMENTO) - {0} - pagamento:{1} - spesa:{2}", ex, Utility.GetMethodDescription(), pag.ID, spesa.ID);
                        throw;
                    }
                }
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato durante la scrittura dei movimenti per interessi  e sanzioni - {0} - spesa:{1}", ex, Utility.GetMethodDescription(), spesa.ID);
                throw;
            }
        }
Пример #13
0
        public void SetMovimentiRitenuta(PagamentoRitenuta fileRitenuta, string descrizioneAddebitoInteressi, string descrizioneAddebitoSanzioni)
        {
            try
            {
                var numeroRiga = 0;
                var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("VR");
                var lista = new Dictionary<Esercizio, TestataMovimentoContabile>(fileRitenuta.Pagamenti.Count);

                foreach (var pag in fileRitenuta.Pagamenti)
                {
                    try
                    {
                        // ------------------------------------------------
                        // Testata
                        // ------------------------------------------------
                        TestataMovimentoContabile testata;

                        var esercizi = (from es in _daoFactory.GetEsercizioDao().GetByCondominio(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento)
                                        where es.Gestione == GestioneEsercizioEnum.Ordinario && es.DataApertura <= fileRitenuta.Data.GetValueOrDefault() && es.DataChiusura >= fileRitenuta.Data.GetValueOrDefault()
                                        select es).ToList();

                        if (esercizi.Count() > 1)
                        {
                            var eserciziId = esercizi.Aggregate(string.Empty, (current, es) => current + (" id:" + es.ID + " descrizione:" + es.Descrizione + " - "));
                            _log.WarnFormat("Uno o più esercizi ordinari si sovrappongono - {0} - condominio:{1} - esercizi:{2}", Utility.GetMethodDescription(), pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, eserciziId);
                        }
                        var esercizio = esercizi.FirstOrDefault() ?? pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento;

                        if (lista.ContainsKey(esercizio))
                            testata = lista[esercizio];
                        else
                        {
                            var message = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, fileRitenuta.Data.GetValueOrDefault());
                            if (message.Count == 0)
                            {
                                testata = new TestataMovimentoContabile(esercizio, fileRitenuta.Data, TipoTestataMovimentoContabileEnum.Automatica, null);
                                _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
                                lista.Add(esercizio, testata);
                            }
                            else
                            {
                                var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", fileRitenuta.Data));
                                _log.ErrorFormat("Data di registrazione non valida - {0} - data:{1} - pagamento:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), fileRitenuta.Data, pag.ID , esercizio.ID);
                                throw ex;
                            }
                        }

                        var spesa = pag.ScadenzaRiferimento.SpesaRiferimento;
                        var firstDettaglio = spesa.Dettagli.FirstOrDefault();
                        TestataMovimentoContabile testataFattura = null;
                        if (firstDettaglio != null)
                        {
                            var firstMovimento = firstDettaglio.Movimenti.FirstOrDefault();
                            if (firstMovimento != null)
                                testataFattura = firstMovimento.Testata;
                        }
                        
                        // ------------------------------------------------
                        // Interessi per Ravvedimento Operoso
                        // ------------------------------------------------
                        if (pag.RitenutaAcconto.ImportoInteressi > 0)
                        {
                            if (testataFattura != null && !testataFattura.AperturaBilancio)
                            {
                                var importo = spesa.Dettagli.SelectMany(item => item.Movimenti).Sum(item => item.Importo.GetValueOrDefault());
                                foreach (var dettaglio in spesa.Dettagli)
                                {
                                    try
                                    {
                                        foreach (var movimento in dettaglio.Movimenti)
                                        {
                                            try
                                            {
                                                var importoMovimento = movimento.GetImportoConSegno().GetValueOrDefault();
                                                if (movimento.ContoRiferimento.Tipo == TipoContoEconomicoEnum.Patrimoniale)
                                                    importoMovimento = importoMovimento * -1;

                                                var interesseCompetenza = pag.RitenutaAcconto.ImportoInteressi.GetValueOrDefault();
                                                if (spesa.ImportoLordo != 0)
                                                    interesseCompetenza = (pag.RitenutaAcconto.ImportoInteressi.GetValueOrDefault() * importoMovimento) / importo;
                                                else
                                                {
                                                    _log.WarnFormat("Trovata spesa con importo lordo a 0 - {0} - spesa:{1} - data:{2} - movimento:{3} - pagamento:{4} - file ritenuta:{5}", Utility.GetMethodDescription(), spesa.ID, fileRitenuta.Data, movimento.ID, pag.ID, fileRitenuta.ID);
                                                }

                                                var movimentoInteresse = new MovimentoContabile(testata, causale, numeroRiga, movimento.ContoRiferimento, interesseCompetenza, "D")
                                                {
                                                    SottoContoRiferimento = movimento.SottoContoRiferimento,
                                                    FornitoreRiferimento = movimento.FornitoreRiferimento,
                                                    Descrizione = descrizioneAddebitoInteressi.Replace("<DescrizioneSpesa>", movimento.GetDescrizione()),
                                                    TipoInteresseSanzione = TipoInteresseSanzioneEnum.Interesse,
                                                    PagamentoInteresseSanzione = pag
                                                };

                                                // TODO: Da verificare per i problemi riscontrati con interessi e sanzioni
                                                // "Interessi ravv. operoso - " + movimento.GetDescrizione();
                                                _ripartizioneService.CloneRipartizioneByMovimento(movimentoInteresse, movimento);

                                                _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoInteresse);

                                            }
                                            catch (Exception ex)
                                            {
                                                _log.ErrorFormat("Errore inaspettato nella funzione - (SINGOLO MOVIMENTO INTERESSE) - {0} - data:{1} - movimento:{2} - pagamento:{3} - file ritenuta:{4}", ex, Utility.GetMethodDescription(), fileRitenuta.Data, movimento.ID, pag.ID, fileRitenuta.ID);
                                                throw;
                                            }
                                        }

                                    }
                                    catch (Exception ex)
                                    {
                                        _log.ErrorFormat("Errore inaspettato nella funzione - (SINGOLO DETTAGLIO INTERESSE) - {0} - data:{1} - dettaglio:{2} - pagamento:{3} - file ritenuta:{4}", ex, Utility.GetMethodDescription(), fileRitenuta.Data, dettaglio.ID, pag.ID, fileRitenuta.ID);
                                        throw;
                                    }
                                }
                            }
                            else
                            {
                                numeroRiga++;
                                var sottoContoInteressiSanzioni = _daoFactory.GetSottoContoDao().GetInteressiSanzioniByEsercizio(testata.EsercizioRiferimento.ID, testata.EsercizioRiferimento.CondominioRiferimento.ID);
                                if (sottoContoInteressiSanzioni != null)
                                {
                                    var movimentoInteresse = new MovimentoContabile(testata, causale, numeroRiga, sottoContoInteressiSanzioni.ContoRiferimento, pag.RitenutaAcconto.ImportoInteressi.GetValueOrDefault(), "D")
                                    {
                                        SottoContoRiferimento = sottoContoInteressiSanzioni,
                                        FornitoreRiferimento = spesa.FornitoreRiferimento,
                                        Descrizione = "Interesse versamento ritenuta"
                                    };

                                    _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoInteresse);
                                }
                                else
                                {
                                    pag.RitenutaAcconto.ImportoInteressi = null;
                                }
                            }

                        }

                        // ------------------------------------------------
                        // Sanzione per Ravvedimento Operoso
                        // ------------------------------------------------
                        if (pag.RitenutaAcconto.ImportoSanzione > 0)
                        {
                            if (testataFattura != null && !testataFattura.AperturaBilancio)
                            {
                                var importo = spesa.Dettagli.SelectMany(item => item.Movimenti).Sum(item => item.Importo.GetValueOrDefault());
                                foreach (var dettaglio in spesa.Dettagli)
                                {
                                    try
                                    {
                                        foreach (var movimento in dettaglio.Movimenti)
                                        {
                                            try
                                            {
                                                var importoMovimento = movimento.GetImportoConSegno().GetValueOrDefault();
                                                if (movimento.ContoRiferimento.Tipo == TipoContoEconomicoEnum.Patrimoniale)
                                                    importoMovimento = importoMovimento * -1;

                                                var sanzioneCompetenza = pag.RitenutaAcconto.ImportoSanzione.GetValueOrDefault();
                                                if (spesa.ImportoLordo != 0)
                                                    sanzioneCompetenza = (pag.RitenutaAcconto.ImportoSanzione.GetValueOrDefault() * importoMovimento) / importo;
                                                else
                                                {
                                                    _log.WarnFormat("Trovata spesa con importo lordo a 0 - (SANZIONE) - {0} - spesa:{1} - data:{2} - movimento:{3} - pagamento:{4} - file ritenuta:{5}", Utility.GetMethodDescription(), spesa.ID, fileRitenuta.Data, movimento.ID, pag.ID, fileRitenuta.ID);
                                                }

                                                var movimentoSanzione = new MovimentoContabile(testata, causale, numeroRiga, movimento.ContoRiferimento, sanzioneCompetenza, "D")
                                                {
                                                    SottoContoRiferimento = movimento.SottoContoRiferimento,
                                                    FornitoreRiferimento = movimento.FornitoreRiferimento,
                                                    Descrizione = descrizioneAddebitoSanzioni.Replace("<DescrizioneSpesa>", movimento.GetDescrizione()),
                                                    TipoInteresseSanzione = TipoInteresseSanzioneEnum.Sanzione,
                                                    PagamentoInteresseSanzione = pag
                                                };
                                                //"Sanzione ravv. operoso - " + movimento.GetDescrizione();
                                                _ripartizioneService.CloneRipartizioneByMovimento(movimentoSanzione, movimento);

                                                _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoSanzione);

                                            }
                                            catch (Exception ex)
                                            {
                                                _log.ErrorFormat("Errore inaspettato nella funzione - (SINGOLO MOVIMENTO INTERESSE) - {0} - data:{1} - movimento:{2} - pagamento:{3} - file ritenuta:{4}", ex, Utility.GetMethodDescription(), fileRitenuta.Data, movimento.ID, pag.ID, fileRitenuta.ID);
                                                throw;
                                            }
                                        }
                                    }
                                    catch (Exception ex)
                                    {
                                        _log.ErrorFormat("Errore inaspettato nella funzione - (SINGOLO DETTAGLIO RAVVEDIMENTO) - {0} - data:{1} - dettaglio:{2} - pagamento:{3} - file ritenuta:{4}", ex, Utility.GetMethodDescription(), fileRitenuta.Data, dettaglio.ID, pag.ID, fileRitenuta.ID);
                                        throw;
                                    }
                                }
                            }
                            else
                            {
                                numeroRiga++;
                                var sottoContoInteressiSanzioni = _daoFactory.GetSottoContoDao().GetInteressiSanzioniByEsercizio(testata.EsercizioRiferimento.ID, testata.EsercizioRiferimento.CondominioRiferimento.ID);
                                if (sottoContoInteressiSanzioni != null)
                                {
                                    var movimentoSanzione = new MovimentoContabile(testata, causale, numeroRiga, sottoContoInteressiSanzioni.ContoRiferimento, pag.RitenutaAcconto.ImportoSanzione, "D")
                                    {
                                        SottoContoRiferimento = sottoContoInteressiSanzioni,
                                        FornitoreRiferimento = spesa.FornitoreRiferimento,
                                        Descrizione = "Sanzione versamento ritenuta"
                                    };

                                    _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoSanzione);
                                }
                                else
                                {
                                    pag.RitenutaAcconto.ImportoSanzione = 0;
                                }
                            }
                        }

                        // ------------------------------------------------
                        // Ritenuta
                        // ------------------------------------------------
                        numeroRiga++;
                        var movimentoPatrimoniale = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoRitenuta()), pag.RitenutaAcconto.Importo, "D")
                        {
                            FornitoreRiferimento = pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento,
                            Descrizione = "Versamento Ritenuta " + pag.GetDescrizione()
                        };
                        _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);

                        // ------------------------------------------------
                        // BANCA
                        // ------------------------------------------------
                        numeroRiga++;
                        var movimentoBancario = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoBancario()), pag.RitenutaAcconto.ImportoConInteressi + pag.RitenutaAcconto.ImportoSanzione.GetValueOrDefault(), "A")
                        {
                            FornitoreRiferimento = movimentoPatrimoniale.FornitoreRiferimento,
                            Descrizione = movimentoPatrimoniale.Descrizione,
                            ContoCorrenteBancario = esercizio.CondominioRiferimento.DatiBancariPrincipale
                        };
                        _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoBancario);

                        pag.RitenutaAcconto.MovimentoContabilePagamento = movimentoBancario;

                        setMovimentoArrotondamento(testata, causale, null);
                    }
                    catch (Exception ex)
                    {
                        _log.ErrorFormat("Errore inaspettato nella funzione - (SINGOLO PAGAMENTO) - {0} - data:{1} - pagamento:{2} - fileRitenuta:{3}", ex, Utility.GetMethodDescription(), fileRitenuta.Data, pag.ID, fileRitenuta.ID);
                        throw;
                    }

                }
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato nella funzione - {0} - data:{1} - fileRitenuta:{2}", ex, Utility.GetMethodDescription(), fileRitenuta.Data, fileRitenuta.ID);
                throw;
            }
        }
Пример #14
0
        public MovimentoContabile SetMovimentiRiscossione(Riscossione riscossione, int? idConto, int? idSottoConto, DateTime dataRegistrazione)
        {
            try
            {
                var esercizio = getEsercizioCompetenza(riscossione.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento, dataRegistrazione);
                var message = IsAllowDataRegistrazione(new List<int> { riscossione.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
                if (message.Count == 0)
                {
                    var numeroRiga = 0;
                    var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("PF");

                    // ================================================
                    // Testata
                    // ================================================
                    var testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null);
                    _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);

                    // ================================================
                    // Crediti VS Fornitori
                    // ================================================
                    numeroRiga++;

                    const string segnoFornitori = "A";
                    var movimentoFornitore = new MovimentoContabile(testata, riscossione.SpesaRiferimento.FornitoreRiferimento, causale, numeroRiga,
                                                                    _daoFactory.GetContoDao().GetByCodice(riscossione.SpesaRiferimento.EsercizioRiferimento.ID, riscossione.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoFornitori()),
                                                                    Math.Abs(riscossione.Importo.GetValueOrDefault()), segnoFornitori)
                    {
                        Descrizione = "Riscossione Nota Accredito n." + riscossione.SpesaRiferimento.NumeroDocumento + " del " + riscossione.SpesaRiferimento.DataDocumento.GetValueOrDefault().ToShortDateString()
                    };
                    _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoFornitore);

                    // ================================================
                    // Conto Patrimoniale
                    // ================================================
                    numeroRiga++;

                    const string segnoPatrimoniale = "D";
                    var conto = _daoFactory.GetContoDao().GetById(idConto.GetValueOrDefault(), false);
                    SottoConto sottoconto = null;
                    if (idSottoConto > 0)
                        sottoconto = _daoFactory.GetSottoContoDao().GetById(idSottoConto.Value, false);

                    var movimentoPatrimoniale = new MovimentoContabile(testata, riscossione.SpesaRiferimento.FornitoreRiferimento, causale, numeroRiga, conto, Math.Abs(riscossione.Importo.GetValueOrDefault() - riscossione.ImportoRitenuta.GetValueOrDefault()), segnoPatrimoniale)
                    {
                        SottoContoRiferimento = sottoconto,
                        Descrizione = "Riscossione Nota Accredito n." + riscossione.SpesaRiferimento.NumeroDocumento + " del " + riscossione.SpesaRiferimento.DataDocumento.GetValueOrDefault().ToShortDateString()
                    };
                    if (idSottoConto < 0)
                        movimentoPatrimoniale.ContoCorrenteBancario = _daoFactory.GetDatiBancariCondominiDao().GetById(idSottoConto.Value * -1, false);
                    _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);

                    // ================================================
                    // Ritenuta Acconto
                    // ================================================
                    if (Math.Abs(riscossione.ImportoRitenuta.GetValueOrDefault()) > 0)
                    {
                        numeroRiga++;

                        const string segnoRitenuta = "D";
                        var movimentoRitenuta = new MovimentoContabile(testata, riscossione.SpesaRiferimento.FornitoreRiferimento, causale, numeroRiga,
                                                                       _daoFactory.GetContoDao().GetByCodice(riscossione.SpesaRiferimento.EsercizioRiferimento.ID, riscossione.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoRitenuta()), Math.Abs(riscossione.ImportoRitenuta.GetValueOrDefault()), segnoRitenuta)
                        {
                            Descrizione = "Riscossione Nota Accredito n." + riscossione.SpesaRiferimento.NumeroDocumento + " del " + riscossione.SpesaRiferimento.DataDocumento.GetValueOrDefault().ToShortDateString()
                        };
                        _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoRitenuta);
                    }

                    return movimentoPatrimoniale;
                }

                var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", dataRegistrazione));
                
                _log.Fatal("Data di registrazione non valida - " + Utility.GetMethodDescription() + " - data:" + dataRegistrazione + " - riscossione:" + riscossione.ID + " - idConto:" + idConto.GetValueOrDefault() + " - idSottoConto:" + idSottoConto.GetValueOrDefault(), ex);
                throw ex;
 
            }
            catch (Exception ex)
            {
                
                _log.Fatal("Errore inaspettato nella funzione - " + Utility.GetMethodDescription() + " - data:" + dataRegistrazione + " - riscossione:" + riscossione.ID + " - idConto:" + idConto.GetValueOrDefault() + " - idSottoConto:" + idSottoConto.GetValueOrDefault(), ex);
                throw;
            }
        }
Пример #15
0
        public MovimentoContabile SetMovimentiStornoScadenza(DettaglioSpesa dettaglioSpesa, ScadenzaFattura scadenza, decimal importo, Esercizio esercizio, DateTime dataRegistrazione)
        {
            try
            {
                var message = IsAllowDataRegistrazione(new List<int> { scadenza.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
                if (message.Count == 0)
                {
                    var numeroRiga = 0;
                    var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("SS");

                    // ================================================
                    // Testata
                    // ================================================
                    var testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null);
                    _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);

                    // ================================================
                    // Debiti VS Fornitori
                    // ================================================
                    numeroRiga++;

                    var segno = "D";
                    if (importo < 0)
                    {
                        segno = "A";
                        importo = importo * -1;
                    }

                    var movimentoPatrimoniale = new MovimentoContabile(testata, scadenza.SpesaRiferimento.FornitoreRiferimento, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(scadenza.SpesaRiferimento.EsercizioRiferimento.ID, scadenza.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoFornitori()), importo, segno)
                    {
                        Descrizione = "Storno Fatt. n." + scadenza.SpesaRiferimento.NumeroDocumento + " del " + scadenza.SpesaRiferimento.DataDocumento.GetValueOrDefault().ToShortDateString()
                    };
                    _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);

                    // ================================================
                    // Conto Economico
                    // ================================================
                    var importoTotale = 0m;
                    numeroRiga++;

                    if (scadenza.SpesaRiferimento.TipoDocumento != "FATBILAPP")
                    {
                        var movimenti = new List<MovimentoContabile>();

                        // Se è una FATTURA ......
                        if (scadenza.SpesaRiferimento.Dettagli.Count > 0)
                        {
                            importoTotale = scadenza.SpesaRiferimento.Dettagli.Sum(item => item.Movimenti.Sum(item2 => item2.GetImportoConSegno().GetValueOrDefault()));
                            foreach (var dettaglio in scadenza.SpesaRiferimento.Dettagli)
                                movimenti.AddRange(dettaglio.Movimenti);
                        }
                        // .... oppure una BOLLETTA
                        else if (scadenza.SpesaRiferimento.MovimentiBollette.Count > 0)
                        {
                            importoTotale = scadenza.SpesaRiferimento.MovimentiBollette.Sum(item => item.GetImportoConSegno().GetValueOrDefault());
                            movimenti.AddRange(scadenza.SpesaRiferimento.MovimentiBollette);
                        }

                        foreach (var movimento in movimenti)
                        {
                            var movimentoEconomico = new MovimentoContabile(testata, causale, numeroRiga, movimento.ContoRiferimento, (importo * movimento.GetImportoConSegno()) / importoTotale, invertiSegno(movimento.Segno))
                            {
                                SottoContoRiferimento = movimento.SottoContoRiferimento,
                                Descrizione = movimento.GetDescrizione(),
                                IsRipartoPersonalizzato = movimento.IsRipartoPersonalizzato,
                                LottiAddebito = movimento.LottiAddebito,
                                StabiliAddebito = movimento.StabiliAddebito,
                                GruppiAddebito = movimento.GruppiAddebito,
                                FornitoreRiferimento = movimento.FornitoreRiferimento,
                                DettaglioRiferimento = dettaglioSpesa
                            };
                            _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoEconomico);

                            // Se è presente una ripartizione personalizzata o una spesa personale deve salvare anche il riparto.
                            foreach (var itemRiparto in movimento.DettaglioRipartizione)
                            {
                                var importoRiparto = (itemRiparto.Importo.GetValueOrDefault()*movimentoEconomico.Importo.GetValueOrDefault()/movimento.Importo.GetValueOrDefault()) * -1;
                                var spesaUnita = itemRiparto.MovimentoRiferimento.ContoRiferimento.IsSpesePersonali ? new SpeseUnita(importoRiparto, null, itemRiparto.SoggettoCondominio, movimentoEconomico) : new SpeseUnita(importoRiparto, itemRiparto.UnitaRiferimento, null, movimentoEconomico);
                                _daoFactory.GetSpeseUnitaDao().SaveOrUpdate(spesaUnita);
                            }

                            movimento.MovimentoStorno = movimentoEconomico;
                        }
                    }
                    // Se si tratta di fattura da Bilancio di Apertura lo storno avviene esclusivamente dal conto Bancario
                    else
                    {
                        var movimentoEconomico = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoBancario()), importo, invertiSegno(movimentoPatrimoniale.Segno))
                        {
                            ContoCorrenteBancario = esercizio.CondominioRiferimento.DatiBancariPrincipale,
                            Descrizione = movimentoPatrimoniale.Descrizione
                        };
                        _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoEconomico);
                    }

                    return movimentoPatrimoniale;
                }

                var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", dataRegistrazione));
                
                _log.ErrorFormat("Data di registrazione non valida - {0} - data:{1} - scadenza:{2} - importo:{3}", ex, Utility.GetMethodDescription(), dataRegistrazione, scadenza.ID, importo);
                throw ex;
            }
            catch (Exception ex)
            {
                
                _log.Fatal("Errore inaspettato nella funzione - " + Utility.GetMethodDescription() + " - data:" + dataRegistrazione + " - scadenza:" + scadenza.ID + " - importo:" + importo, ex);
                throw;
            }
        }
Пример #16
0
        public TestataMovimentoContabile SetMovimentiContatoreCondominiale(Esercizio esercizio, IList<ImportoMovimento> importiAccredito, IList<ImportiDTO> addebitiContatoriDivisionali, DateTime dataRegistrazione, Conto contoAddebito, SottoConto sottoContoAddebito, string descrizione)
        {
            // controllo data registrazione
            var message = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
            if (message.Count > 0)
            {
                var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", dataRegistrazione));
                _log.FatalFormat("Data di registrazione non valida - {0} - data:{1} - esercizio:{2}", ex, Utility.GetMethodDescription(), dataRegistrazione, esercizio.ID);
                throw ex;
            }

            var testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null)
            {
                Descrizione = descrizione,
                IsAbilitataArchiviazioneOttica = false,
                IsAllowUpdate = true
            };
            _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);

            var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("SC");

            // -------------------------------------------------
            // Calcolo Importo
            // ------------------------------------------------
            var importo = importiAccredito.Sum(item => item.Importo);

            // -------------------------------------------------
            // Segno Movimento
            // ------------------------------------------------
            var segnoContoEconomico = "D";
            if (importo < 0)
            {
                segnoContoEconomico = "A";
                importo = importo * -1;
            }

            // ------------------------------------------------
            // Conto economico da addebitare
            // ------------------------------------------------
            var movimentoContoEconomicoAddebito = new MovimentoContabile(testata, causale, 1, contoAddebito, importo, segnoContoEconomico)
            {
                SottoContoRiferimento = sottoContoAddebito,
                Descrizione = descrizione,
                IsRipartoPersonalizzato = true
            };
            _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoContoEconomicoAddebito);

            // ------------------------------------------------
            // Conto economico da accreditare
            // ------------------------------------------------
            foreach (var item in importiAccredito)
            {
                var movimentoContoEconomicoAccredito = new MovimentoContabile(testata, causale, 2, _daoFactory.GetContoDao().GetById(item.IdConto, false), item.Importo, invertiSegno(segnoContoEconomico)) { Descrizione = descrizione, IsRipartoPersonalizzato = true };
                if(item.IdSottoConto > 0)
                    movimentoContoEconomicoAccredito.SottoContoRiferimento = _daoFactory.GetSottoContoDao().GetById(item.IdSottoConto.GetValueOrDefault(), false);
                _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoContoEconomicoAccredito);

                // Ripartizione tra le unità immobiliari
                var totaleMillesimi = addebitiContatoriDivisionali.Sum(mill => mill.Importo);
                foreach (var importiDTO in addebitiContatoriDivisionali)
                {
                    var unita = _daoFactory.GetUnitaImmobiliareDao().GetById(importiDTO.Id, false);
                    var importoUnita = (movimentoContoEconomicoAccredito.GetImportoConSegno() * importiDTO.Importo) / totaleMillesimi;
                    var spesaUnita = new SpeseUnita(importoUnita, unita, null, movimentoContoEconomicoAccredito);
                    _daoFactory.GetSpeseUnitaDao().SaveOrUpdate(spesaUnita);

                }
            }

            return testata;
        }
Пример #17
0
        public string SetMovimentoAccreditoInteressiMora(Esercizio esercizio, TestataMovimentoContabile testata, Conto conto, string descrizione, decimal importo, DateTime dataRegistrazione)
        {
            try
            {
                var message = string.Empty;

                var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("RI");
                if (testata == null)
                    testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null) {IsAllowUpdate = true};

                // controllo data registrazione
                var messageData = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, testata.DataRegistrazione.GetValueOrDefault());
                if (messageData.Count > 0)
                {
                    var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", testata.DataRegistrazione.GetValueOrDefault()));
                    _log.ErrorFormat("Data di registrazione non valida - {0} - data:{1} - conto:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), testata.DataRegistrazione.GetValueOrDefault(), conto.ID, esercizio.ID);
                    throw ex;
                }

                var movimento = new MovimentoContabile(testata, causale, testata.Movimenti.Count() + 1, conto, importo, "A") {Descrizione = descrizione};
                _ripartizioneService.ReloadRipartizioneByMovimento(movimento);

                return message;
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato nella creazione del movimento di accredito per interessi di mora - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), esercizio.ID);
                throw;
            }
        }
Пример #18
0
        public void SetMovimentiRichiamoRata(RataSoggetto rata, LogTransazione logTransazione)
        {
            // Movimenti Contabili: Non devono essere registrati movimenti contabili all'atto dell'annullamento di una rata bugid#6383
            return;
            var numeroRiga = 0;
            var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("IR");

            // ------------------------------------------------
            // Testata
            // ------------------------------------------------
            var testata = new TestataMovimentoContabile(rata.Esercizio, DateTime.Today, TipoTestataMovimentoContabileEnum.Automatica, logTransazione);

            // controllo data registrazione
            var message = IsAllowDataRegistrazione(new List<int> { rata.Esercizio.CondominioRiferimento.ID }, rata.Esercizio, testata.DataRegistrazione.GetValueOrDefault());
            if (message.Count > 0)
            {
                var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", testata.DataRegistrazione.GetValueOrDefault()));
                _log.ErrorFormat("Data di registrazione non valida - {0} - testata:{1} - data:{2} - rata:{3}", ex, Utility.GetMethodDescription(), testata.ID, testata.DataRegistrazione.GetValueOrDefault(), rata.ID);
                throw ex;
            }

            // ------------------------------------------------
            // Crediti V/S Condomini - a Saldo
            // ------------------------------------------------
            numeroRiga++;
            var movimentoPatrimoniale = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(rata.Esercizio.ID, rata.Esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoVersamentiCondomini()), rata.Importo, "A")
            {
                CondominoRiferimento = rata.Soggetto,
                Descrizione = "Richiamo Rata n. " + rata.PianoRatealeDettaglio.Progressivo + " di " + rata.Soggetto.DisplayName + " - " + rata.MotivoRichiamo
            };

            // ------------------------------------------------
            // Storno rate condominiali
            // ------------------------------------------------
            numeroRiga++;
            var movimentoPatrimonialeAttivo = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(rata.Esercizio.ID, rata.Esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoRateCondomini()), rata.Importo, "D")
            {
                CondominoRiferimento = rata.Soggetto,
                Descrizione = movimentoPatrimoniale.Descrizione
            };
        }
Пример #19
0
        public TestataMovimentoContabile SetMovimentiAddebitoCompetenze(Esercizio esercizio, AddebitoCompetenza addebito, DateTime dataRegistrazione, Conto conto, SottoConto sottoConto, string descrizione)
        {
            try
            {
                // controllo data registrazione
                var message = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
                if (message.Count > 0)
                {
                    var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", dataRegistrazione));
                    _log.ErrorFormat("Data di registrazione non valida - {0} - data:{1} - addebito:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), dataRegistrazione, addebito.ID, esercizio.ID);
                    throw ex;
                }

                // se la testata è automatica non è possibile aggiornare gli importi nel dettaglio, se manuale è possibile l'aggiornamento.
                // per ora la testata viene inserita come manuale.
                //TestataMovimentoContabile testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, Sfera.Enums.TipoTestataMovimentoContabileEnum.Automatica);
                var testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Manuale, null) {Descrizione = descrizione, IsAllowUpdate = true};

                var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("IA");
                var numeroRiga = 0;

                // Contropartita
                numeroRiga++;
                var contoContropartita = _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, "913");
                new MovimentoContabile(testata, causale, numeroRiga, contoContropartita, addebito.Dettaglio.Sum(item => item.Importo), "A") {Descrizione = descrizione};

                foreach (var item in addebito.Dettaglio)
                {
                    try
                    {
                        numeroRiga++;
                        var movimento = new MovimentoContabile(testata, causale, numeroRiga, conto, item.Importo, "D")
                        {
                            SottoContoRiferimento = sottoConto,
                            Descrizione = descrizione,
                            CondominoRiferimento = item.Soggetto
                        };
                        item.MovimentoContabile = movimento;
                    
                        switch (item.Soggetto.Tipo)
                        {
                            case TipoSoggetto.Proprietario:
                                movimento.PercentualeProprieta = 1;
                                break;
                            case TipoSoggetto.Conduttore:
                                movimento.PercentualeProprieta = 0;
                                break;
                        }

                        movimento.IsRipartoPersonalizzato = true;
                        new SpeseUnita(item.Importo, null, item.Soggetto, movimento);

                    }
                    catch (Exception ex)
                    {
                        _log.ErrorFormat("Errore inaspettato nella creazione del movimento di addebito competenze per sollecito - SINGOLO DETTAGLIO - {0} - item:{1}", ex, Utility.GetMethodDescription(), item.ID);
                        throw;
                    }
                }

                addebito.TestataMovimento = testata;
                _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);

                return testata;
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato nella creazione del movimento di addebito competenze per sollecito - {0} - esercizio:{1} - dataRegistrazione:{2} - addebito:{3} - conto:{4} - sottoconto:{5} - descrizione:{6}", ex, Utility.GetMethodDescription(), esercizio != null ? esercizio.ID.ToString() : "<NULL>", dataRegistrazione, addebito != null ? addebito.ID.ToString() : "<NULL>", conto != null ? conto.ID.ToString() : "<NULL>", sottoConto != null ? sottoConto.ID.ToString() : "<NULL>", descrizione);
                throw;
            }
        }
Пример #20
0
        public IList<TestataMovimentoContabile> SetMovimentiVersamentoCondomino(TestataMovimentoContabile testata, MovimentoContabile movimentoPatrimonialeAttivo, Esercizio esercizio, VersamentoSoggetto versamento, DateTime dataRegistrazione, CausaleContabile causale, Conto contoVersamentoCondomini, int? idMovimentoBancario, FileCBI file, LogTransazione logTransazione)
        {
            var testate = new List<TestataMovimentoContabile>();
            if(causale == null)
                causale = _daoFactory.GetCausaleContabileDao().GetByCodice("RR");
            if (contoVersamentoCondomini == null)
                contoVersamentoCondomini = _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoVersamentiCondomini());
            bool evasioneBancaria = false;
            
            // ================================================================================
            //  Registrazione Movimenti Contabili per Versamento Condomino
            // ================================================================================
            var rateVersate = string.Empty;
            foreach (var versamentoRata in versamento.Rate)
            {
                if (!string.IsNullOrEmpty(rateVersate))
                    rateVersate += ", ";
                rateVersate += versamentoRata.Rata.PianoRatealeDettaglio.Progressivo;
            }
            if (!string.IsNullOrEmpty(rateVersate))
                rateVersate = "(" + rateVersate + ")";

            var descrizione = $"Versamento Rata di {versamento.Soggetto.DisplayName} {rateVersate}";
            
            // ------------------------------------------------
            // Testata
            // ------------------------------------------------
            if (testata == null)
            {
                testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, file, logTransazione)
                {
                    Descrizione = descrizione
                };
            }

            testate.Add(testata);
            var message = IsAllowDataRegistrazione(new List<int>(), testata.EsercizioRiferimento, testata.DataRegistrazione.GetValueOrDefault());
            if (message.Count > 0)
            {
                var ex = new InvalidDataException($"La data di registrazione {testata.DataRegistrazione.GetValueOrDefault()} non è valida");
                _log.FatalFormat("Data di registrazione non valida - {0} - data:{1} - versamento:{2} - message:{3}", ex, Utility.GetMethodDescription(), testata.DataRegistrazione.GetValueOrDefault(), versamento.ID, message.Aggregate(string.Empty, (current, str) => current + string.Format("{0}{1}", message, Environment.NewLine)));
                throw ex;
            }

            var numeroRiga = testata.Movimenti.Count;

            // ------------------------------------------------
            // Crediti V/S Condomini - a Saldo
            // ------------------------------------------------
            numeroRiga++;
            var movimentoPatrimoniale = new MovimentoContabile(testata, causale, numeroRiga, contoVersamentoCondomini, versamento.Importo, "A")
            {
                CondominoRiferimento = versamento.Soggetto, 
                Descrizione = descrizione
            };

            // ------------------------------------------------
            // Banca / Cassa
            // ------------------------------------------------
            if (movimentoPatrimonialeAttivo == null)
            {
                evasioneBancaria = true;
                numeroRiga++;
                movimentoPatrimonialeAttivo = new MovimentoContabile(testata, causale, numeroRiga, versamento.ContoPatrimoniale, versamento.Importo, "D")
                {
                    Descrizione = descrizione,
                    SottoContoRiferimento = versamento.SottoContoPatrimoniale,
                    ContoCorrenteBancario = versamento.ContoBancario,
                    NumeroAssegno = versamento.NumeroAssegno
                };
            }
            else
                movimentoPatrimonialeAttivo.Importo = movimentoPatrimonialeAttivo.GetImportoSenzaSegno() + versamento.Importo;

            // ================================================================================
            //  SOLO ESERCIZI ORDINARI
            //  Se la data di registrazione è successiva alla data di chiusura dell'esercizio
            //  registro i movimenti, usando un contro transitorio, che permette di rilevare
            //  il versamento nello stato patrimoniale dell'esercizio.
            // ================================================================================
            if (versamento.TipoVersamentoDopoChiusura.GetValueOrDefault() == TipoVersamentoDopoChiusuraEnum.Giroconto  && esercizio.Gestione == GestioneEsercizioEnum.Ordinario)
            {
                var esercizioPrecedente = esercizio.GetEsercizioPrecedente();
                if (esercizioPrecedente != null)
                {
                    var causaleVersamentiCondominiDopoChiusura = _daoFactory.GetCausaleContabileDao().GetByCodice("VS");
                    var contoVersamentiDopoChiusura = _pianoContiService.GetContoVersamentiSuccessiviAllaChiusura(esercizio);
                    try
                    {
                        if (movimentoPatrimoniale.CondominoRiferimento != null)
                        {
                            var descrizioneStorno = string.Format("Versamento dopo data chiusura - {0} del {1} {2}", movimentoPatrimoniale.CondominoRiferimento.DisplayName, movimentoPatrimoniale.Testata.DataRegistrazione.GetValueOrDefault().ToShortDateString(), rateVersate);

                            // ---------------------------------------------------------------------------------------
                            // Movimenti per storno e riconoscimento versamenti ai condomini
                            // Nuova testata nell'esercizio precedente per registrare lo storno
                            // ---------------------------------------------------------------------------------------
                            var numeroRigaStorno = 0;
                            var testataStorno = new TestataMovimentoContabile(esercizioPrecedente, esercizioPrecedente.DataChiusura, TipoTestataMovimentoContabileEnum.Automatica, file, logTransazione)
                            {
                                Descrizione = descrizioneStorno
                            };
                            testate.Add(testataStorno);

                            numeroRigaStorno++;
                            var movimentoVersamento = new MovimentoContabile(testataStorno, causaleVersamentiCondominiDopoChiusura, numeroRigaStorno, movimentoPatrimoniale.ContoRiferimento, movimentoPatrimoniale.Importo, movimentoPatrimoniale.Segno)
                            {
                                CondominoRiferimento = movimentoPatrimoniale.CondominoRiferimento,
                                Descrizione = descrizioneStorno
                            };

                            numeroRigaStorno++;
                            var movimentoContoTemporaneo = new MovimentoContabile(testataStorno, causaleVersamentiCondominiDopoChiusura, numeroRigaStorno, contoVersamentiDopoChiusura, movimentoPatrimoniale.Importo, invertiSegno(movimentoPatrimoniale.Segno))
                            {
                                CondominoRiferimento = movimentoPatrimoniale.CondominoRiferimento,
                                Descrizione = descrizioneStorno
                            };

                            // ---------------------------------------------------------------------------------------
                            // Nella stessa testata del versamento originale aggiungo il movimento di chiusura del conto temporaneo
                            // ---------------------------------------------------------------------------------------
                            numeroRiga++;
                            var descrizioneChiusuraStorno = string.Format("Chiusura dello storno del versamento dopo data chiusura - {0} del {1} {2}", movimentoPatrimoniale.CondominoRiferimento.DisplayName, movimentoPatrimoniale.Testata.DataRegistrazione.GetValueOrDefault().ToShortDateString(), rateVersate);
                            var movimentoVersamentoChiusura = new MovimentoContabile(testata, causaleVersamentiCondominiDopoChiusura, numeroRiga, movimentoPatrimoniale.ContoRiferimento, movimentoPatrimoniale.Importo, invertiSegno(movimentoPatrimoniale.Segno))
                            {
                                CondominoRiferimento = movimentoPatrimoniale.CondominoRiferimento,
                                Descrizione = descrizioneChiusuraStorno
                            };

                            numeroRiga++;
                            var movimentoContoTemporaneoChiusura = new MovimentoContabile(testata, causaleVersamentiCondominiDopoChiusura, numeroRiga, contoVersamentiDopoChiusura, movimentoPatrimoniale.Importo, movimentoPatrimoniale.Segno)
                            {
                                CondominoRiferimento = movimentoPatrimoniale.CondominoRiferimento,
                                Descrizione = descrizioneChiusuraStorno
                            };
                            versamento.TestataMovimentoDopoChiusura = testataStorno;
                        }
                    }
                    catch (Exception ex)
                    {
                        _log.ErrorFormat("Errore inaspettato durante la registrazione dei movimenti per i versamenti eseguiti dopo la chiusura - SINGOLO MOVIMENTO - {0} - esercizio:{1} - movimento:{2}", ex, Utility.GetMethodDescription(), esercizio.ID, movimentoPatrimoniale.ID);
                        throw;
                    }
                }
                else
                {
                    _log.ErrorFormat("Esercizio precedente a null - {0} - versamento:{1} - esercizio:{2}", Utility.GetMethodDescription(), versamento.ID, esercizio.ID);
                }
            }

            // ================================================================================
            //  SOLO ESERCIZI ORDINARI - bugid#6223
            //  Se la data di registrazione è antecedente alla data di apertura dell'esercizio
            //  registro i movimenti, usando un contro transitorio, che permette di rilevare
            //  il versamento nello stato patrimoniale dell'esercizio.
            // ================================================================================
            if (versamento.TipoVersamentoPrimaApertura.GetValueOrDefault() == TipoVersamentoPrimaAperturaEnum.Giroconto && esercizio.Gestione == GestioneEsercizioEnum.Ordinario)
            {
                var annoSuccessivo = _daoFactory.GetAnnoGestionaleDao().GetAnnoSuccessivo(esercizio.AnnoGestionale.ID);
                if (annoSuccessivo != null)
                {
                    if (annoSuccessivo.EsercizioOrdinario != null)
                    {
                        var causaleVersamentiCondominiPrimaApertura = _daoFactory.GetCausaleContabileDao().GetByCodice("VA");
                        var contoVersamentiPrecedentiAllaApertura = _pianoContiService.GetContoVersamentiPrecedentiAllaApertura(esercizio);
                        try
                        {
                            if (movimentoPatrimoniale.CondominoRiferimento != null)
                            {
                                var descrizioneStorno = string.Format("Versamento prima della data di apertura - {0} del {1} {2}", movimentoPatrimoniale.CondominoRiferimento.DisplayName, movimentoPatrimoniale.Testata.DataRegistrazione.GetValueOrDefault().ToShortDateString(), rateVersate);

                                // ---------------------------------------------------------------------------------------
                                // Movimenti per storno e riconoscimento versamenti ai condomini
                                // Nuova testata nell'esercizio successivo per registrare lo storno
                                // ---------------------------------------------------------------------------------------
                                var numeroRigaStorno = 0;
                                var testataStorno = new TestataMovimentoContabile(annoSuccessivo.EsercizioOrdinario, annoSuccessivo.EsercizioOrdinario.DataApertura, TipoTestataMovimentoContabileEnum.Automatica, file, logTransazione)
                                {
                                    Descrizione = descrizioneStorno
                                };
                                testate.Add(testataStorno);

                                numeroRigaStorno++;
                                var movimentoVersamento = new MovimentoContabile(testataStorno, causaleVersamentiCondominiPrimaApertura, numeroRigaStorno, movimentoPatrimoniale.ContoRiferimento, movimentoPatrimoniale.Importo, movimentoPatrimoniale.Segno)
                                {
                                    CondominoRiferimento = movimentoPatrimoniale.CondominoRiferimento,
                                    Descrizione = descrizioneStorno
                                };

                                numeroRigaStorno++;
                                var movimentoContoTemporaneo = new MovimentoContabile(testataStorno, causaleVersamentiCondominiPrimaApertura, numeroRigaStorno, contoVersamentiPrecedentiAllaApertura, movimentoPatrimoniale.Importo, invertiSegno(movimentoPatrimoniale.Segno))
                                {
                                    CondominoRiferimento = movimentoPatrimoniale.CondominoRiferimento,
                                    Descrizione = descrizioneStorno
                                };

                                // ---------------------------------------------------------------------------------------
                                // Nella stessa testata del versamento originale aggiungo il movimento di chiusura del conto temporaneo
                                // ---------------------------------------------------------------------------------------
                                numeroRiga++;
                                var descrizioneChiusuraStorno = string.Format("Chiusura dello storno del versamento prima della data di apertura - {0} del {1} {2}", movimentoPatrimoniale.CondominoRiferimento.DisplayName, movimentoPatrimoniale.Testata.DataRegistrazione.GetValueOrDefault().ToShortDateString(), rateVersate);
                                var movimentoVersamentoChiusura = new MovimentoContabile(testata, causaleVersamentiCondominiPrimaApertura, numeroRiga, movimentoPatrimoniale.ContoRiferimento, movimentoPatrimoniale.Importo, invertiSegno(movimentoPatrimoniale.Segno))
                                {
                                    CondominoRiferimento = movimentoPatrimoniale.CondominoRiferimento,
                                    Descrizione = descrizioneChiusuraStorno
                                };

                                numeroRiga++;
                                var movimentoContoTemporaneoChiusura = new MovimentoContabile(testata, causaleVersamentiCondominiPrimaApertura, numeroRiga, contoVersamentiPrecedentiAllaApertura, movimentoPatrimoniale.Importo, movimentoPatrimoniale.Segno)
                                {
                                    CondominoRiferimento = movimentoPatrimoniale.CondominoRiferimento,
                                    Descrizione = descrizioneChiusuraStorno
                                };
                                versamento.TestataMovimentoDopoChiusura = testataStorno;
                            }
                        }
                        catch (Exception ex)
                        {
                            _log.ErrorFormat("Errore inaspettato durante la registrazione dei movimenti per i versamenti eseguiti dopo la chiusura - SINGOLO MOVIMENTO - {0} - esercizio:{1} - movimento:{2}", ex, Utility.GetMethodDescription(), esercizio.ID, movimentoPatrimoniale.ID);
                            throw;
                        }                        
    
                    }
                }
                else
                {
                    _log.ErrorFormat("Esercizio successivo a null - {0} - versamento:{1} - esercizio:{2}", Utility.GetMethodDescription(), versamento.ID, esercizio.ID);
                }
            }

            // ================================================================================
            //  Evado il corrispondente Movimento Bancario
            // ================================================================================
            if (evasioneBancaria && idMovimentoBancario != null)
            {
                EvadiMovimento(string.Format("Evasione automatica per contabilizzazione versamento condomino del {0}", dataRegistrazione.ToShortDateString()), new List<MovimentoContabile> { movimentoPatrimonialeAttivo }, new List<int> { idMovimentoBancario.Value }, dataRegistrazione, logTransazione);
                _log.DebugFormat("Evasione automatica per contabilizzazione versamento condomino - {0} - movimento economico:{1} - movimento bancario:{2} - data registrazione:{3}", Utility.GetMethodDescription(), movimentoPatrimoniale.ID, idMovimentoBancario.GetValueOrDefault(), dataRegistrazione);
            }
            versamento.MovimentoContabilePatrimoniale = movimentoPatrimonialeAttivo;

            return testate;
        }
Пример #21
0
        public TestataMovimentoContabile SetMovimentiVersamentiDopoChiusura(Esercizio esercizioStraordinario)
        {
            try
            {
                TestataMovimentoContabile testata = null;
                var contoVersamentiCondomini = _daoFactory.GetContoDao().GetByCodice(esercizioStraordinario.ID, esercizioStraordinario.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoVersamentiCondomini());
                var movimenti = GetMovimentiByContiData(esercizioStraordinario.CondominioRiferimento.ID, esercizioStraordinario.DataChiusura.GetValueOrDefault().AddDays(1), DateTime.MaxValue, new List<int> { contoVersamentiCondomini.ID });

                if (movimenti.Any())
                {
                    testata = new TestataMovimentoContabile(esercizioStraordinario, esercizioStraordinario.DataChiusura, TipoTestataMovimentoContabileEnum.Automatica, null)
                    {
                        AperturaChiusuraConti = true,
                        Descrizione = "Versamento dopo data chiusura"
                    };
                    var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("VC");
                    var contoVersamentiDopoChiusura = _pianoContiService.GetContoVersamentiSuccessiviAllaChiusura(esercizioStraordinario);
                    var numeroRiga = 0;
                    foreach (var movimentoContabile in movimenti)
                    {
                        try
                        {
                            if (movimentoContabile.CondominoRiferimento != null)
                            {
                                var descrizione = string.Format("Versamento dopo data chiusura - {0} del {1}", movimentoContabile.CondominoRiferimento.DisplayName, movimentoContabile.Testata.DataRegistrazione.GetValueOrDefault().ToShortDateString());

                                numeroRiga++;
                                var movimentoVersamento = new MovimentoContabile(testata, causale, numeroRiga, movimentoContabile.ContoRiferimento, movimentoContabile.Importo, movimentoContabile.Segno);
                                movimentoVersamento.CondominoRiferimento = movimentoContabile.CondominoRiferimento;
                                movimentoVersamento.Descrizione = descrizione;

                                numeroRiga++;
                                var movimentoContoTemporaneo = new MovimentoContabile(testata, causale, numeroRiga, contoVersamentiDopoChiusura, movimentoContabile.Importo, invertiSegno(movimentoContabile.Segno));
                                movimentoContoTemporaneo.CondominoRiferimento = movimentoContabile.CondominoRiferimento;
                                movimentoContoTemporaneo.Descrizione = descrizione;

                                // Nella stessa testata del versamento originale aggiungo il movimento di chiusura del conto temporaneo
                                var numeroRigaChiusura = movimentoContabile.Testata.Movimenti.Max(item => item.NumeroRiga) + 1;
                                var movimentoVersamentoChiusura = new MovimentoContabile(movimentoContabile.Testata, causale, numeroRigaChiusura, movimentoContabile.ContoRiferimento, movimentoContabile.Importo, invertiSegno(movimentoContabile.Segno));
                                movimentoVersamentoChiusura.CondominoRiferimento = movimentoContabile.CondominoRiferimento;
                                movimentoVersamentoChiusura.Descrizione = descrizione;

                                numeroRigaChiusura++;
                                var movimentoContoTemporaneoChiusura = new MovimentoContabile(movimentoContabile.Testata, causale, numeroRigaChiusura, contoVersamentiDopoChiusura, movimentoContabile.Importo, movimentoContabile.Segno);
                                movimentoContoTemporaneoChiusura.CondominoRiferimento = movimentoContabile.CondominoRiferimento;
                                movimentoContoTemporaneoChiusura.Descrizione = descrizione;
                            }
                        }
                        catch (Exception ex)
                        {
                            _log.ErrorFormat("Errore inaspettato durante la registrazione dei movimenti per i versamenti eseguiti dopo la chiusura - SINGOLO MOVIMENTO - {0} - esercizio:{1} - movimento:{2}", ex, Utility.GetMethodDescription(), esercizioStraordinario.ID, movimentoContabile.ID);
                            throw;
                        }
                    }
                }

                return testata;
            }
            catch (Exception ex)
            {
                var idEsercizio = string.Empty;
                if (esercizioStraordinario != null)
                    idEsercizio = esercizioStraordinario.ID.ToString();

                _log.FatalFormat("Errore inaspettato durante la registrazione dei movimenti per i versamenti eseguiti dopo la chiusura - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), idEsercizio);
                throw;
            }
        }
Пример #22
0
        public MovimentoContabile SetMovimentoBancarioGenerico(DatiBancariCondomini banca, Esercizio esercizioRiferimento, SottoConto sottoconto, decimal importo, string descrizione, DateTime dataRegistrazione, CausaleContabile causale)
        {
            try
            {
                var message = IsAllowDataRegistrazione(new List<int> { esercizioRiferimento.CondominioRiferimento.ID }, esercizioRiferimento, dataRegistrazione);
                if (message.Count > 0)
                {
                    var ex = new InvalidDataException($"La data di registrazione {dataRegistrazione} non è valida");
                    _log.FatalFormat("Data di registrazione non valida - {0} - data:{1} - esercizio:{2}", ex,  Utility.GetMethodDescription(), dataRegistrazione, esercizioRiferimento.ID);
                    throw ex;
                }

                var testata = new TestataMovimentoContabile(esercizioRiferimento, dataRegistrazione, TipoTestataMovimentoContabileEnum.Manuale, null)
                {
                    Descrizione = descrizione,
                    IsAbilitataArchiviazioneOttica = false,
                    IsAllowUpdate = true
                };
                _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);

                // -------------------------------------------------
                // Segno Movimento
                // ------------------------------------------------
                string segnoContoEconomico = "D";
                if (importo > 0)
                    segnoContoEconomico = "A";
                else
                    importo = importo * -1;

                // ------------------------------------------------
                // Conto economico
                // ------------------------------------------------
                var movimentoContoEconomico = new MovimentoContabile(testata, causale, 1, sottoconto, importo, segnoContoEconomico) {Descrizione = descrizione};
                _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoContoEconomico);
                _ripartizioneService.SalvaRipartizione(movimentoContoEconomico, esercizioRiferimento.CondominioRiferimento.ID);

                // ------------------------------------------------
                // BANCA
                // ------------------------------------------------
                var movimentoBancario = new MovimentoContabile(testata, causale, 2, _daoFactory.GetContoDao().GetByCodice(esercizioRiferimento.ID, esercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoBancario()), importo, invertiSegno(segnoContoEconomico))
                {
                    Descrizione = descrizione, 
                    Stato = StatoMovimentoContabileEnum.Evaso,
                    ContoCorrenteBancario = banca
                };
                _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoBancario);

                return movimentoBancario;
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato nella contabilizzazione di un movimento bancario - {0} - importo:{1} - descrizione:{2} - data registrazione:{3:d}", ex, Utility.GetMethodDescription(), importo, descrizione, dataRegistrazione);
                throw;
            }
        }
Пример #23
0
        public string SetTestataContabileGenerica(TestataMovimentoContabileGenericoDTO dto)
        {
            try
            {
                var message = string.Empty;
                var numeroRiga = 0;

                if (dto.IdEsercizio > 0)
                {
                    if (dto.Movimenti.Sum(mov => mov.ImportoDare.GetValueOrDefault()) !=
                        dto.Movimenti.Sum(mov => mov.ImportoAvere.GetValueOrDefault()))
                        message = "Il totale Dare:" + dto.Movimenti.Sum(mov => mov.ImportoDare.GetValueOrDefault()).ToString("c") + " non corrisponde col totale Avere:" + dto.Movimenti.Sum(mov => mov.ImportoAvere.GetValueOrDefault()).ToString("c") + Environment.NewLine;
                    else if (dto.DataRegistrazione == null)
                        message = "Deve essere definita la data di registrazione" + Environment.NewLine;
                    else
                    {
                        var esercizio = _daoFactory.GetEsercizioDao().Find(dto.IdEsercizio.GetValueOrDefault(), false);

                        if (esercizio != null && esercizio.Stato == StatoEsercizioEnum.Aperto)
                        {
                            // controllo data registrazione
                            var messageData = IsAllowDataRegistrazione(new List<int> {esercizio.CondominioRiferimento.ID}, esercizio, dto.DataRegistrazione.GetValueOrDefault());
                            if (messageData.Count > 0)
                            {
                                _log.WarnFormat("Data di registrazione non valida - {0} - data:{1} - esercizio:{2}", Utility.GetMethodDescription(), dto.DataRegistrazione.GetValueOrDefault(), esercizio.ID);
                                return messageData.Aggregate(message, (current, mess) => current + (mess + Environment.NewLine));
                            }

                            var causale = _daoFactory.GetCausaleContabileDao().GetById(dto.IdCausale, false);

                            var testata = _daoFactory.GetTestataMovimentoContabileDao().Find(dto.ID, false);
                            if (testata == null)
                            {
                                testata = new TestataMovimentoContabile(esercizio, dto.DataRegistrazione.Value, TipoTestataMovimentoContabileEnum.Manuale, null) {IsAllowUpdate = false};
                                _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
                            }
                            else
                            {
                                // ----------------------------------------------------------
                                // Verifico che tutti i movimenti siano aggiornabili
                                // ----------------------------------------------------------
                                message = testata.Movimenti.Select(movimento => IsAllowUpdateMovimento(movimento.ID)).Where(messageMovimento => !string.IsNullOrEmpty(messageMovimento)).Aggregate(message, (current, messageMovimento) => current + string.Format("{0}{1}", messageMovimento, Environment.NewLine));
                                if (!string.IsNullOrEmpty(message))
                                    return message;
                                // ----------------------------------------------------------

                                testata.EsercizioRiferimento = esercizio;
                                testata.DataRegistrazione = dto.DataRegistrazione.Value;
                                testata.Movimenti.Clear();
                            }

                            testata.Descrizione = dto.Descrizione;
                            foreach (var movimentoDto in dto.Movimenti)
                            {
                                numeroRiga++;
                                var conto = _daoFactory.GetContoDao().GetById(movimentoDto.IdConto.GetValueOrDefault(), false);
                                string segno;
                                decimal importo;
                                if (movimentoDto.ImportoAvere > 0)
                                {
                                    importo = movimentoDto.ImportoAvere.GetValueOrDefault();
                                    segno = "A";
                                }
                                else
                                {
                                    importo = movimentoDto.ImportoDare.GetValueOrDefault();
                                    segno = "D";
                                }

                                var movimento = _daoFactory.GetMovimentoContabileDao().Find(movimentoDto.ID, false);
                                if (movimento == null)
                                {
                                    movimento = new MovimentoContabile(testata, causale, numeroRiga, conto, importo, segno) {Descrizione = movimentoDto.Descrizione};
                                    if (movimentoDto.IdFornitore != null && movimentoDto.IdFornitore.GetValueOrDefault() > 0)
                                        movimento.FornitoreRiferimento = _daoFactory.GetFornitoreDao().GetById(movimentoDto.IdFornitore.Value, false);
                                    _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimento);
                                }
                                else
                                {
                                    movimento.Causale = causale;
                                    movimento.Segno = segno;
                                    movimento.Importo = importo;
                                    movimento.ContoRiferimento = conto;
                                    movimento.NumeroRiga = numeroRiga;
                                    movimento.Descrizione = movimentoDto.Descrizione;
                                    if (movimentoDto.IdFornitore != null && movimentoDto.IdFornitore.GetValueOrDefault() > 0)
                                        movimento.FornitoreRiferimento = _daoFactory.GetFornitoreDao().GetById(movimentoDto.IdFornitore.Value, false);
                                }

                                testata.Movimenti.Add(movimento);

                                if (movimentoDto.IdSottoConto != null)
                                {
                                    if (movimentoDto.IdSottoConto > 0)
                                    {
                                        var sottoConto = _daoFactory.GetSottoContoDao().GetById(movimentoDto.IdSottoConto.Value, false);
                                        movimento.SottoContoRiferimento = sottoConto;
                                    }
                                    else if (movimentoDto.IdSottoConto < 0)
                                    {
                                        if (movimento.ContoRiferimento.Codice == _pianoContiService.GetCodiceContoBancario())
                                        {
                                            var banca = _daoFactory.GetDatiBancariCondominiDao().Find(movimentoDto.IdSottoConto.Value*-1, false);
                                            if (banca != null)
                                                movimento.ContoCorrenteBancario = banca;
                                        }
                                        else if (movimento.ContoRiferimento.Codice == _pianoContiService.GetCodiceContoFornitori())
                                        {
                                            var fornitore = _daoFactory.GetFornitoreDao().Find(movimentoDto.IdSottoConto.Value*-1, false);
                                            if (fornitore != null)
                                                movimento.FornitoreRiferimento = fornitore;
                                        }
                                        else if (movimento.ContoRiferimento.Codice == _pianoContiService.GetCodiceContoVersamentiCondomini() || movimento.ContoRiferimento.Codice == _pianoContiService.GetCodiceContoRateCondomini())
                                        {
                                            var soggetto = _daoFactory.GetSoggettoCondominioDao().Find(movimentoDto.IdSottoConto.Value*-1, false);
                                            if (soggetto != null)
                                                movimento.CondominoRiferimento = soggetto;
                                        }
                                    }
                                }
                            }

                            // Aggiorno l'importo dell'eventuale versamento associato
                            foreach (var movimentoContabile in testata.Movimenti)
                            {
                                var versamento = _daoFactory.GetVersamentoSoggettoDao().GetByMovimentoContabile(movimentoContabile);
                                if (versamento != null)
                                    versamento.Importo = movimentoContabile.Importo.GetValueOrDefault();
                            }
                        }
                        else
                        {
                            if (esercizio != null)
                                message += "La registrazione non è possibile perchè l'esercizio è chiuso." + Environment.NewLine;
                            else
                            {
                                message += "L'esercizio non è più presente nel database." + Environment.NewLine;
                                _log.WarnFormat("Tentativo di registrare una testata generica di movimento contabile per un esercizio inesistente - {0} - esercizio:{1} - testata:{2}", Utility.GetMethodDescription(),  dto.IdEsercizio, dto.ID);
                            }
                        }
                    }
                }
                return message;
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato durante l'aggiornamento della testata generica di movimento contabile - {0}", Utility.GetMethodDescription(), ex);
                throw;
            }
        }
Пример #24
0
        public TestataMovimentoContabile SetMovimentoSpesaPersonale(Esercizio esercizio, TestataMovimentoContabile testata, SoggettoCondominio soggetto, Conto conto, string descrizione, decimal importo, DateTime dataRegistrazione)
        {
            var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("IA");
            if (testata == null)
            {
                testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null) {Descrizione = "Calcolo interessi di mora", IsAllowUpdate = true};
            }

            // controllo data registrazione
            var message = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, testata.DataRegistrazione.GetValueOrDefault());
            if (message.Count > 0)
            {
                var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", testata.DataRegistrazione.GetValueOrDefault()));
                _log.FatalFormat("Data di registrazione non valida - {0} - data:{1} - soggetto:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), testata.DataRegistrazione.GetValueOrDefault(), soggetto.ID, esercizio.ID);
                throw ex;
            }

            var movimento = new MovimentoContabile(testata, causale, testata.Movimenti.Count() + 1, conto, importo, "D") {Descrizione = descrizione};
            switch (soggetto.Tipo)
            {
                case TipoSoggetto.Proprietario:
                    movimento.PercentualeProprieta = 1;
                    break;
                case TipoSoggetto.Conduttore:
                    movimento.PercentualeProprieta = 0;
                    break;
            }

            movimento.IsRipartoPersonalizzato = true;
            new SpeseUnita(importo, null, soggetto, movimento);

            _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);

            return testata;
        }
Пример #25
0
        public string GetKeyContoSottoconto(MovimentoContabile movimento)
        {
            var idSottoconto = 0;
            var idConto = movimento.ContoRiferimento.ID;

            // Fornitore
            if (movimento.ContoRiferimento.Codice == _pianoContiService.GetCodiceContoFornitori())
            {
                idSottoconto = movimento.FornitoreRiferimento != null ? movimento.FornitoreRiferimento.ID : movimento.ContoRiferimento.ID;
            }

            // Condomino - Versamenti
            else if (movimento.ContoRiferimento.Codice == _pianoContiService.GetCodiceContoVersamentiCondomini())
            {
                idSottoconto = movimento.CondominoRiferimento != null ? movimento.CondominoRiferimento.ID : movimento.ContoRiferimento.ID;
            }

            // Condomino - Rate
            else if (movimento.ContoRiferimento.Codice == _pianoContiService.GetCodiceContoRateCondomini())
            {
                idSottoconto = movimento.CondominoRiferimento != null ? movimento.CondominoRiferimento.ID : movimento.ContoRiferimento.ID;
            }

            // Banca
            else if (movimento.ContoRiferimento.Codice == _pianoContiService.GetCodiceContoBancario())
            {
                var contoCorrente = movimento.ContoCorrenteBancario;
                if (contoCorrente == null && movimento.Testata.EsercizioRiferimento.CondominioRiferimento.DatiBancariPrincipale != null)
                    contoCorrente = movimento.Testata.EsercizioRiferimento.CondominioRiferimento.DatiBancariPrincipale;

                if (contoCorrente != null)
                    idSottoconto = contoCorrente.ID;
            }

            // Altri
            else if (movimento.SottoContoRiferimento != null)
                idSottoconto = movimento.SottoContoRiferimento.ID;

            // Sottoconto NON definito
            else
                idSottoconto = movimento.ContoRiferimento.ID;

            return idConto + "&" + idSottoconto;
        }
Пример #26
0
        public IList<MovimentoContabile> SetMovimentoBolletta(BollettaDTO bolletta, Spesa spesa, TestataMovimentoContabile testata, LogTransazione logTransazione, bool controlloDataRegistrazione)
        {
            try
            {
                IList<MovimentoContabile> movimentiEconomici = new List<MovimentoContabile>();

                CausaleContabile causale;
                if (spesa.Utenza != null && spesa.Utenza.RipartoLetture)
                    causale = _daoFactory.GetCausaleContabileDao().GetByCodice("IA");
                else
                    causale = _daoFactory.GetCausaleContabileDao().GetByCodice("IF");

                if (testata == null && spesa.TestateMovimenti.Count > 0)
                {
                    testata = spesa.TestateMovimenti.FirstOrDefault();
                    if (testata != null)
                    {
                        testata.EsercizioRiferimento = spesa.EsercizioRiferimento;
                        testata.DataRegistrazione = bolletta.DataRegistrazione;
                    }
                }

                var dataRegistrazione = DateTime.Today;
                if (bolletta.DataRegistrazione != null)
                    dataRegistrazione = bolletta.DataRegistrazione.GetValueOrDefault();

                if (testata == null)
                {
                    testata = new TestataMovimentoContabile(spesa.EsercizioRiferimento, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null) { SpesaRiferimento = spesa };
                    spesa.TestateMovimenti.Add(testata);
                    testata.IsAllowUpdate = false;
                    if(logTransazione == null)
                        _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
                    else
                        testata.LogTransazione = logTransazione;
                }

                // controllo data registrazione
                IList<string> message = new List<string>();
                if(controlloDataRegistrazione)
                    message = IsAllowDataRegistrazione(new List<int> { spesa.EsercizioRiferimento.CondominioRiferimento.ID }, spesa.EsercizioRiferimento, testata.DataRegistrazione.GetValueOrDefault());
                if (message.Count > 0)
                {
                    var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", testata.DataRegistrazione.GetValueOrDefault()));
                    _log.ErrorFormat("Data di registrazione non valida - {0} - data:{1} - spesa:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), testata.DataRegistrazione.GetValueOrDefault(), spesa.ID, spesa.EsercizioRiferimento.ID);
                    throw ex;
                }

                testata.Descrizione = bolletta.Descrizione;
                testata.DataRegistrazione = dataRegistrazione;

                // -------------------------------------------
                // Elimino movimenti cancellati
                // -------------------------------------------
                foreach (var mov in testata.Movimenti.Where(item => item.NumeroRiga > 1).ToList())
                    DeleteSingoloMovimento(mov);

                // -------------------------------------------
                // Movimenti Economici
                // -------------------------------------------
                var numeroRiga = 1;
                var importoEconomico = 0m;
                foreach (var movimentoDto in bolletta.Movimenti)
                {
                    if (movimentoDto.IdConto != null)
                    {
                        var importo = Math.Round(movimentoDto.Importo.GetValueOrDefault(), 2);
                        importoEconomico += importo;

                        var segno = "D";
                        if (importo < 0)
                        {
                            segno = "A";
                            importo = importo * -1;
                        }

                        var movimento = _daoFactory.GetMovimentoContabileDao().Find(movimentoDto.ID, false);
                        numeroRiga++;
                        if (movimento != null)
                        {
                            movimento.ContoRiferimento = _daoFactory.GetContoDao().GetById(movimentoDto.IdConto.Value, false);
                            movimento.Segno = segno;
                            movimento.Importo = importo;
                            movimento.Causale = causale;
                        }
                        else
                        {
                            movimento = new MovimentoContabile(testata, spesa, causale, testata.Movimenti.Count + 1, _daoFactory.GetContoDao().GetById(movimentoDto.IdConto.Value, false), importo, segno);
                            if(logTransazione == null)
                                _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimento);
                        }

                        movimento.IsMovimentoEconomico = true;
                        movimento.NumeroRiga = numeroRiga;
                        movimento.Descrizione = movimentoDto.Descrizione;
                        if (movimentoDto.IdSottoConto != null && movimentoDto.IdSottoConto > 0)
                            movimento.SottoContoRiferimento = _daoFactory.GetSottoContoDao().GetById(movimentoDto.IdSottoConto.Value, false);

                        movimentoDto.ID = movimento.ID;
                        movimentiEconomici.Add(movimento);
                    }
                    else
                    {
                        _log.ErrorFormat("Movimento senza conto associato - {0} - bolletta:{1}", Utility.GetMethodDescription(), bolletta.ID);
                        throw (new Exception("Movimento senza conto associato - " + Utility.GetMethodDescription() + " - idBolletta:" + bolletta.ID));
                    }
                }

                // ------------------------------------------------
                // Debiti VS Fornitori
                // ------------------------------------------------
                var causalePatrimoniale = _daoFactory.GetCausaleContabileDao().GetByCodice("IF");
                var importoTotale = spesa.ImportoBolletta.GetValueOrDefault();
                var importoPatrimoniale = importoTotale;

                var segnoPatrimoniale = "A";
                if (importoTotale < 0)
                {
                    segnoPatrimoniale = "D";
                    importoTotale = importoTotale * -1;
                }

                var movimentoPatrimoniale = (testata.Movimenti.Where(item => !item.IsMovimentoEconomico && !item.ContoRiferimento.IsArrotondamento)).FirstOrDefault();
                if (movimentoPatrimoniale == null)
                {
                    movimentoPatrimoniale = new MovimentoContabile(testata, spesa.FornitoreRiferimento, causalePatrimoniale, 1, _daoFactory.GetContoDao().GetByCodice(spesa.EsercizioRiferimento.ID, spesa.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoFornitori()), importoTotale, segnoPatrimoniale);
                    if(logTransazione == null)
                        _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);
                }
                else
                {
                    movimentoPatrimoniale.NumeroRiga = 1;
                    movimentoPatrimoniale.Importo = importoTotale;
                    movimentoPatrimoniale.Segno = segnoPatrimoniale;
                }

                movimentoPatrimoniale.Descrizione = $"Fatt. n. {spesa.NumeroDocumento} del {spesa.DataDocumento.GetValueOrDefault():d}";

                // ------------------------------------------------
                // Eventuale arrotondamento
                // ------------------------------------------------
                setMovimentoArrotondamento(importoPatrimoniale, importoEconomico, numeroRiga, spesa, testata, causale, logTransazione);

                return movimentiEconomici;
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato nella creazione del movimento di registrazione delle bollette - {0} - bolletta:{1}", ex, Utility.GetMethodDescription(), bolletta.ID);
                throw;
            }
        }
Пример #27
0
        public void SetMovimentiPagamenti(Disposizione disposizione, string tipoConto, LogTransazione logTransazione)
        {
            try
            {
                var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("PF");
                var lista = new Dictionary<Esercizio, TestataMovimentoContabile>(disposizione.Pagamenti.Count);

                foreach (var pag in disposizione.Pagamenti)
                {
                    try
                    {
                        var numeroRiga = 0;
                        var esercizioRiferimento = getEsercizioCompetenza(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento, pag.Data.GetValueOrDefault());
                        if (esercizioRiferimento == null)
                        {
                            var ex = new InvalidDataException(string.Format("Non trovato nessun esercizio attivo"));
                            _log.FatalFormat("Non trovato nessun esercizio attivo - {0} - condominio:{1} - disposizione:{2} - tipoConto:{3}", ex, Utility.GetMethodDescription(), pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, disposizione.ID, tipoConto);
                            throw ex;
                        }

                        var message = IsAllowDataRegistrazione(new List<int> { esercizioRiferimento.CondominioRiferimento.ID }, esercizioRiferimento, pag.Data.GetValueOrDefault());
                        if (message.Count == 0)
                        {
                            // ================================================
                            // Testata
                            // ================================================
                            TestataMovimentoContabile testata;
                            if (lista.ContainsKey(esercizioRiferimento))
                                testata = lista[esercizioRiferimento];
                            else
                            {
                                testata = new TestataMovimentoContabile(esercizioRiferimento, pag.Data, TipoTestataMovimentoContabileEnum.Automatica, logTransazione);
                                if(logTransazione == null)
                                    _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);

                                // Per ora ritengo opportuno avere una testata di movimento contabile distinta per ogni pagamento.
                                // Per avere un testata che accorpi diversi pagamenti è sufficiente scommentare la riga successiva.
                                //lista.Add(esercizioRiferimento, testata);
                            }

                            // ================================================
                            // Debiti VS Fornitori
                            // ------------------------------------------------
                            //  Se è già presente un movimento contabile legato alla ritenute
                            //  vuol dire che il pagamento stato annullato.
                            //  In questo caso il movimento di ritenuta non deve essere generato
                            // ================================================
                            numeroRiga++;
                            var importoFornitori = pag.Importo.GetValueOrDefault();
                            if (pag.RitenutaAcconto != null && pag.RitenutaAcconto.MovimentoContabileCreazione == null)
                                importoFornitori += pag.RitenutaAcconto.Importo.GetValueOrDefault();
                            var movimentoPatrimoniale = new MovimentoContabile(testata, pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.ID, pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoFornitori()), importoFornitori, "D")
                            {
                                Descrizione = string.Format("Pagamento Fatt. n.{0} del {1:d}", pag.ScadenzaRiferimento.SpesaRiferimento.NumeroDocumento, pag.ScadenzaRiferimento.SpesaRiferimento.DataDocumento.GetValueOrDefault())
                            };
                            if(logTransazione == null)
                                _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);

                            // ================================================
                            // Ritenuta
                            // ================================================
                            decimal importoRitenuta = 0;
                            if (pag.ScadenzaRiferimento.SpesaRiferimento.Detrazione.GetValueOrDefault() == 0 && pag.RitenutaAcconto != null && pag.RitenutaAcconto.MovimentoContabileCreazione == null && pag.RitenutaAcconto.Importo != null && pag.RitenutaAcconto.Importo.GetValueOrDefault() != 0)
                            {
                                numeroRiga++;
                                var segnoRitenuta = "A";
                                importoRitenuta = pag.RitenutaAcconto.Importo.GetValueOrDefault();
                                if (pag.RitenutaAcconto.Importo.GetValueOrDefault() < 0)
                                {
                                    segnoRitenuta = "D";
                                    importoRitenuta = importoRitenuta * -1;
                                }
                                var movimentoRitenuta = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.ID, pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoRitenuta()), importoRitenuta, segnoRitenuta)
                                {
                                    FornitoreRiferimento = movimentoPatrimoniale.FornitoreRiferimento
                                };
                                if (!string.IsNullOrEmpty(pag.ScadenzaRiferimento.SpesaRiferimento.NumeroDocumento) && pag.ScadenzaRiferimento.SpesaRiferimento.DataDocumento != null)
                                    movimentoRitenuta.Descrizione = "Ritenuta Fatt. n." + pag.ScadenzaRiferimento.SpesaRiferimento.NumeroDocumento + " del " + pag.ScadenzaRiferimento.SpesaRiferimento.DataDocumento.Value.ToShortDateString();

                                pag.RitenutaAcconto.MovimentoContabileCreazione = movimentoRitenuta;
                                if(logTransazione == null)
                                    _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoRitenuta);
                            }

                            // ================================================
                            // Conto Patrimoniale
                            // ================================================
                            numeroRiga++;
                            if (pag.Conto == null)
                            {
                                switch (tipoConto)
                                {
                                    case "B":
                                        pag.Conto = _daoFactory.GetContoDao().GetByCodice(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.ID, pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoBancario());
                                        break;
                                    case "C":
                                        pag.Conto = _daoFactory.GetContoDao().GetByCodice(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.ID, pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, "903");
                                        break;
                                }
                            }

                            var segnoPagamento = "A";
                            var importoPagamento = importoFornitori - importoRitenuta;
                            if (importoPagamento < 0)
                            {
                                segnoPagamento = "D";
                                importoPagamento = importoPagamento * -1;

                                // Inverto segno e importo anche per il movimento di Debiti v/Fornitori
                                movimentoPatrimoniale.Segno = invertiSegno("D");
                                movimentoPatrimoniale.Importo = importoFornitori * -1;
                            }

                            var movimentoBancario = new MovimentoContabile(testata, causale, numeroRiga, pag.Conto, importoPagamento, segnoPagamento)
                            {
                                Descrizione = movimentoPatrimoniale.GetDescrizione(),
                                NumeroAssegno = pag.NumeroAssegno,
                                FornitoreRiferimento =
                                    pag.ScadenzaRiferimento.SpesaRiferimento.
                                    FornitoreRiferimento,
                                SottoContoRiferimento = pag.SottoConto,
                                ContoCorrenteBancario = pag.ContoCorrenteBancario
                            };
                            pag.MovimentoContabile = movimentoBancario;
                            if (logTransazione == null)
                                _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoBancario);
                        }
                        else
                        {
                            var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", pag.Data.GetValueOrDefault()));
                            _log.FatalFormat("Data di registrazione non valida - {0} - data:{1} - pagamento:{2} - disposizione:{3} - tipoConto:{4} - esercizio:{5}", ex, Utility.GetMethodDescription(), pag.Data.GetValueOrDefault(), pag.ID, disposizione.ID, tipoConto, esercizioRiferimento.ID);
                            throw ex;
                        }
                    }
                    catch (Exception ex)
                    {
                        _log.FatalFormat("Errore inaspettato durante la scrittura dei movimenti per pagamenti - (SINGOLO PAGAMENTO) - {0} - pagamento:{1} - disposizione:{2}", ex, Utility.GetMethodDescription(), pag.ID, disposizione.ID);
                        throw;
                    }

                }
            }
            catch (Exception ex)
            {
                _log.FatalFormat("Errore inaspettato durante la scrittura dei movimenti per pagamenti - {0} - disposizione:{1}", ex, Utility.GetMethodDescription(), disposizione.ID);
                throw;
            }
        }
Пример #28
0
        private void setMovimentoArrotondamento(decimal importoAvere, decimal importoDare, int numeroRiga, Spesa spesa, TestataMovimentoContabile testata, CausaleContabile causale, LogTransazione logTransazione)
        {
            if (importoAvere != importoDare)
            {
                var importoArrotondamento = importoAvere - importoDare;
                numeroRiga++;
                var segno = "D";
                if (importoArrotondamento < 0)
                {
                    segno = "A";
                    importoArrotondamento = importoArrotondamento * -1;
                }
                var contoArrotondamenti = _pianoContiService.GetContoArrotondamenti(testata.EsercizioRiferimento);
                _daoFactory.GetContoDao().SaveOrUpdate(contoArrotondamenti);

                var movimentoArrotondamento = new MovimentoContabile(testata, causale, numeroRiga, contoArrotondamenti, importoArrotondamento, segno)
                {
                    Descrizione = spesa != null ? string.Format("Arrotondamento Fatt. n. {0} del {1:d}", spesa.NumeroDocumento, spesa.DataDocumento.GetValueOrDefault()) : string.Format("Arrotondamento per {0}", testata.GetDescrizione())
                };

                if(logTransazione == null)
                    _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoArrotondamento);
            }
        }
Пример #29
0
 private string getDescrizioneMovimento(MovimentoContabile movimento, Esercizio esercizio, bool detrazione)
 {
     if (movimento.SottoContoRiferimento != null)
         return movimento.SottoContoRiferimento.GetDescrizione(esercizio, null, movimento);
     if (!string.IsNullOrEmpty(movimento.GetDescrizione(detrazione)))
         return movimento.GetDescrizione();
     return string.Empty;
 }
Пример #30
0
        public TestataMovimentoContabile SetMovimentiRiscaldamentoAcqua(Esercizio esercizio, int idContoAcquaRiscaldata, int idContoRiscaldamento, string descrizioneMovimentoAcqua, string descrizioneMovimentoRiscaldamento, IList<ImportiDTO> importiRiscaldamento, DateTime dataRegistrazione, bool checkDataRegistrazione)
        {
            // controllo data registrazione
            if (checkDataRegistrazione)
            {
            var message = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
                if (message.Count > 0)
                {
                    var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", dataRegistrazione));
                	_log.Fatal("Data di registrazione non valida - " + Utility.GetMethodDescription() + " - data:" + dataRegistrazione + " - IdEsercizio:" + esercizio.ID, ex);
                    throw ex;
                }
            }

            var testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null)
            {
                Descrizione = descrizioneMovimentoAcqua,
                IsAbilitataArchiviazioneOttica = false,
                IsAllowUpdate = true
            };
            _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);

            var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("SC");

            // -------------------------------------------------
            // Calcolo Importo
            // ------------------------------------------------
            var importo = importiRiscaldamento.Sum(item => item.Importo);

            // -------------------------------------------------
            // Segno Movimento
            // ------------------------------------------------
            var segnoContoEconomico = "D";
            if (importo < 0)
            {
                segnoContoEconomico = "A";
                importo = importo * -1;
            }

            // ------------------------------------------------
            // Conto economico da addebitare
            // ------------------------------------------------
            var contoEconomico = _daoFactory.GetContoDao().GetById(idContoAcquaRiscaldata, false);
            var movimentoContoEconomicoAddebito = new MovimentoContabile(testata, causale, 1, contoEconomico, importo, segnoContoEconomico)
            {
                Descrizione = descrizioneMovimentoAcqua,
                IsRipartoPersonalizzato = true,
                RipartoTramiteLetture = true
            };
            _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoContoEconomicoAddebito);
            _ripartizioneService.SalvaRipartizione(movimentoContoEconomicoAddebito, importiRiscaldamento, false);

            // ------------------------------------------------
            // Conto economico da accreditare
            // ------------------------------------------------
            var movimentoContoEconomicoAccredito = new MovimentoContabile(testata, causale, 2, _daoFactory.GetContoDao().GetById(idContoRiscaldamento, false), importo, invertiSegno(segnoContoEconomico)) {Descrizione = descrizioneMovimentoRiscaldamento};
            _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoContoEconomicoAccredito);

            return testata;
        }