Пример #1
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;
            }
        }
        public string RiscossioneNoteAccredito(IList<RiscossioneNotaAccreditoDTO> riscossioni, DateTime dataRegistrazione)
        {
            var message = string.Empty;

            try
            {
                foreach (var riscossione in riscossioni)
                {
                    var nota = _daoFactory.GetSpesaDao().Find(riscossione.IdNotaAccredito, false);
                    if (nota != null)
                    {
                        var risc = new Riscossione(nota, Math.Abs(riscossione.Importo))
                        {
                            ImportoRitenuta = Common.ContabilitaHelper.GetImportoRitenuta(nota, Math.Abs(riscossione.Importo))
                        };

                        risc.MovimentoContabile = _movimentiContabilitaService.SetMovimentiRiscossione(risc, riscossione.IdConto, riscossione.IdSottoConto, dataRegistrazione);

                        nota.SetStato();
                    }
                }
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore nell'aggiornamento dei pagamenti - {0} - dataRegistrazione:{1:d}", ex, Utility.GetMethodDescription(), dataRegistrazione);
                throw;
            }

            return message;
        }
        public string StornoNoteAccredito(int idNota, IList<StornoScadenzaDTO> scadenze, DettaglioSpesa dettaglioSpesa, Esercizio esercizio, DateTime dataRegistrazione)
        {
            try
            {
                var message = string.Empty;
                var nota = _daoFactory.GetSpesaDao().GetById(idNota, false);

                Disposizione disposizione = null;
                if (nota.Riscossioni.Count > 0)
                {
                    var riscossione = IesiGenericCollections<Riscossione>.GetByIndex(nota.Riscossioni, 0);
                    if (riscossione.Pagamenti.Count > 0)
                        disposizione = IesiGenericCollections<Pagamento>.GetByIndex(riscossione.Pagamenti, 0).DisposizioneRiferimento;
                }

                if (disposizione == null)
                {
                    disposizione = new Disposizione($"Storno da nota accredito n.{nota.NumeroDocumento} del:{nota.DataDocumento.GetValueOrDefault():d}", dataRegistrazione, nota.EsercizioRiferimento.CondominioRiferimento.Azienda, null);
                    _daoFactory.GetDisposizioneDao().SaveOrUpdate(disposizione);
                }

                //==============================================================
                // Controlli
                //==============================================================
                IList<ScadenzaFattura> scadenzeFattura = new List<ScadenzaFattura>();
                foreach (var scadenzaImporto in scadenze)
                {
                    var scadenza = _daoFactory.GetScadenzaFatturaDao().GetById(scadenzaImporto.Id, false);
                    scadenzeFattura.Add(scadenza);
                    if (scadenza.Stato != StatoSpesaEnum.Pagata && scadenza.Stato != StatoSpesaEnum.ParzialmentePagata && scadenzaImporto.Importo > scadenza.Importo.GetValueOrDefault() - scadenza.ImportoPagato)
                        message += $"L'importo {scadenzaImporto.Importo:c} è superiore al residuo da pagare: {(scadenza.Importo.GetValueOrDefault() - scadenza.ImportoPagato):c}{Environment.NewLine}";
                }

                //==============================================================
                // Verifico se devo impostare automaticamente la detrazione
                //==============================================================
                try
                {
                    if (scadenzeFattura.All(item => item.SpesaRiferimento.Detrazione.GetValueOrDefault() == 36))
                        nota.Detrazione = 36;
                    else if (scadenzeFattura.All(item => item.SpesaRiferimento.Detrazione.GetValueOrDefault() == 55))
                        nota.Detrazione = 55;
                }
                catch (Exception ex)
                {
                    _log.ErrorFormat("Errore nella impostazione automatica della detrazione per una nota di accredito - {0} - idNota:{1}", ex, Utility.GetMethodDescription(), idNota);
                }

                //==============================================================
                // Cancellazione riscossioni esistenti
                //==============================================================
                IList<Riscossione> riscossioni = nota.Riscossioni.ToList();
                nota.Riscossioni.Clear();
                nota.TestateMovimenti.Clear();
                var movimentiToDelete = new List<int>();
                foreach (var riscossione in riscossioni)
                {
                    riscossione.ScadenzaRiferimento = null;
                    riscossione.SpesaRiferimento = null;

                    // Memorizzazione dei movimenti da cancellare, la cancellazione NON viene eseguita ora
                    // per evitare problemi nella successione degli script eseguiti sul database da NHibernate
                    if (riscossione.MovimentoContabile != null)
                        movimentiToDelete.Add(riscossione.MovimentoContabile.ID);

                    riscossione.MovimentoContabile = null;
                    riscossione.Pagamenti.Clear();
                    _daoFactory.GetRiscossioneDao().Delete(riscossione);
                }

                IList<Pagamento> pagamenti = disposizione.Pagamenti.ToList();
                disposizione.Pagamenti.Clear();
                foreach (var pagamento in pagamenti)
                {
                    pagamento.DisposizioneRiferimento = null;

                    if (pagamento.ScadenzaRiferimento != null)
                        pagamento.ScadenzaRiferimento.Pagamenti.Remove(pagamento);
                    pagamento.ScadenzaRiferimento = null;

                    if (pagamento.NotaStorno != null)
                        pagamento.NotaStorno.Pagamenti.Remove(pagamento);
                    pagamento.NotaStorno = null;

                    pagamento.File = null;
                    pagamento.MovimentoContabile = null;
                    pagamento.MovimentoContabileStorno = null;

                    _daoFactory.GetPagamentoDao().Delete(pagamento);
                }

                //==============================================================
                // Esecuzione
                //==============================================================
                if (string.IsNullOrEmpty(message))
                {
                    foreach (var scadenzaImporto in scadenze)
                    {
                        var scadenza = _daoFactory.GetScadenzaFatturaDao().GetById(scadenzaImporto.Id, false);

                        var pagamento = new Pagamento(scadenza, disposizione, scadenzaImporto.Importo, dataRegistrazione, TipoPagamentoFatturaEnum.Storno)
                        {
                            RitenutaAcconto = new Ritenuta(scadenzaImporto.ImportoRitenuta) { Stato = StatoRitenutaEnum.Stornata },
                            Stato = StatoSpesaEnum.Pagata
                        };
                        _daoFactory.GetPagamentoDao().SaveOrUpdate(pagamento);

                        var riscossione = new Riscossione(nota, scadenzaImporto.Importo);
                        _daoFactory.GetRiscossioneDao().SaveOrUpdate(riscossione);
                        riscossione.ImportoRitenuta = (scadenza.ImportoRitenuta * scadenzaImporto.Importo) / scadenza.Importo;
                        riscossione.DataRitenuta = dataRegistrazione;
                        riscossione.Pagamenti.Add(pagamento);
                        riscossione.ScadenzaRiferimento = scadenza;

                        pagamento.NotaStorno = riscossione;
                        riscossione.MovimentoContabile = _movimentiContabilitaService.SetMovimentiStornoScadenza(dettaglioSpesa, scadenza, scadenzaImporto.Importo + scadenzaImporto.ImportoRitenuta, esercizio, dataRegistrazione);
                        riscossione.MovimentoContabile.Testata.SpesaRiferimento = nota;
                        nota.TestateMovimenti.Add(riscossione.MovimentoContabile.Testata);
                        scadenza.SetStato();

                        if (scadenza.Stato == StatoSpesaEnum.Pagata)
                            scadenza.Stato = StatoSpesaEnum.Stornata;
                    }

                    // Cancellazione dei movimenti precedentemente individuati, la cancellazione viene eseguita solo ora
                    // per evitare problemi nella successione degli script eseguiti sul database da NHibernate
                    foreach (var idMovimentoContabile in movimentiToDelete)
                        _movimentiContabilitaService.DeleteMovimento(idMovimentoContabile);
                }

                return message;
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore nello storno di una fattura - {0} - idNota:{1}", ex, Utility.GetMethodDescription(), idNota);
                throw;
            }
        }
