private DisposizioneDTO setDisposizioniDto(Disposizione disposizione) { var dto = new DisposizioneDTO {Data = disposizione.Data, Descrizione = disposizione.Descrizione, ID = disposizione.ID}; var azienda = _daoFactory.GetAziendaDao().GetById(disposizione.Azienda.ID, false); dto.IdAzienda = azienda.ID; dto.DescrizioneAzienda = azienda.Descrizione; return dto; }
/// <summary> /// Crea un Pagamento valido /// </summary> public Pagamento(ScadenzaFattura scadenza, Disposizione disposizione, decimal? importo, DateTime? dataPagamento, TipoPagamentoFatturaEnum tipo) { ScadenzaRiferimento = scadenza; DisposizioneRiferimento = disposizione; Importo = importo; Data = dataPagamento; Tipo = tipo; if (scadenza != null) scadenza.Pagamenti.Add(this); if (disposizione != null) disposizione.Pagamenti.Add(this); }
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; } }
public string CreatePagamentiImmediati(Spesa spesa, IList<ScadenzaFatturaDTO> scadenze, LogTransazione logTransazione) { try { var anomalie = string.Empty; var scadenzePagate = (scadenze.Where(scad => scad.IdContoPagamentoScadenza != null && !string.IsNullOrEmpty(scad.Stato))).ToList(); // ============================================================ // Controllo Pagamenti // ============================================================ anomalie = (from dto in scadenzePagate let scadenza = _daoFactory.GetScadenzaFatturaDao().Find(dto.ID, false) where scadenza != null where dto.Importo > scadenza.Importo.GetValueOrDefault() - scadenza.ImportoPagato select scadenza).Aggregate(anomalie, (current, scadenza) => current + ("Per la spesa: " + _archiviazioneOtticaService.GetIdentificativoArchiviazione(scadenza.SpesaRiferimento) + " l'importo del pagamento è superiore al residuo da pagare")); // ============================================================ // Esecuzione Pagamenti // ============================================================ if (string.IsNullOrEmpty(anomalie) && scadenzePagate.Any()) { AnnullamentoPagamentiSpesa(spesa.ID); var descrizione = "Pagamento Immediato"; if (spesa.NumeroDocumento != null) descrizione += $" Fatt. n. {spesa.NumeroDocumento}"; if (spesa.DataDocumento != null) descrizione += $" del {spesa.DataDocumento.Value:d}"; // Per avere un cascade corretto dell'oggetto ScadenzaFattura la disposizione di pagamento viene collegata allo stesso // logtransazione del file d'importazione diverso dal log di transazione della spesa var logTransazioneDisposizione = logTransazione; if (spesa.FileImportazione != null && spesa.FileImportazione.LogTransazione != null) logTransazioneDisposizione = spesa.FileImportazione.LogTransazione; var disposizione = new Disposizione(descrizione, DateTime.Now, spesa.EsercizioRiferimento.CondominioRiferimento.Azienda, logTransazioneDisposizione); if (logTransazione == null) _daoFactory.GetDisposizioneDao().SaveOrUpdate(disposizione); var lista = new List<DisposizionePagamentoDTO>(spesa.Scadenze.Count); var index = 0; foreach (var scadenzaDto in scadenzePagate) { try { var scadenza = _daoFactory.GetScadenzaFatturaDao().Find(scadenzaDto.ID, false); // Per le scadenze create dall'importazione bollette l'ID della scadenza è valorizzato solo alla fine if (scadenza == null) { if (spesa.FileImportazione != null && scadenzePagate.Count == spesa.Scadenze.Count) scadenza = spesa.Scadenze.ToList()[index]; } if (scadenza != null && scadenza.SpesaRiferimento != null && scadenza.SpesaRiferimento.EsercizioRiferimento != null && scadenza.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento != null) { var dto = new DisposizionePagamentoDTO { DataDocumento = spesa.DataDocumento, DataScadenza = scadenza.Scadenza, Detrazione = spesa.Detrazione, IdScadenza = scadenza.ID, ImportoAutorizzato = scadenza.Importo, ImportoPagamento = scadenza.Importo.GetValueOrDefault(), ImportoPagato = 0, ImportoRitenuta = scadenza.ImportoRitenuta, ImportoScadenza = scadenza.Importo, IdSpesa = scadenza.SpesaRiferimento.ID, NumeroDocumento = spesa.NumeroDocumento, Selezionabile = true, Valuta = scadenza.Scadenza, IdConto = scadenzaDto.IdContoPagamentoScadenza, IdSottoConto = scadenzaDto.IdSottoContoPagamentoScadenza, DataPagamentoRitenuta = scadenzaDto.DataPagamentoRitenuta, IdEsercizio = scadenza.SpesaRiferimento.EsercizioRiferimento.ID, IdCondominio = scadenza.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, ImponibileSpesa = scadenza.SpesaRiferimento.Imponibile, IdentificativoArchiviazioneOttica = _archiviazioneOtticaService.GetIdentificativoArchiviazione(scadenza.SpesaRiferimento, true), StatoSpesa = scadenza.SpesaRiferimento.Stato }; if (scadenza.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.DatiBancariPrincipale != null) { dto.Abi = scadenza.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.DatiBancariPrincipale.Abi; dto.Cab = scadenza.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.DatiBancariPrincipale.Cab; } if (scadenza.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.Responsabile != null) dto.ResponsabileCondominio = scadenza.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.Responsabile.DisplayName; if (scadenza.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ResponsabileContabilita != null) dto.ResponsabileContabilita = scadenza.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ResponsabileContabilita.DisplayName; dto.Contestata = scadenza.SpesaRiferimento.Contestata; if (scadenza.SpesaRiferimento.Sinistro > 0) dto.Sinistro = true; lista.Add(dto); } else _log.WarnFormat("ATTENZIONE: Anomalia nel tentativo di creare i pagamenti immediati - {0} - scadenza:{1} - spesa:{2}", Utility.GetMethodDescription(), scadenza != null ? scadenza.ID.ToString() : "<NULL>", spesa.ID); index++; } catch (Exception ex) { _log.ErrorFormat("Errore nella creazione dei pagamenti immediati - SINGOLA SCADENZA - {0} - data:{1} - importo:{2:c} - conto:{3} - sottoconto:{4}", ex, Utility.GetMethodDescription(), scadenzaDto.ID, scadenzaDto.IdContoPagamentoScadenza, scadenzaDto.IdSottoContoPagamentoScadenza); throw; } } createPagamenti(disposizione, lista, StatoSpesaEnum.Pagata, DataPagamentoEnum.Scadenza, TipoPagamentoFatturaEnum.Immediato, spesa.Scadenze.ToList()); // Movimenti Contabili _movimentiContabilitaService.SetMovimentiPagamenti(disposizione, null, logTransazione); } return anomalie; } catch (Exception ex) { _log.ErrorFormat("Errore nella creazione dei pagamenti immediati - {0} - spesa:{1}", ex, Utility.GetMethodDescription(), spesa.ID); throw; } }
/* private decimal getImportoDataPagare(ScadenzaFattura scadenza) { decimal importo = scadenza.SpesaRiferimento.ImportoLordo - scadenza.SpesaRiferimento.ImportoRitenuta.GetValueOrDefault() + scadenza.SpesaRiferimento.AltreSpeseEsenti.GetValueOrDefault(); return scadenza.Pagamenti.Aggregate(importo, (current, pagamento) => current - pagamento.Importo.GetValueOrDefault()); } */ public ResultPagamento CreatePagamenti(IList<DisposizionePagamentoDTO> lista, string descrizione, TipoPagamentoFatturaEnum tipo, bool invio, string tipoConto, int? idModello, bool testataPerCondominio, bool mittenteCondominio, int idAzienda) { // ================================ // Controllo Pagamenti // ================================ var message = string.Empty; foreach (var dto in lista) { var scadenza = _daoFactory.GetScadenzaFatturaDao().Find(dto.IdScadenza.GetValueOrDefault(), false); if (scadenza != null) { decimal importoRitenutaDaPagare = 0; if (scadenza.SpesaRiferimento.Detrazione > 0) importoRitenutaDaPagare = scadenza.ImportoRitenuta.GetValueOrDefault(); if (dto.ImportoPagamento > (scadenza.Importo.GetValueOrDefault() + importoRitenutaDaPagare) - scadenza.ImportoPagato) message += string.Format("Per la spesa: {0} l'importo del pagamento è superiore al residuo da pagare", _archiviazioneOtticaService.GetIdentificativoArchiviazione(scadenza.SpesaRiferimento)); } } // ================================ // Esecuzione Pagamenti // ================================ if (string.IsNullOrEmpty(message)) { DateTime? dataDisposizione = DateTime.Today; var tipoDataPagamento = DataPagamentoEnum.Today; if (tipo == TipoPagamentoFatturaEnum.Manuale) { tipoDataPagamento = DataPagamentoEnum.Custom; if (lista.Count > 0) dataDisposizione = lista[0].DataPagamento; } var disposizione = new Disposizione(descrizione, dataDisposizione, _daoFactory.GetAziendaDao().GetById(idAzienda, false), null); _daoFactory.GetDisposizioneDao().SaveOrUpdate(disposizione); createPagamenti(disposizione, lista, StatoSpesaEnum.Pagata, tipoDataPagamento, tipo, null); var result = new ResultPagamento(null, new DocumentInfo(), null); if (invio) result = _esecuzionePagamento.EsecuzionePagamenti(disposizione, false, idModello, testataPerCondominio, mittenteCondominio); if ((result.DocumentInfo.Body != null && string.IsNullOrEmpty(result.Message)) || !_esecuzionePagamento.IsNecessaryFile || !invio) { _movimentiContabilitaService.SetMovimentiPagamenti(disposizione, tipoConto, null); return result; } _persistenceContext.RollbackAndCloseSession(Security.Login.Instance.CurrentLogin().LoginName); _persistenceContext.BeginTransaction(Security.Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted); return new ResultPagamento(result.Message, new DocumentInfo(), null); } _persistenceContext.RollbackAndCloseSession(Security.Login.Instance.CurrentLogin().LoginName); _persistenceContext.BeginTransaction(Security.Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted); return new ResultPagamento(message, new DocumentInfo(), null); }
private void createPagamenti(Disposizione disposizione, IList<DisposizionePagamentoDTO> lista, StatoSpesaEnum stato, DataPagamentoEnum tipoDataPagamento, TipoPagamentoFatturaEnum tipo, IList<ScadenzaFattura> scadenze) { try { var index = 0; foreach (var disposizionePagamento in lista) { DateTime? dataPagamento = null; try { if (disposizionePagamento.ImportoPagamento > 0 || disposizionePagamento.ImportoAutorizzato > 0) { var scadenza = _daoFactory.GetScadenzaFatturaDao().Find(disposizionePagamento.IdScadenza.Value, false); if (scadenza == null && scadenze != null && lista.Count == scadenze.Count) scadenza = scadenze[index]; scadenza.ImportoAutorizzato = disposizionePagamento.ImportoAutorizzato; if (disposizionePagamento.PagamentoCompletoRitenuta) scadenza.PagamentoCompletoRitenuta = true; var importoRitenutaResiduo = scadenza.GetImportoRitenutaResiduo(); // Calcolo la data di pagamento switch (tipoDataPagamento) { case DataPagamentoEnum.Today: dataPagamento = DateTime.Today; break; case DataPagamentoEnum.Scadenza: dataPagamento = disposizionePagamento.DataScadenza; break; case DataPagamentoEnum.Custom: dataPagamento = disposizionePagamento.DataPagamento; break; case DataPagamentoEnum.Undefined: dataPagamento = null; break; default: dataPagamento = DateTime.Today; break; } var pag = _daoFactory.GetPagamentoDao().Find(disposizionePagamento.IdPagamento.GetValueOrDefault(), false) ?? new Pagamento(scadenza, disposizione, disposizionePagamento.ImportoAutorizzato, dataPagamento, tipo); // ============================================================================================== // Se non viene pagato completamente l'importo autorizzato creo un nuovo pagamento e sottraggo // dell'importo del pagamento originale l'importo pagato // ============================================================================================== Pagamento pagToUpdate; if (tipo != TipoPagamentoFatturaEnum.Undefined && tipo != TipoPagamentoFatturaEnum.Immediato && pag.Importo > disposizionePagamento.ImportoPagamento) { pag.Importo = pag.Importo - disposizionePagamento.ImportoPagamento; pagToUpdate = new Pagamento(scadenza, disposizione, disposizionePagamento.ImportoPagamento, dataPagamento, tipo); } else pagToUpdate = pag; pagToUpdate.Tipo = tipo; pagToUpdate.Data = dataPagamento; if (disposizione != null) { disposizione.Pagamenti.Add(pagToUpdate); pagToUpdate.DisposizioneRiferimento = disposizione; } pagToUpdate.Stato = stato; pagToUpdate.Valuta = disposizionePagamento.Valuta; // La ritenuta solo se NON di tratta di una spesa con detrazione decimal? importoRitenuta = 0; if (scadenza.SpesaRiferimento.Detrazione.GetValueOrDefault() == 0) { // L'importo della ritenuta se richiesto dall'utente corrisponde all'intero importo se è il primo pagamento if (!scadenza.PagamentoCompletoRitenuta) importoRitenuta = Common.ContabilitaHelper.GetImportoRitenuta(scadenza.SpesaRiferimento, disposizionePagamento.ImportoPagamento); else importoRitenuta = scadenza.Pagamenti.Count == 1 ? scadenza.ImportoRitenuta : importoRitenutaResiduo; } pagToUpdate.RitenutaAcconto = new Ritenuta(importoRitenuta); pagToUpdate.NumeroAssegno = disposizionePagamento.NumeroAssegno; if (disposizionePagamento.IdModalitaPagamento > 0) pagToUpdate.ModalitaPagamento = _daoFactory.GetModalitaPagamentoDao().GetById(disposizionePagamento.IdModalitaPagamento.Value, false); if (disposizionePagamento.IdConto != null) { var conto = _daoFactory.GetContoDao().Find(disposizionePagamento.IdConto.Value, false); if (conto != null) pagToUpdate.Conto = conto; else { _log.WarnFormat("ATTENZIONE: Non trovato conto corrente bancario - {0} - conto:{1}", Utility.GetMethodDescription(), disposizionePagamento.IdConto.GetValueOrDefault()); pagToUpdate.Conto = getDefaultContoPagamento(scadenza.SpesaRiferimento.EsercizioRiferimento); } } if (disposizionePagamento.IdSottoConto != null) { if (disposizionePagamento.IdSottoConto > 0) { var sottoconto = _daoFactory.GetSottoContoDao().Find(disposizionePagamento.IdSottoConto.Value, false); if (sottoconto != null) { _log.WarnFormat("ATTENZIONE: Non trovato conto corrente bancario - {0} - sottoconto:{1}", Utility.GetMethodDescription(), disposizionePagamento.IdSottoConto.GetValueOrDefault()); pagToUpdate.SottoConto = sottoconto; } } else if (disposizionePagamento.IdSottoConto < 0) { var contocorrente = _daoFactory.GetDatiBancariCondominiDao().Find(disposizionePagamento.IdSottoConto.Value * -1, false); if (contocorrente != null) pagToUpdate.ContoCorrenteBancario = contocorrente; else { _log.WarnFormat("ATTENZIONE: Non trovato conto corrente bancario - {0} - idContoCorrente:{1}", Utility.GetMethodDescription(), disposizionePagamento.IdSottoConto.GetValueOrDefault()); pagToUpdate.ContoCorrenteBancario = scadenza.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.DatiBancariPrincipale; } } } // Aggiorno dati scadenza scadenza.Stato = stato; if (stato == StatoSpesaEnum.Pagata) { scadenza.ImportoAutorizzato -= disposizionePagamento.ImportoPagamento; pagToUpdate.Importo = disposizionePagamento.ImportoPagamento; if (scadenza.Importo > scadenza.ImportoPagato) scadenza.Stato = StatoSpesaEnum.ParzialmentePagata; } scadenza.SpesaRiferimento.SetStato(); // Eseguo il pagamento anche della ritenuta var contoRitenuta = _daoFactory.GetContoDao().GetByCodice(scadenza.SpesaRiferimento.EsercizioRiferimento.ID, scadenza.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoBancario()); if (disposizionePagamento.DataPagamentoRitenuta != null && pagToUpdate.RitenutaAcconto != null && pagToUpdate.RitenutaAcconto.Importo != 0) { int? idSottoconto = null; if (pagToUpdate.ContoCorrenteBancario != null) idSottoconto = pagToUpdate.ContoCorrenteBancario.ID * -1; if (Conversione.IsSqlSmallDateTime(disposizionePagamento.DataPagamentoRitenuta.GetValueOrDefault())) _ritenutaAccontoService.PagamentoRitenuta(pagToUpdate, disposizionePagamento.DataPagamentoRitenuta.Value, contoRitenuta, idSottoconto, disposizione.Descrizione, null, null, null); else { _log.WarnFormat("La data di pagamento della ritenuta non è corretta - {0} - dataPagamento:{1:d} - conto:{2} - dataPagamentoRitenuta:{3:d} - descrizione:{4}", Utility.GetMethodDescription(), disposizionePagamento.DataPagamentoRitenuta, contoRitenuta.ID, dataPagamento, disposizione.Descrizione); } } } index++; } catch (Exception ex) { _log.ErrorFormat("Errore nella creazione dei pagamenti immediati - SINGOLA DISPOSIZIONE - {0} - condominio:{1} - dataPagamento:{2} - tipoDataPagamento:{3} - data:{4:d} - documento:{5} - dataDocumento:{6:d}", ex, Utility.GetMethodDescription(), disposizionePagamento.Condominio, dataPagamento, tipoDataPagamento, disposizionePagamento.DataScadenza, disposizionePagamento.NumeroDocumento, disposizionePagamento.DataDocumento); throw; } } } catch (Exception ex) { _log.ErrorFormat("Errore nella creazione dei pagamenti immediati - {0} - disposizione:{1} - data:{2:d} - descrizione:{3} - azienda:{4}", ex, Utility.GetMethodDescription(), disposizione.ID, disposizione.Data, disposizione.Descrizione, disposizione.Azienda.ID); throw; } }
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; } }
public ResultPagamento EsecuzionePagamenti(Disposizione disposizione, bool accorpate, int? idModello, bool testataPerCondominio, bool mittenteCondominio) { _disposizione = disposizione; byte[] bytes = null; var message = string.Empty; StreamWriter sw = null; try { message = IsAllowPagamento(disposizione.Pagamenti.Select(item => item.ScadenzaRiferimento.ID).ToList(), true); if (string.IsNullOrEmpty(message)) { // ============================================================================================= // Divido le disposizione per Condominio (Codice SIA) se è previsto l'accorpamento ...... // ..... altrimenti creo un blocco di testata-piede per ogni singolo pagamento // // Azienda Mittente --> Condominio // Ricevente --> Banca del Condominio (ordinante) // Destinatario --> Banca del Fornitore (beneficiario) // // Se è previsto di NON dividere i blocchi di righe per condominio (testataPerCondominio == false) // nel file sarà presente una sola riga di testata e una sola riga di piede, in questo caso // i dati bancari presenti in testata saranno quelli dello Studio (Azienda) // ============================================================================================= var pagamenti = new Dictionary<string, List<Pagamento>>(); foreach (var pag in disposizione.Pagamenti) { List<Pagamento> listaPagamenti; var condominio = pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento; var contoCorrente = pag.ContoCorrenteBancario ?? condominio.DatiBancariPrincipale; var key = string.Empty; if (testataPerCondominio) { if (accorpate) key = disposizione.ID + "&" + condominio.CodiceSIA + "&" + contoCorrente.Abi; else key = pag.ID.ToString(); } if (pagamenti.ContainsKey(key)) listaPagamenti = pagamenti[key]; else { listaPagamenti = new List<Pagamento>(); pagamenti.Add(key, listaPagamenti); } listaPagamenti.Add(pag); } var fileName = Path.GetTempPath() + "\\" + Guid.NewGuid(); if (File.Exists(fileName)) File.Delete(fileName); // ============================================================================================= // Creo un blocco di testata/piede per ogni condominio (Codice SIA) // ============================================================================================= using (sw = File.CreateText(fileName)) { foreach (var key in pagamenti.Keys) { try { var numeroDisposizione = 0; decimal importoTotale = 0; var numeroRighe = 1; string codiceSia; string codiceAbi; var cond = pagamenti[key][0].ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento; if (testataPerCondominio) { codiceSia = cond.CodiceSIA; codiceAbi = cond.DatiBancariPrincipale.Abi; } else { codiceSia = cond.Azienda.CodiceSIA; codiceAbi = cond.Azienda.BancaRiferimentoRitenuta.ID.Abi; } writeTestataPC(codiceSia, codiceAbi, key, sw); foreach (var pag in pagamenti[key]) { try { importoTotale += pag.Importo.GetValueOrDefault(); numeroDisposizione++; numeroRighe++; writeMovimento10(pag, sw, numeroDisposizione); numeroRighe++; writeMovimento16(pag, sw, numeroDisposizione); numeroRighe++; writeMovimento17(pag, sw, numeroDisposizione); numeroRighe++; writeMovimento20(pag, sw, numeroDisposizione, mittenteCondominio); numeroRighe++; writeMovimento30(pag, sw, numeroDisposizione); numeroRighe++; writeMovimento50(pag, sw, numeroDisposizione); numeroRighe++; writeMovimento70(pag, sw, numeroDisposizione); } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato durante la creazione del file CBI dei bonifici - SINGOLO PAGAMENTO - {0} - key:{1} - pag:{2}", ex, Library.Utility.GetMethodDescription(), key, pag.ID); throw; } } numeroRighe++; writeCodaEF(cond.CodiceSIA, cond.DatiBancariPrincipale.Abi, key, sw, numeroDisposizione, importoTotale, numeroRighe); } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato durante la creazione del file CBI dei bonifici - {0} - key:{1}", ex, Library.Utility.GetMethodDescription(), key); throw; } } } var infile = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read); bytes = new byte[infile.Length]; infile.Read(bytes, 0, bytes.Length); disposizione.ContenutoFile = Library.Conversione.ToString(bytes); } return new ResultPagamento(message, new DocumentInfo { Body = bytes, FileName = ContabilitaHelper.GetFileName("Pagamenti", null), FileExtension = ".txt" }, null); } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato durante la creazione del file CBI dei bonifici - {0} - modello:{1} - disposizione:{2} - azienda:{3}", ex, Library.Utility.GetMethodDescription(), idModello, disposizione.ID, disposizione.Azienda.ID); message = "Si sono verificati problemi inaspettati durante la creazione del file CBI dei bonifici." + Environment.NewLine + "Controllare il log per ulteriori dettagli."; return new ResultPagamento(message, new DocumentInfo { Body = bytes }, null); } finally { if (sw != null) { sw.Close(); sw.Dispose(); } } }
/// <summary> /// Crea il file per la disposizione dei bonifici in formato SEPA SCT /// Nel caso in cui siano presenti più debitori (Condomini) viene creato un file zip contenente tutte le disposizioni di bonifico /// </summary> /// <param name="disposizione">Oggetto contenente tutti i metadati dei bonifici</param> /// <param name="accorpate">Usato solo per i bonifici CBI</param> /// <param name="idModello">Usato solo per i pagamenti manuali</param> /// <param name="testataPerCondominio">Usato solo per i bonifici CBI</param> /// <param name="mittenteCondominio">Usato solo per i bonifici CBI</param> /// <returns></returns> public ResultPagamento EsecuzionePagamenti(Disposizione disposizione, bool accorpate, int? idModello, bool testataPerCondominio, bool mittenteCondominio) { string message; try { var documentInfo = new DocumentInfo(); message = IsAllowPagamento(disposizione.Pagamenti.Select(item => item.ScadenzaRiferimento.ID).ToList(), true); if (string.IsNullOrEmpty(message)) { var pagamenti = disposizione.Pagamenti.GroupBy(item => item.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento).ToList(); var stream = new MemoryStream(); ZipFile zipFile = null; var singleFileName = string.Empty; if (pagamenti.Count > 1) zipFile = new ZipFile(); foreach (var pagamentiGroupByCondominio in pagamenti) { try { var sepa = new CBIPaymentRequest000400 { PaymentInfo = getPaymentInfo(pagamentiGroupByCondominio.Key, pagamentiGroupByCondominio.ToList()), GroupHeader = getGroupHeader(pagamentiGroupByCondominio.ToList(), pagamentiGroupByCondominio.Key) }; var envelop = new CBIBdyPaymentRequest000400 { CBIEnvelPaymentRequest = { CBIPaymentRequest = sepa } }; var streamContent = Library.XML.SerializerHelper<CBIBdyPaymentRequest000400>.Serialize(envelop, new List<string> { "urn:CBI:xsd:CBIBdyPaymentRequest.00.04.00", "urn:CBI:xsd:CBIPaymentRequest.00.04.00" }); var fileName = ContabilitaHelper.GetFileName("Pagamenti", pagamentiGroupByCondominio.Key); if (zipFile != null) { streamContent.Seek(0, SeekOrigin.Begin); zipFile.AddEntry($"{fileName}.xml", streamContent); } else { stream = (MemoryStream)streamContent; singleFileName = fileName; } } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato durante la creazione del file CBI dei bonifici - SINGOLO CONDOMINIO - {0} - condominio:{1} - modello:{2} - disposizione:{3} - azienda:{4}", ex, Library.Utility.GetMethodDescription(), pagamentiGroupByCondominio.Key.ID, idModello, disposizione.ID, disposizione.Azienda.ID); throw; } } if (zipFile != null) { documentInfo.FileName = ContabilitaHelper.GetFileName("Pagamenti", null); documentInfo.FileExtension = ".zip"; zipFile.Save(stream); var documentMessages = _documentService.SaveDocument(stream.ToArray(), documentInfo.FileName, documentInfo.FileExtension, null, disposizione.Azienda.ID); var documento = new Documento(documentMessages.Documento.Checksum, documentInfo.FileName, documentInfo.FileExtension, "DisposizioneBonifico", false, disposizione.Azienda); _daoFactory.GetDocumentoDao().Save(documento); disposizione.Documento = documento; documentInfo.Body = stream.ToArray(); zipFile.Dispose(); } else { documentInfo.Body = stream.ToArray(); documentInfo.FileName = singleFileName; documentInfo.FileExtension = ".xml"; disposizione.ContenutoFile = Library.Conversione.ToString(documentInfo.Body); } stream.Close(); stream.Dispose(); } return new ResultPagamento(message, documentInfo, null); } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato durante la creazione del file CBI dei bonifici - {0} - modello:{1} - disposizione:{2} - azienda:{3}", ex, Library.Utility.GetMethodDescription(), idModello, disposizione.ID, disposizione.Azienda.ID); message = "Si sono verificati problemi inaspettati durante la creazione del file CBI dei bonifici." + Environment.NewLine + "Controllare il log per ulteriori dettagli."; return new ResultPagamento(message, new DocumentInfo(), null); } }
public ResultPagamento EsecuzionePagamenti(Disposizione disposizione, bool accorpamento, int? idModelloLettera, bool testataPerCondominio, bool mittenteCondominio) { IList<ReportPagamentoDTO> pagamenti = new List<ReportPagamentoDTO>(); var message = string.Empty; try { foreach (var pag in disposizione.Pagamenti) { try { var coordinateBancarieCondominio = pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.DatiBancariPrincipale; if (coordinateBancarieCondominio != null) { var abiCab = _daoFactory.GetAbiCabDao().GetById(new AbiCabId(coordinateBancarieCondominio.Abi, coordinateBancarieCondominio.Cab), false); var condominio = pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento; var fornitore = pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento; var oggetto = "RICHIESTA DI BONIFICO AI SENSI DELLA LEGGE FINANZIARIA 1998 ART.1 AGEVOLAZIONI FISCALI SU INTERVENTI DI RECUPERO DEL PATRIMONIO EDILIZIO"; if(idModelloLettera != null) { var modello = _daoFactory.GetModelloLetteraTestoDao().Find(idModelloLettera.Value, false); if (modello != null) oggetto = modello.Oggetto; } var reportPagamento = new ReportPagamentoDTO { IdPagamento = pag.ID, NomeBanca = abiCab.DescrizioneAbi + " - " + abiCab.DescrizioneCab, OggettoLettera = oggetto }; if (pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.Azienda.IndirizzoSede?.Comune != null) reportPagamento.LuogoPagamento = pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.Azienda.IndirizzoSede.Comune.Descrizione; // Condominio reportPagamento.DescrizioneCondominio = condominio.Descrizione; if (condominio.Indirizzo != null) { reportPagamento.IndirizzoCondominio = condominio.Indirizzo.Indirizzo + " " + condominio.Indirizzo.Civico; reportPagamento.CapCondominio = condominio.Indirizzo.Cap; if (condominio.Indirizzo.Comune != null) reportPagamento.ComuneCondominio = condominio.Indirizzo.Comune.Descrizione + " " + condominio.Indirizzo.Comune.ProvinciaAppartenenza.Codice; } reportPagamento.CodiceFiscaleCondominio = condominio.CodiceFiscale; reportPagamento.ContoCorrenteCondominio = coordinateBancarieCondominio.ContoCorrente; if(condominio.Azienda.Amministratore?.PersonaRiferimento != null) reportPagamento.CodiceFiscaleAmministratore = condominio.Azienda.Amministratore.PersonaRiferimento.CodiceFiscale; else { _log.WarnFormat("ATTENZIONE: Non è definito l'amministratore dell'azienda - {0} - azienda:{1}", Library.Utility.GetMethodDescription(), condominio.Azienda.ID); } // Beneficiario reportPagamento.RagioneSocialeBeneficiario = fornitore.DisplayName; if (fornitore.PersonaRiferimento.IndirizzoResidenza != null) { reportPagamento.IndirizzoBeneficiario = fornitore.PersonaRiferimento.IndirizzoResidenza.Indirizzo + " " + fornitore.PersonaRiferimento.IndirizzoResidenza.Civico; reportPagamento.CapBeneficiario = fornitore.PersonaRiferimento.IndirizzoResidenza.Cap; if (fornitore.PersonaRiferimento.IndirizzoResidenza.Comune != null) reportPagamento.ComuneBeneficiario = fornitore.PersonaRiferimento.IndirizzoResidenza.Comune.Descrizione; } reportPagamento.CodiceFiscaleBeneficiario = fornitore.PersonaRiferimento.CodiceFiscale; reportPagamento.PartitaIvaBeneficiario = fornitore.PersonaRiferimento.PartitaIva; reportPagamento.AbiBeneficiario = fornitore.PersonaRiferimento.Abi; reportPagamento.CabBeneficiario = fornitore.PersonaRiferimento.Cab; reportPagamento.ContoCorrenteBeneficiario = fornitore.PersonaRiferimento.ContoCorrente; reportPagamento.CinBeneficiario = fornitore.PersonaRiferimento.Cin; reportPagamento.IbanBeneficiario = fornitore.PersonaRiferimento.Iban; // Pagamento reportPagamento.ImportoPagamento = pag.Importo.GetValueOrDefault(); if (pag.Valuta != null) reportPagamento.ValutaPagamento = pag.Valuta.GetValueOrDefault(); reportPagamento.NumeroDocumento = pag.ScadenzaRiferimento.SpesaRiferimento.NumeroDocumento; if (pag.ScadenzaRiferimento.SpesaRiferimento.DataDocumento != null) reportPagamento.DataDocumento = pag.ScadenzaRiferimento.SpesaRiferimento.DataDocumento.GetValueOrDefault(); reportPagamento.DataPagamento = pag.Data.GetValueOrDefault(); var descrizione = string.Empty; foreach (var dettaglio in pag.ScadenzaRiferimento.SpesaRiferimento.Dettagli) { descrizione = dettaglio.GetDescrizione(); break; } reportPagamento.DescrizioneDocumento = descrizione; reportPagamento.CausaleBeneficiario = $"Sd. Ft.{reportPagamento.NumeroDocumento} del {reportPagamento.DataDocumento.ToShortDateString()} {reportPagamento.DescrizioneDocumento}"; pagamenti.Add(reportPagamento); } else message = "Per il condominio " + pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.DisplayName + " non è definita nessuna banca principale"; } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato durante l'apertura del documento - SINGOLO PAGAMENTO - {0} - pagamento:{1} - documento: /Bonifico_{2:dd-MM-yy}", ex, Library.Utility.GetMethodDescription(), pag.ID, DateTime.Today); throw; } } } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato durante l'apertura del documento - {0} - documento: /Bonifico_{1:dd-MM-yy}", ex, Library.Utility.GetMethodDescription(), DateTime.Today); } return new ResultPagamento(message, new DocumentInfo(), pagamenti); }
public virtual IUpdatableBusinessEntity Copy() { var disposizione = new Disposizione("<DA MODIFICARE>", Data, Azienda, null); return disposizione; }