Exemplo n.º 1
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;
        }
Exemplo n.º 2
0
 public RitenutaAccontoDTO GetByDomainEntity(Ritenuta item)
 {
     try
     {
         return setDto(item);
     }
     catch (Exception ex)
     {
         _log.ErrorFormat("Errore nel caricamento della ritenuta di acconto - {0} - id:{1}", ex, Library.Utility.GetMethodDescription(), item.PagamentoRiferimento.ID);
         throw;
     }
 }
Exemplo n.º 3
0
        public SpesaInfoDTO SalvaFiscale(SpesaFiscaleDTO dto)
        {
            try
            {
                var message = string.Empty;

                var fornitore = _daoFactory.GetFornitoreDao().GetById(dto.IdFornitore, false);
                var esercizio = _daoFactory.GetEsercizioDao().Find(dto.IdEsercizio, false);
                if (esercizio == null)
                    throw new InvalidDataException("L'esercizio selezionato non è più presente in archivio.");

                GestioneCondomini.Domain.Spesa spesa;

                if (dto.ID == 0)
                {
                    spesa = new GestioneCondomini.Domain.Spesa(fornitore, esercizio, null);
                    var protocollo = _protocolloService.GetProgressivo(TipoProtocollo.Fattura, esercizio.DataApertura.GetValueOrDefault().Year, esercizio.CondominioRiferimento);
                    if (protocollo.Progressivo != null)
                    {
                        spesa.NumeroProtocollo = protocollo.Progressivo;
                        _daoFactory.GetSpesaDao().SaveOrUpdate(spesa);
                    }
                    else
                        message = protocollo.Message + Environment.NewLine;
                }
                else
                {
                    spesa = _daoFactory.GetSpesaDao().GetById(dto.ID, false);
                    spesa.FornitoreRiferimento = fornitore;
                    spesa.EsercizioRiferimento = esercizio;
                }

                var info = new SpesaInfoDTO();
                if (string.IsNullOrEmpty(message))
                {
                    spesa.ImportoRitenuta = dto.Scadenze.Sum(item => item.ImportoRitenuta);
                    spesa.AltreSpese = dto.AltreSpese;
                    spesa.AltreSpeseEsenti = dto.SpeseEsenti;
                    spesa.SpeseEsentiRitenuta = dto.SpeseEsentiRitenuta;
                    spesa.CassaProfessionisti = dto.CassaProfessionisti;
                    spesa.DataDocumento = dto.DataDocumento;
                    spesa.NumeroDocumento = dto.NumeroDocumento;
                    spesa.AliquotaRitenuta = dto.AliquotaRitenuta;
                    spesa.IsAbilitataArchiviazioneOttica = dto.IsAbilitataArchiviazioneOttica;
                    spesa.IsRitenutaCalcoloImponibile = dto.IsRitenutaCalcoloImponibile;
                    spesa.Stato = StatoSpesaEnum.Pagata;
                    spesa.TipoDocumento = dto.TipoDocumento;
                    spesa.Detrazione = dto.Detrazione;
                    spesa.EsenteRegimeMinimo = dto.EsenteRegimeMinimo;

                    // ----------------------------------------------------
                    // Dettagli
                    // ----------------------------------------------------
                    spesa.Dettagli.Clear();
                    var index = 0;
                    foreach (var dtoDettaglio in dto.Dettagli)
                    {
                        index++;
                        DettaglioSpesa dettaglio;
                        if (dtoDettaglio.ID == 0)
                            dettaglio = new DettaglioSpesa(spesa, index);
                        else
                        {
                            dettaglio = _daoFactory.GetDettaglioSpesaDao().GetById(dtoDettaglio.ID, false);
                            dettaglio.NumeroRiga = index;
                            spesa.Dettagli.Add(dettaglio);
                        }

                        dettaglio.AliquotaIva = dtoDettaglio.AliquotaIva;
                        dettaglio.Descrizione = dtoDettaglio.Descrizione;
                        dettaglio.ImportoIva = dtoDettaglio.ImportoIva;
                        dettaglio.ImportoLordo = dtoDettaglio.ImportoLordo;
                        dettaglio.SoggettoRitenutaAcconto = dtoDettaglio.SoggettoRitenutaAcconto;
                    }

                    // ----------------------------------------------------
                    // Scadenze / Pagamenti
                    // ----------------------------------------------------
                    // Pulizia movimenti, scadenze e pagamenti presenti
                    foreach (var scadenza in spesa.Scadenze)
                    {
                        foreach (var pagamento in scadenza.Pagamenti)
                            _daoFactory.GetPagamentoDao().Delete(pagamento);
                        _daoFactory.GetScadenzaFatturaDao().Delete(scadenza);
                    }
                    spesa.Scadenze.Clear();

                    foreach (var scadenzaDto in dto.Scadenze)
                    {
                        var scadenzaNew = new ScadenzaFattura(spesa, scadenzaDto.DataPagamento, scadenzaDto.Importo) { Stato = StatoSpesaEnum.Pagata };
                        var pagamentoNew = new Pagamento(scadenzaNew, null, scadenzaNew.Importo, scadenzaNew.Scadenza, TipoPagamentoFatturaEnum.Immediato) { Stato = StatoSpesaEnum.Pagata };
                        scadenzaNew.Pagamenti.Add(pagamentoNew);
                        _daoFactory.GetScadenzaFatturaDao().SaveOrUpdate(scadenzaNew);

                        // -----------------------------------------------------
                        // Ritenuta
                        // -----------------------------------------------------
                        // ritenuta PAGATA dal vecchio amministratore i dati, compresi interessi e sanzioni servono per il modello 770
                        var ritenuta = new Ritenuta(scadenzaDto.ImportoRitenuta);

                        if (!scadenzaDto.RitenutaNONPagata)
                        {
                            ritenuta.Stato = StatoRitenutaEnum.PagataAltroAmministratore;
                            ritenuta.DataPagamentoRitenuta = scadenzaDto.DataPagamentoRitenuta;
                            ritenuta.ImportoInteressi = scadenzaDto.ImportoInteressi;
                            ritenuta.ImportoSanzione = scadenzaDto.ImportoSanzioni;
                        }
                        // ritenuta NON Pagata inserita come da pagare
                        else
                        {
                            ritenuta.Stato = StatoRitenutaEnum.Inserita;
                            ritenuta.DataPagamentoRitenuta = null;
                            _daoFactory.GetSpesaDao().SaveOrUpdate(spesa);
                            _movimentoContabileService.SetMovimentiRitenutaPagataAltroAmministratore(spesa, scadenzaDto.DataPagamento.GetValueOrDefault());
                        }
                        pagamentoNew.RitenutaAcconto = ritenuta;                        
                    }

                    info = new SpesaInfoDTO
                    {
                        Id = spesa.ID,
                        NumeroProtocollo = spesa.NumeroProtocollo.GetValueOrDefault(),
                    };
                    if (spesa.IsAbilitataArchiviazioneOttica)
                    {
                        var impostazioni = _daoFactory.GetImpostazioniAziendaDao().GetByAzienda(spesa.EsercizioRiferimento.CondominioRiferimento.Azienda.ID);
                        info.IdentificativoArchiviazione = _archiviazioneService.GetIdentificativoArchiviazione(spesa);
                        info.StampaEtichettaArchiviazione = impostazioni.UtilizzoEtichettatriceArchiviazioneOtticaFatture && spesa.EsercizioRiferimento.CondominioRiferimento.IsAbilitataArchiviazioneOtticaPassivi.GetValueOrDefault();
                        info.EtichettatriceArchiviazione = impostazioni.EtichettatriceArchiviazioneOttica;
                        info.TipoEtichettaArchiviazione = impostazioni.TipoEtichettaArchiviazioneOttica;
                    }

                    spesa.Stato = StatoSpesaEnum.PagataAltroAmministratore;
                }
                else
                    info.Message = message;

                return info;
            }
            catch (Exception ex)
            {
                
                _log.Fatal("Errore inaspettato nel salvataggio della spesa FISCALE - " + Utility.GetMethodDescription() + " - spesa:" + dto.ID, ex);
                throw;
            }        
        }