Пример #4
0
        public virtual IUpdatableBusinessEntity Copy()
        {
            var item = new Riscossione(SpesaRiferimento, 0);

            return item;
        }
Пример #5
0
        private PagamentoSpesaDTO setRiscossioneSpesaDto(Riscossione item)
        {
            try
            {
                var dto = new PagamentoSpesaDTO
                {
                    ID = item.ID,
                    Importo = item.Importo,
                    Version = item.Version
                };

                if (item.ScadenzaRiferimento != null)
                    dto.IdScadenzaFattura = item.ScadenzaRiferimento.ID;

                if (item.MovimentoContabile != null)
                {
                    dto.Data = item.MovimentoContabile.Testata.DataRegistrazione;
                    if (item.MovimentoContabile.ContoRiferimento != null)
                        dto.Conto = item.MovimentoContabile.ContoRiferimento.Descrizione;
                    else
                        _log.WarnFormat("Trovato movimento senza conto - {0} - idMovimento:{1} - idRiscossione:{2}", Library.Utility.GetMethodDescription(), item.MovimentoContabile.ID, item.ID);

                    if (item.MovimentoContabile.SottoContoRiferimento != null)
                        dto.SottoConto = item.MovimentoContabile.SottoContoRiferimento.GetDescrizione(item.MovimentoContabile.Testata.EsercizioRiferimento, null, item.MovimentoContabile);
                    else if (item.MovimentoContabile.ContoCorrenteBancario != null)
                        dto.SottoConto = item.MovimentoContabile.ContoCorrenteBancario.DisplayName;
                }

                return dto;
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore nella creazione dell'istanza DTO - {0} - id:{1}", ex, Library.Utility.GetMethodDescription(), item.ID);
                throw;
            }
        }
