/// <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 virtual IUpdatableBusinessEntity Copy() { ScadenzaFattura rata = new ScadenzaFattura(SpesaRiferimento, null, null); return rata; }
private bool insert(ScadenzaFatturaDTO dto, out ScadenzaFattura item) { var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda); item = null; try { item = new ScadenzaFattura(daoFactory.GetSpesaDao().GetById(dto.IdSpesa, false), dto.Scadenza, dto.Importo) {ImportoRitenuta = dto.ImportoRitenuta}; daoFactory.GetScadenzaFatturaDao().SaveOrUpdate(item); } catch (Exception ex) { _log.ErrorFormat("Errore nel salvataggio scadenza Fattura/Spesa - {0} - id:{1}", ex, Library.Utility.GetMethodDescription(), dto.ID); throw; } return true; }
private bool update(ScadenzaFatturaDTO dto, out ScadenzaFattura item) { var result = false; var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda); try { item = daoFactory.GetScadenzaFatturaDao().GetById(dto.ID, false); // Solo se la scadenza non è stata pagata, oppure se l'importo da pagare è superiore a quello pagato, oppure l'importo pagato è uguale ma l'importo della ritenuta è diverso e la ritenuta non è stata ancora versata if (item.Stato == StatoSpesaEnum.Inserita || item.Stato == StatoSpesaEnum.Autorizzata || dto.Importo > item.Importo || (dto.Importo == item.Importo && dto.ImportoRitenuta != item.ImportoRitenuta && !item.Pagamenti.Any(pag => pag.RitenutaAcconto.Stato == StatoRitenutaEnum.Pagata))) { item.Importo = dto.Importo; item.ImportoRitenuta = dto.ImportoRitenuta; item.Scadenza = dto.Scadenza; item.SetStato(); result = true; } else result = true; } catch (Exception ex) { _log.Error("Errore nel salvataggio della scadenza Fattura/Spesa: " + Library.Utility.GetMethodDescription() + " - id:" + dto.ID.ToString(), ex); throw; } return result; }
private ScadenzaFatturaDTO setDto(ScadenzaFattura item) { var dto = new ScadenzaFatturaDTO { ID = item.ID, IdSpesa = item.SpesaRiferimento.ID, Importo = item.Importo, ImportoPagato = item.ImportoPagato, ImportoRitenuta = item.ImportoRitenuta, IdEsercizio = item.SpesaRiferimento.EsercizioRiferimento.ID, Esercizio = item.SpesaRiferimento.EsercizioRiferimento.DisplayName, IdCondominio = item.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, Condominio = item.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.DisplayName }; dto.ImportoResiduoRitenuta = Common.ContabilitaHelper.GetImportoRitenuta(item.ID, dto.Importo.GetValueOrDefault() - dto.ImportoPagato.GetValueOrDefault(), _windsorRepository.GetContainer(_info.Azienda)); dto.Scadenza = item.Scadenza; dto.DisplayFornitore = item.SpesaRiferimento.FornitoreRiferimento.DisplayName; dto.DisplayDataDocumento = item.SpesaRiferimento.DataDocumento; dto.DisplayNumeroDocumento = item.SpesaRiferimento.NumeroDocumento; dto.DisplayTipoDocumento = item.SpesaRiferimento.TipoDocumento; var pagamenti = item.Pagamenti.Where(pag => pag.Stato != StatoSpesaEnum.Autorizzata).ToList(); if (pagamenti.Any()) { var pag = pagamenti.FirstOrDefault(); if (pag != null) { if (pag.RitenutaAcconto != null && pag.RitenutaAcconto.TestataRiferimento != null && pag.RitenutaAcconto.TestataRiferimento.Data != null) dto.DataPagamentoRitenuta = pag.RitenutaAcconto.TestataRiferimento.Data; if (pag.Conto != null) dto.IdContoPagamentoScadenza = pag.Conto.ID; if (pag.MovimentoContabile != null) { if (pag.MovimentoContabile.SottoContoRiferimento != null) dto.IdSottoContoPagamentoScadenza = pag.MovimentoContabile.SottoContoRiferimento.ID; else if (pag.MovimentoContabile.ContoCorrenteBancario != null) dto.IdSottoContoPagamentoScadenza = pag.MovimentoContabile.ContoCorrenteBancario.ID * -1; } } } dto.StatoScadenza = item.Stato; dto.Version = item.Version; // Pagamenti var rep = getPagamentoFatturaRepository(); var pagamentiDTO = new List<PagamentoDTO>(pagamenti.Count); pagamentiDTO.AddRange(from pagamento in pagamenti select rep.GetByDomainEntity(pagamento)); dto.Pagamenti = pagamentiDTO; return dto; }
public ScadenzaFatturaDTO GetByDomainEntity(ScadenzaFattura item) { try { return setDto(item); } catch (Exception ex) { _log.Error("Errore nel caricamento delle scadenze delle fatture: " + Library.Utility.GetMethodDescription() + " - id:" + item.ID.ToString(), ex); throw; } }
public MovimentoContabile SetMovimentiStornoScadenza(DettaglioSpesa dettaglioSpesa, ScadenzaFattura scadenza, decimal importo, Esercizio esercizio, DateTime dataRegistrazione) { try { var message = IsAllowDataRegistrazione(new List<int> { scadenza.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID }, esercizio, dataRegistrazione); if (message.Count == 0) { var numeroRiga = 0; var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("SS"); // ================================================ // Testata // ================================================ var testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null); _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata); // ================================================ // Debiti VS Fornitori // ================================================ numeroRiga++; var segno = "D"; if (importo < 0) { segno = "A"; importo = importo * -1; } var movimentoPatrimoniale = new MovimentoContabile(testata, scadenza.SpesaRiferimento.FornitoreRiferimento, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(scadenza.SpesaRiferimento.EsercizioRiferimento.ID, scadenza.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoFornitori()), importo, segno) { Descrizione = "Storno Fatt. n." + scadenza.SpesaRiferimento.NumeroDocumento + " del " + scadenza.SpesaRiferimento.DataDocumento.GetValueOrDefault().ToShortDateString() }; _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale); // ================================================ // Conto Economico // ================================================ var importoTotale = 0m; numeroRiga++; if (scadenza.SpesaRiferimento.TipoDocumento != "FATBILAPP") { var movimenti = new List<MovimentoContabile>(); // Se è una FATTURA ...... if (scadenza.SpesaRiferimento.Dettagli.Count > 0) { importoTotale = scadenza.SpesaRiferimento.Dettagli.Sum(item => item.Movimenti.Sum(item2 => item2.GetImportoConSegno().GetValueOrDefault())); foreach (var dettaglio in scadenza.SpesaRiferimento.Dettagli) movimenti.AddRange(dettaglio.Movimenti); } // .... oppure una BOLLETTA else if (scadenza.SpesaRiferimento.MovimentiBollette.Count > 0) { importoTotale = scadenza.SpesaRiferimento.MovimentiBollette.Sum(item => item.GetImportoConSegno().GetValueOrDefault()); movimenti.AddRange(scadenza.SpesaRiferimento.MovimentiBollette); } foreach (var movimento in movimenti) { var movimentoEconomico = new MovimentoContabile(testata, causale, numeroRiga, movimento.ContoRiferimento, (importo * movimento.GetImportoConSegno()) / importoTotale, invertiSegno(movimento.Segno)) { SottoContoRiferimento = movimento.SottoContoRiferimento, Descrizione = movimento.GetDescrizione(), IsRipartoPersonalizzato = movimento.IsRipartoPersonalizzato, LottiAddebito = movimento.LottiAddebito, StabiliAddebito = movimento.StabiliAddebito, GruppiAddebito = movimento.GruppiAddebito, FornitoreRiferimento = movimento.FornitoreRiferimento, DettaglioRiferimento = dettaglioSpesa }; _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoEconomico); // Se è presente una ripartizione personalizzata o una spesa personale deve salvare anche il riparto. foreach (var itemRiparto in movimento.DettaglioRipartizione) { var importoRiparto = (itemRiparto.Importo.GetValueOrDefault()*movimentoEconomico.Importo.GetValueOrDefault()/movimento.Importo.GetValueOrDefault()) * -1; var spesaUnita = itemRiparto.MovimentoRiferimento.ContoRiferimento.IsSpesePersonali ? new SpeseUnita(importoRiparto, null, itemRiparto.SoggettoCondominio, movimentoEconomico) : new SpeseUnita(importoRiparto, itemRiparto.UnitaRiferimento, null, movimentoEconomico); _daoFactory.GetSpeseUnitaDao().SaveOrUpdate(spesaUnita); } movimento.MovimentoStorno = movimentoEconomico; } } // Se si tratta di fattura da Bilancio di Apertura lo storno avviene esclusivamente dal conto Bancario else { var movimentoEconomico = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoBancario()), importo, invertiSegno(movimentoPatrimoniale.Segno)) { ContoCorrenteBancario = esercizio.CondominioRiferimento.DatiBancariPrincipale, Descrizione = movimentoPatrimoniale.Descrizione }; _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoEconomico); } return movimentoPatrimoniale; } var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", dataRegistrazione)); _log.ErrorFormat("Data di registrazione non valida - {0} - data:{1} - scadenza:{2} - importo:{3}", ex, Utility.GetMethodDescription(), dataRegistrazione, scadenza.ID, importo); throw ex; } catch (Exception ex) { _log.Fatal("Errore inaspettato nella funzione - " + Utility.GetMethodDescription() + " - data:" + dataRegistrazione + " - scadenza:" + scadenza.ID + " - importo:" + importo, ex); throw; } }
private ScadenzaFatturaDTO setScadenzaDto(ScadenzaFattura item) { var dto = new ScadenzaFatturaDTO { ID = item.ID, IdSpesa = item.SpesaRiferimento.ID, Importo = item.Importo, ImportoPagato = item.ImportoPagato, ImportoRitenuta = item.ImportoRitenuta }; dto.ImportoResiduoRitenuta = Common.ContabilitaHelper.GetImportoRitenuta(item.SpesaRiferimento, dto.Importo.GetValueOrDefault() - dto.ImportoPagato.GetValueOrDefault()); dto.Scadenza = item.Scadenza; dto.DisplayFornitore = item.SpesaRiferimento.FornitoreRiferimento.DisplayName; dto.DisplayDataDocumento = item.SpesaRiferimento.DataDocumento; dto.DisplayNumeroDocumento = item.SpesaRiferimento.NumeroDocumento; dto.DisplayTipoDocumento = item.SpesaRiferimento.TipoDocumento; if (item.Pagamenti.Count == 1) { var pag = IesiGenericCollections<Pagamento>.GetByIndex(item.Pagamenti, 0); if (pag.RitenutaAcconto != null && pag.RitenutaAcconto.TestataRiferimento != null && pag.RitenutaAcconto.TestataRiferimento.Data != null) dto.DataPagamentoRitenuta = pag.RitenutaAcconto.TestataRiferimento.Data; if (pag.Conto != null) dto.IdContoPagamentoScadenza = pag.Conto.ID; if (pag.MovimentoContabile != null) { if (pag.MovimentoContabile.SottoContoRiferimento != null) dto.IdSottoContoPagamentoScadenza = pag.MovimentoContabile.SottoContoRiferimento.ID; else if (pag.MovimentoContabile.ContoCorrenteBancario != null) dto.IdSottoContoPagamentoScadenza = pag.MovimentoContabile.ContoCorrenteBancario.ID * -1; } } dto.StatoScadenza = StatoSpesaEnum.Stornata; dto.Version = item.Version; return dto; }
public BilancioAperturaMessage SetBilancioApertura(TestataMovimentoContabileGestioneDTO testata) { try { var fatalMessage = string.Empty; var warnMessage = string.Empty; //============================================== // Controllo esercizio //============================================== if (testata.CodiceEsercizio == 0) { _log.ErrorFormat("Non è definito alcun esercizio - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID); _persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName); _persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted); return new BilancioAperturaMessage("Non è definito alcun esercizio", string.Empty, false); } var esercizio = _daoFactory.GetEsercizioDao().Find(testata.CodiceEsercizio, false); if(esercizio == null) { _log.ErrorFormat("L'esercizio non è stato trovato - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID); _persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName); _persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted); return new BilancioAperturaMessage($"L'esercizio '{testata.CodiceEsercizio}' non è stato trovato.", string.Empty, false); } if(esercizio.Gestione == GestioneEsercizioEnum.Straordinario) { _log.ErrorFormat("L'esercizio deve essere un esercizio ordinario - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID); _persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName); _persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted); return new BilancioAperturaMessage("L'esercizio deve essere un esercizio ordinario", string.Empty, false); } //============================================== // Controllo Saldi Condomini //============================================== var saldiCondomini = _daoFactory.GetSaldoSoggettoDao().GetByEsercizioStabileScala(esercizio, null, null); var contoCreditiCondomini = _daoFactory.GetContoDao().GetAllByCodice(esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoVersamentiCondomini()).FirstOrDefault(item => item.EsercizioRiferimento == null); if (contoCreditiCondomini != null) { var movimentiVersamentiCondomini = testata.Movimenti.Where(item => item.IdConto == contoCreditiCondomini.ID).ToList(); if (movimentiVersamentiCondomini.Count > 1) { _persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName); _persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted); return new BilancioAperturaMessage($"Non può essere presente più di un movimento per il conto {contoCreditiCondomini.Codice} - {contoCreditiCondomini.Descrizione}", string.Empty, false); } if (movimentiVersamentiCondomini.Count == 1) { var importoCreditiCondomini = movimentiVersamentiCondomini.Sum(item => item.ImportoDare.GetValueOrDefault() - item.ImportoAvere.GetValueOrDefault()); if (importoCreditiCondomini > 0) { if (saldiCondomini.Count == 0) { _persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName); _persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted); return new BilancioAperturaMessage("Prima di registrare il bilancio di apertura occorre inserire i saldi iniziali dei singoli condomini", string.Empty, true); } var totaleSaldiCondomini = saldiCondomini.Sum(item => item.Importo); if (importoCreditiCondomini != totaleSaldiCondomini) { _persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName); _persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted); return new BilancioAperturaMessage($"L'importo del conto crediti v/condomini: {importoCreditiCondomini:c} non corrisponde con la somma dei saldi dei singoli condomini: {totaleSaldiCondomini:c}", string.Empty, true); } } } } //============================================== // Controllo data registrazione //============================================== if (testata.DataRegistrazione == null || !Conversione.IsSqlSmallDateTime(testata.DataRegistrazione.GetValueOrDefault())) { _log.ErrorFormat("Non è definita la data di registrazione - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID); _persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName); _persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted); return new BilancioAperturaMessage("Non è definita la data di registrazione", string.Empty, false); } if(testata.DataRegistrazione.GetValueOrDefault() < esercizio.DataApertura.GetValueOrDefault()) { _log.DebugFormat("La data di registrazione è inferiore alla data di apertura dell'esercizio - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID); _persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName); _persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted); return new BilancioAperturaMessage("La data di registrazione è inferiore alla data di apertura dell'esercizio", string.Empty, false); } //============================================== // Controllo correttezza importi //============================================== if (testata.Movimenti == null) { _log.FatalFormat("I movimenti sono a null - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID); _persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName); _persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted); return new BilancioAperturaMessage("I movimenti sono a null", string.Empty, false); } if (testata.Movimenti.Sum(mov => mov.ImportoDare.GetValueOrDefault()) != testata.Movimenti.Sum(mov => mov.ImportoAvere.GetValueOrDefault())) fatalMessage = $"Il totale Dare:{testata.Movimenti.Sum(mov => mov.ImportoDare.GetValueOrDefault()):c} non corrisponde col totale Avere:{testata.Movimenti.Sum(mov => mov.ImportoAvere.GetValueOrDefault()):c}.{Environment.NewLine}"; else { var listaDettagli = new Dictionary<int, DettaglioSpesa>(); // ============================================================================================================== // Se il bilancio di apertura NON è registrato nel primo esercizio occorre registrare solo i movimenti contabili // ============================================================================================================== if (IsRequiredDatiFatturaBilancioApertura(esercizio.ID)) { // =============================================== // Controllo movimenti // =============================================== foreach (var dto in testata.Movimenti) { if (dto.Stato == "U") { var messageControllo = IsAllowUpdateMovimentoBilancioApertura(dto.ID, dto.IdSpesa); if (string.IsNullOrEmpty(messageControllo)) { // ------------------------------------------------------------------------------------ // Se il conto non è Fornitori e Ritenuta devo cancellare l'eventuale spesa associata // ------------------------------------------------------------------------------------ var conto = _daoFactory.GetContoDao().GetById(dto.IdConto.GetValueOrDefault(), false); if (conto.Codice == _pianoContiService.GetCodiceContoFornitori() || conto.Codice == _pianoContiService.GetCodiceContoRitenuta()) dto.IdSpesa = 0; else { if (dto.IdSpesa > 0) { var messageDeleteSpesa = IsAllowDelete(dto.IdSpesa); if (!string.IsNullOrEmpty(messageDeleteSpesa.FatalMessage)) return new BilancioAperturaMessage(messageDeleteSpesa.FatalMessage, string.Empty, false); else { var movimento = _daoFactory.GetMovimentoContabileDao().Find(dto.ID, false); if(movimento != null) { movimento.Spesa = null; movimento.Testata.Movimenti.Remove(movimento); movimento.Testata = null; _daoFactory.GetMovimentoContabileDao().Delete(movimento); } Delete(dto.IdSpesa); dto.ID = 0; dto.IdSpesa = 0; dto.IdFornitore = 0; dto.NumeroDocumento = null; dto.DataDocumento = null; dto.ImportoFattura = null; dto.ImportoIva = null; dto.ImportoRitenuta = null; dto.InteressiRitenuta = null; dto.SanzioniRitenuta = null; dto.AliquotaRitenuta = null; dto.AltreSpese = null; dto.AltreSpeseEsenti = null; dto.DataPagamento = null; dto.DataVersamentoRitenuta = null; } } } } else { fatalMessage += messageControllo + Environment.NewLine; _log.WarnFormat("{0} - {1} - testata:{2}", fatalMessage, Utility.GetMethodDescription(), testata.ID); _persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName); _persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted); return new BilancioAperturaMessage(fatalMessage, string.Empty, false); } } } var index = 0; // =============================================== // Elaborazione di tutti i movimenti // =============================================== foreach (var movimento in testata.Movimenti) { try { if (movimento.Stato == "U") { if (movimento.IdConto == null) { _log.FatalFormat("I movimenti sono a null - 2 - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID); _persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName); _persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted); return new BilancioAperturaMessage($"Non è presente il conto per la riga:{movimento.NumeroRiga.GetValueOrDefault()}", string.Empty, false); } index++; if (movimento.ID == 0) movimento.ID = index*-1; // ---------------------------------------------------------- // Se è presente il fornitore devo gestire la fattura // ---------------------------------------------------------- var conto = _daoFactory.GetContoDao().GetById(movimento.IdConto.GetValueOrDefault(), false); if (movimento.IdFornitore > 0 && (conto.Codice == _pianoContiService.GetCodiceContoFornitori() || conto.Codice == _pianoContiService.GetCodiceContoRitenuta())) { var fornitore = _daoFactory.GetFornitoreDao().GetById(movimento.IdFornitore.GetValueOrDefault(), false); // ---------------------------------- // Importi // ---------------------------------- decimal importo; decimal? importoRitenuta = null; try { if (movimento.ImportoAvere.GetValueOrDefault() > 0) { importo = movimento.ImportoAvere.GetValueOrDefault() - movimento.AltreSpeseEsenti.GetValueOrDefault(); importoRitenuta = movimento.ImportoRitenuta; } else { importo = (movimento.ImportoDare.GetValueOrDefault() - movimento.AltreSpeseEsenti.GetValueOrDefault()) * -1; if(movimento.ImportoRitenuta != null) importoRitenuta = movimento.ImportoRitenuta.GetValueOrDefault()*-1; } } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - IMPORTI - {0} - idTestata:{1}", ex, Utility.GetMethodDescription(), testata.ID); throw; } // ---------------------------------- // Spesa // ---------------------------------- GestioneCondomini.Domain.Spesa spesa; try { if (movimento.ID > 0) { var mov = _daoFactory.GetMovimentoContabileDao().Find(movimento.ID, false); if (mov != null) { if (mov.Spesa != null) spesa = mov.Spesa; else { if (mov.DettaglioRiferimento?.SpesaRiferimento == null) { var messageSpesa = getNewSpesa(fornitore, esercizio, testata, movimento, out spesa); if (!string.IsNullOrEmpty(messageSpesa)) { fatalMessage += messageSpesa + Environment.NewLine; _log.ErrorFormat("Errore nella generazione della spesa - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID); _persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName); _persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted); return new BilancioAperturaMessage(fatalMessage, string.Empty, false); } } else spesa = mov.DettaglioRiferimento.SpesaRiferimento; } } else { int? idMov = null; if (mov != null) idMov = mov.ID; _log.ErrorFormat("Non è stato trovato il movimento contabile - {0} - id:{1}", Utility.GetMethodDescription(), idMov); _persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName); _persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted); return new BilancioAperturaMessage("Non è stato trovato il movimento contabile", string.Empty, false); } if (spesa != null) spesa.FornitoreRiferimento = fornitore; } else { spesa = new GestioneCondomini.Domain.Spesa(fornitore, esercizio, null); try { if (_protocolloService == null) { _log.ErrorFormat("Errore di inizializzazione del protocollo service - {0} - idEsercizio:{1} - idTestata:{2}", Utility.GetMethodDescription(), testata.CodiceEsercizio, testata.ID); fatalMessage = "Errore di inizializzazione del protocollo service."; } if (movimento.DataDocumento == null) { _log.ErrorFormat("La data del documento è null - {0} - documento:{1} - movimento:{2} - esercizio:{3} - testata:{4}", Utility.GetMethodDescription(), movimento.NumeroDocumento, movimento.ID, testata.CodiceEsercizio, testata.ID); fatalMessage = "La data del documento è null."; } if (esercizio.CondominioRiferimento == null) { _log.FatalFormat("Il Condominio è null - {0} - documento:{1} - movimento:{2} - esercizio:{3} - testata:{4}", Utility.GetMethodDescription(), movimento.NumeroDocumento, movimento.ID, testata.CodiceEsercizio, testata.ID); fatalMessage = "Il Condominio è null."; } var protocollo = _protocolloService.GetProgressivo(TipoProtocollo.Fattura, esercizio.DataApertura.GetValueOrDefault().Year, esercizio.CondominioRiferimento); if (protocollo.Progressivo != null) spesa.NumeroProtocollo = protocollo.Progressivo; else return new BilancioAperturaMessage(protocollo.Message, string.Empty, false); } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato nel recuperare il progressivo - {0} - data:{1:d} - condominio:{2} - movimento:{3} - esercizio:{4} - testata:{5}", ex, Utility.GetMethodDescription(), movimento.DataDocumento.GetValueOrDefault(), esercizio.CondominioRiferimento.ID, movimento.ID, testata.CodiceEsercizio, testata.ID); fatalMessage = "Errore inaspettato nel recuperare il progressivo."; } _daoFactory.GetSpesaDao().SaveOrUpdate(spesa); } if (spesa != null) { spesa.TipoDocumento = "FATBILAPP"; spesa.ImportoRitenuta = importoRitenuta; spesa.AltreSpeseEsenti = movimento.AltreSpeseEsenti; spesa.AltreSpese = movimento.AltreSpese; spesa.IsRitenutaCalcoloImponibile = spesa.FornitoreRiferimento.IsRitenutaCalcolataImponibile; if(movimento.AliquotaRitenuta != null) spesa.AliquotaRitenuta = movimento.AliquotaRitenuta.GetValueOrDefault()/100; else spesa.AliquotaRitenuta = null; spesa.NumeroDocumento = movimento.NumeroDocumento; spesa.DataDocumento = movimento.DataDocumento; spesa.Stato = conto.Codice == _pianoContiService.GetCodiceContoFornitori() ? StatoSpesaEnum.Inserita : StatoSpesaEnum.Pagata; movimento.IdSpesa = spesa.ID; } } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - SPESA - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID); throw; } // ---------------------------------- // Dettaglio Spesa // ---------------------------------- DettaglioSpesa dettaglio = null; try { if (conto.Codice == _pianoContiService.GetCodiceContoFornitori() || conto.Codice == _pianoContiService.GetCodiceContoRitenuta()) { if (movimento.ID > 0 && _daoFactory.GetMovimentoContabileDao().GetById(movimento.ID, false).DettaglioRiferimento != null) dettaglio = _daoFactory.GetMovimentoContabileDao().GetById(movimento.ID, false).DettaglioRiferimento; else { dettaglio = new DettaglioSpesa(spesa, 1); _daoFactory.GetDettaglioSpesaDao().SaveOrUpdate(dettaglio); } dettaglio.Descrizione = movimento.Descrizione; dettaglio.ImportoLordo = conto.Codice == _pianoContiService.GetCodiceContoFornitori() ? importo - movimento.AltreSpese.GetValueOrDefault() : movimento.ImportoFattura; dettaglio.ImportoIva = movimento.ImportoIva; } } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - DETTAGLIO SPESA - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID); throw; } // ------------------------------------------------------ // Scadenza - SOLO se non di tratta di nota di accredito // ------------------------------------------------------ ScadenzaFattura scadenza = null; try { if (spesa != null && movimento.ImportoDare.GetValueOrDefault() == 0) { if (movimento.ID > 0) scadenza = IesiGenericCollections<ScadenzaFattura>.GetByIndex(spesa.Scadenze, 0); if (scadenza == null) { scadenza = new ScadenzaFattura(spesa, esercizio.DataApertura, importo - spesa.ImportoRitenuta.GetValueOrDefault()) { Stato = conto.Codice == _pianoContiService.GetCodiceContoFornitori() ? StatoSpesaEnum.Inserita : StatoSpesaEnum.Pagata }; _daoFactory.GetScadenzaFatturaDao().SaveOrUpdate(scadenza); } if (conto.Codice == _pianoContiService.GetCodiceContoFornitori()) { scadenza.Importo = importo + spesa.AltreSpeseEsenti.GetValueOrDefault() - spesa.ImportoRitenuta.GetValueOrDefault(); scadenza.ImportoRitenuta = spesa.ImportoRitenuta; if (movimento.DataPagamento != null) scadenza.Scadenza = movimento.DataPagamento.GetValueOrDefault(); } else { scadenza.Importo = 0; scadenza.ImportoRitenuta = importoRitenuta; } } } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - SCADENZA - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID); throw; } // ================================================================================= // RITENUTE // ---------------------------------- // Pagamento // ---------------------------------- try { // Inserimento pagamento fattura per ritenuta in bilancio di apertura da pagare if (scadenza != null && conto.Codice == _pianoContiService.GetCodiceContoRitenuta()) { Pagamento pagamento; if (scadenza.Pagamenti.Count > 0) { pagamento = scadenza.Pagamenti.First(); pagamento.Data = movimento.DataPagamento.GetValueOrDefault(); pagamento.RitenutaAcconto.Importo = scadenza.ImportoRitenuta; pagamento.RitenutaAcconto.ImportoInteressi = movimento.InteressiRitenuta; pagamento.RitenutaAcconto.ImportoSanzione = movimento.SanzioniRitenuta; pagamento.Importo = spesa.ImportoLordo - pagamento.RitenutaAcconto.Importo.GetValueOrDefault(); pagamento.Stato = StatoSpesaEnum.Pagata; // Se il pagamento è già presente devo annullare la ritenuta eventualmente già versata // TODO: Verificare se è necessario controllare che non si tratti di un versamento CBI if (pagamento.RitenutaAcconto != null && pagamento.RitenutaAcconto.TestataRiferimento != null) { var messageDeleteRitenuta = _ritenutaService.DeletePagamentoRitenuta(pagamento.RitenutaAcconto.TestataRiferimento.ID); if (!string.IsNullOrEmpty(messageDeleteRitenuta)) fatalMessage += messageDeleteRitenuta + Environment.NewLine; } } else { pagamento = new Pagamento(scadenza, null, spesa.ImportoLordo, movimento.DataPagamento.GetValueOrDefault(), TipoPagamentoFatturaEnum.AltroAmministratore) { RitenutaAcconto = new Ritenuta(scadenza.ImportoRitenuta) { ImportoInteressi = movimento.InteressiRitenuta, ImportoSanzione = movimento.SanzioniRitenuta, Stato = StatoRitenutaEnum.Inserita }, Stato = StatoSpesaEnum.Pagata }; _daoFactory.GetPagamentoDao().SaveOrUpdate(pagamento); } // ------------------------------------------------------------------------------------------- // Se presente la data di versamento della ritenuta la ritenuta inserita è già stata versata // ------------------------------------------------------------------------------------------- if (string.IsNullOrEmpty(fatalMessage) && movimento.DataVersamentoRitenuta != null) { var contoRitenuta = _daoFactory.GetContoDao().GetByCodice(scadenza.SpesaRiferimento.EsercizioRiferimento.ID, scadenza.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoBancario()); _ritenutaService.PagamentoRitenuta(pagamento, movimento.DataVersamentoRitenuta.GetValueOrDefault(), contoRitenuta, null, testata.Descrizione, null, null, null); } } if (dettaglio != null) listaDettagli.Add(movimento.ID, dettaglio); } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - PAGAMENTO - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID); throw; } // ================================================================================= // FATTURE // --------------------------------------------------------------------------------- // Inserimento pagamento fattura per fattura in bilancio di apertura ma già pagata // --------------------------------------------------------------------------------- try { if (spesa != null && string.IsNullOrEmpty(fatalMessage) && conto.Codice == _pianoContiService.GetCodiceContoFornitori() && movimento.DataPagamento != null) { if (spesa.ID > 0 && scadenza?.Pagamenti != null && scadenza.Pagamenti.Count > 0) { var messageAnnullamentoPagamenti = _pagamentoService.IsAllowAnnullamentoPagamentiSpesa(spesa.ID); if (string.IsNullOrEmpty(messageAnnullamentoPagamenti.FatalMessage)) _pagamentoService.AnnullamentoPagamentiSpesa(spesa.ID); else fatalMessage += messageAnnullamentoPagamenti.FatalMessage + Environment.NewLine; } if (string.IsNullOrEmpty(fatalMessage)) { var idScadenza = 0; decimal? importoScadenza = spesa.ImportoLordo; var dataScadenza = movimento.DataPagamento; var statoScadenza = StatoSpesaEnum.Inserita; if (scadenza != null) { idScadenza = scadenza.ID; importoScadenza = scadenza.Importo; dataScadenza = scadenza.Scadenza; statoScadenza = scadenza.Stato; } int? idSottoConto = null; var datiBancari = esercizio.CondominioRiferimento.DatiBancariPrincipale; if (datiBancari != null) idSottoConto = datiBancari.ID*-1; var scadenze = new List<ScadenzaFatturaDTO>(1) { new ScadenzaFatturaDTO { ID = idScadenza, IdContoPagamentoScadenza = _pianoContiService.GetContoBancario(esercizio).ID, DataPagamentoRitenuta = null, DataPagamentoScadenza = movimento.DataPagamento.GetValueOrDefault(), IdSottoContoPagamentoScadenza = idSottoConto, IdSpesa = spesa.ID, Importo = importoScadenza, ImportoRitenuta = movimento.ImportoRitenuta, Scadenza = dataScadenza, StatoScadenza = statoScadenza, Stato = "U" } }; var messagePagamenti = _pagamentoService.CreatePagamentiImmediati(spesa.ID, scadenze, null); if (!string.IsNullOrEmpty(messagePagamenti)) fatalMessage += messagePagamenti + Environment.NewLine; } } } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - PAGAMENTO 2 - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID); throw; } } } } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - SINGOLO MOVIMENTO - {0} - movimento:{1} - testata:{2}", ex, Utility.GetMethodDescription(), movimento.ID, testata.ID); throw; } } } try { if(string.IsNullOrEmpty(fatalMessage)) { var result = _movimentoContabileService.SetBilancioApertura(testata); fatalMessage += result.Message; } } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - MOVIMENTI CONTABILI - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID); throw; } try { if(string.IsNullOrEmpty(fatalMessage)) { foreach (var dto in testata.Movimenti) { try { if (dto.IdMovimentoRiferimento > 0 && listaDettagli.ContainsKey(dto.ID)) _daoFactory.GetMovimentoContabileDao().GetById(dto.IdMovimentoRiferimento, false).DettaglioRiferimento = listaDettagli[dto.ID]; } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - IMPOSTAZIONE DETTAGLIO RIFERIMENTO (SINGOLO DETTAGLIO) - {0} - id:{1} - testata:{2}", ex, Utility.GetMethodDescription(), dto.ID, testata.ID); throw; } } } } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - IMPOSTAZIONE DETTAGLIO RIFERIMENTO - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID); throw; } // ============================================================================================= // Esercizi Precedenti: Se chiusi occorre eliminare le registrazioni di chiusura - bugid#2472 // ============================================================================================= var eserciziPrecedenti = esercizio.CondominioRiferimento.Esercizi.Where( item => item.Stato == StatoEsercizioEnum.Chiuso && item.Gestione == GestioneEsercizioEnum.Ordinario && item.DataApertura.GetValueOrDefault() < esercizio.DataApertura.GetValueOrDefault()).ToList(); foreach (var esercizioPrecedente in eserciziPrecedenti) _movimentoContabileService.EliminazioneOperazioniAperturaChiusura(esercizioPrecedente); } if (!string.IsNullOrEmpty(fatalMessage)) { _persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName); _persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted); } return new BilancioAperturaMessage(fatalMessage, warnMessage, false); } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID); throw; } }
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; } }