Exemplo n.º 4
0
        private RitenutaAccontoDTO setDto(Ritenuta item)
        {
            try
            {
                if (item != null)
                {
                    var dto = new RitenutaAccontoDTO
                    {
                        IdPagamento = item.PagamentoRiferimento.ID,
                        CodiceTributo = item.PagamentoRiferimento.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento.CodiceTributo,
                        Fornitore = item.PagamentoRiferimento.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento.DisplayName,
                        Condominio = item.PagamentoRiferimento.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.DisplayName,
                        DataDocumento = item.PagamentoRiferimento.ScadenzaRiferimento.SpesaRiferimento.DataDocumento,
                        Archiviazione = getArchiviazioneOtticaService().GetIdentificativoArchiviazione(item.PagamentoRiferimento.ScadenzaRiferimento.SpesaRiferimento, true),
                        DataPagamento = item.PagamentoRiferimento.Data,
                        IdCondominio = item.PagamentoRiferimento.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID,
                        ImportoInteressi = item.ImportoInteressi,
                        ImportoPagamento = item.PagamentoRiferimento.Importo,
                        ImportoRitenuta = item.Importo,
                        ImportoSanzione = item.ImportoSanzione,
                        NumeroDocumento = item.PagamentoRiferimento.ScadenzaRiferimento.SpesaRiferimento.NumeroDocumento,
                        Stato = item.Stato,
                        TipoDocumento = item.PagamentoRiferimento.ScadenzaRiferimento.SpesaRiferimento.TipoDocumento,
                        PeriodoRiferimento = item.GetPeriodoRiferimento(true),
                        DataVersamentoRitenuta = item.DataPagamentoRitenuta.GetValueOrDefault(),
                        Tipo = item.Tipo
                    };

                    var datibancari = item.PagamentoRiferimento.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.DatiBancariPrincipale;
                    if (datibancari != null)
                    {
                        var abi = datibancari.Abi;
                        var cab = datibancari.Cab;
                        var descrizioneAbiCab = Common.BancheHelper.GetAbiCabDescription(datibancari.Abi, datibancari.Cab, WindsorConfigRepository.GetKey(_info.Azienda));
                        if (!string.IsNullOrEmpty(descrizioneAbiCab[0]))
                            abi += " - " + descrizioneAbiCab[0];
                        if (!string.IsNullOrEmpty(descrizioneAbiCab[1]))
                            cab += " - " + descrizioneAbiCab[1];

                        dto.AbiCondominio = abi;
                        dto.CabCondominio = cab;
                    }
                    else
                    {
                        _log.WarnFormat("Condominio senza dati bancari - {0} - idRitenuta:{1} - idCondominio:{2} - azienda:{3}", Library.Utility.GetMethodDescription(), item.PagamentoRiferimento.ID, item.PagamentoRiferimento.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, item.PagamentoRiferimento.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.Azienda.ID);
                    }

                    if (item.MovimentoContabilePagamento != null)
                    {
                        dto.IdConto = item.MovimentoContabilePagamento.ContoRiferimento.ID;
                        if (item.MovimentoContabilePagamento.SottoContoRiferimento != null)
                            dto.IdSottoconto = item.MovimentoContabilePagamento.SottoContoRiferimento.ID;
                        else if (item.MovimentoContabilePagamento.ContoCorrenteBancario != null)
                            dto.IdSottoconto = item.MovimentoContabilePagamento.ContoCorrenteBancario.ID * -1;

                    }

                    if (item.TestataRiferimento != null)
                    {
                        dto.DataVersamentoRitenuta = item.TestataRiferimento.Data.GetValueOrDefault();
                        dto.Descrizione = item.TestataRiferimento.Descrizione;
                    }

                    return dto;
                }

                return new RitenutaAccontoDTO();
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore nella creazione dell'istanza DTO - {0} - id:{1} - azienda:{2}", ex, Library.Utility.GetMethodDescription(), item != null ? item.PagamentoRiferimento.ID.ToString(CultureInfo.InvariantCulture) : "<NULL>", _info.Azienda);
                throw;
            }
        }