Пример #6
0
        private PagamentoDTO setDto(Riscossione item)
        {
            try
            {
                if (item != null)
                {
                    var dto = new PagamentoDTO
                    {
                        ID = item.ID * -1,
                        Importo = item.Importo,
                        CodiceConfermaBonifico = null,
                        Version = item.Version
                    };

                    if (item.MovimentoContabile != null)
                    {
                        dto.Data = item.MovimentoContabile.Testata.DataRegistrazione;
                        dto.CodiceMovimentoPagamentoFattura = item.MovimentoContabile.ID;
                        dto.CodiceTestataMovimentoPagamentoFattura = item.MovimentoContabile.Testata.ID;
                        dto.Conto = item.MovimentoContabile.ContoRiferimento.Descrizione;
                        if (item.MovimentoContabile.SottoContoRiferimento != null)
                            dto.SottoConto = item.MovimentoContabile.SottoContoRiferimento.GetDescrizione(item.MovimentoContabile.Testata.EsercizioRiferimento, null, item.MovimentoContabile);
                    }

                    Spesa spesa = null;
                    if (item.SpesaRiferimento != null)
                        spesa = item.SpesaRiferimento;
                    else if (item.ScadenzaRiferimento != null)
                        spesa = item.ScadenzaRiferimento.SpesaRiferimento;

                    if(spesa != null)
                    {
                        dto.IdFattura = spesa.ID;
                        dto.IdentificativoArchiviazione = getArchiviazioneOtticaService().GetIdentificativoArchiviazione(spesa);
                        dto.StatoSpesa = spesa.Stato;
                        dto.DescrizioneCondominio = spesa.EsercizioRiferimento.CondominioRiferimento.DisplayName;
                        dto.DescrizioneFornitore = spesa.FornitoreRiferimento.DisplayName;
                        dto.NumeroDocumento = spesa.NumeroDocumento;
                        dto.DataDocumento = spesa.DataDocumento;
                        dto.TipoDocumentoSpesa = Library.Decodifica.Instance.GetElement("TipoDocumentoContabile", spesa.TipoDocumento).Descrizione;
                        dto.CodiceEsercizioSpesa = spesa.EsercizioRiferimento.ID;
                        dto.StatoPagamento = spesa.Stato;
                        dto.Tipo = TipoPagamentoFatturaEnum.Accredito;

                        var detrazione = string.Empty;
                        if (item.MovimentoContabile != null)
                        {
                            if (item.ScadenzaRiferimento != null && item.ScadenzaRiferimento.SpesaRiferimento != null)
                            {
                                if (item.ScadenzaRiferimento.SpesaRiferimento.Detrazione.GetValueOrDefault() == 36)
                                    detrazione = dto.Data <= new DateTime(2012, 6, 25)
                                                     ? "36 - Ristr.Edilizia"
                                                     : "50% - Ristr.Edilizia";
                                else if (item.ScadenzaRiferimento.SpesaRiferimento.Detrazione.GetValueOrDefault() == 55)
                                    detrazione = "55% - Riqual.Energetica";
                            }
                            else if (item.SpesaRiferimento != null)
                            {
                                if (item.SpesaRiferimento.Detrazione.GetValueOrDefault() == 36)
                                    detrazione = dto.Data <= new DateTime(2012, 6, 25)
                                                     ? "36 - Ristr.Edilizia"
                                                     : "50% - Ristr.Edilizia";
                                else if (item.SpesaRiferimento.Detrazione.GetValueOrDefault() == 55)
                                    detrazione = "55% - Riqual.Energetica";
                            }

                        }
                        dto.Detrazione = detrazione;
                    }

                    if (item.ScadenzaRiferimento != null)
                    {
                        dto.IdScadenzaFattura = item.ScadenzaRiferimento.ID;
                        dto.Tipo = TipoPagamentoFatturaEnum.Storno;
                    }

                    return dto;
                }
                return null;
            }
            catch (Exception ex)
            {
                
                var idStr = string.Empty;
                if (item != null)
                    idStr = item.ID.ToString(CultureInfo.InvariantCulture);
                _log.ErrorFormat("Errore nella creazione dell'istanza DTO - {0} - id:{1}", ex, Library.Utility.GetMethodDescription(), idStr);
                throw;
            }
        }