private string updateDettaglio(DettaglioSpesaDTO dto, DettaglioSpesa dtoMultiIva, out DettaglioSpesa item) { var message = string.Empty; item = null; var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda); try { item = daoFactory.GetDettaglioSpesaDao().GetById(dto.ID, false); // Condizione necessaria per il controllo del fatto che sul DB ho una versione uguale o più vecchia if (dto.Version == item.Version) { item.AliquotaIva = dto.AliquotaIva; item.ImportoIva = dto.ImportoIva; item.ImportoLordo = dto.ImportoLordo - item.SpesaRiferimento.AltreSpese.GetValueOrDefault(); item.Note = dto.Note; item.NumeroRiga = dto.NumeroRiga; item.SoggettoRitenutaAcconto = dto.SoggettoRitenutaAcconto; item.Descrizione = dto.Descrizione; item.ModelloRipartizione = dto.IdModelloRipartizione != null ? daoFactory.GetModelloRegistrazioneContabileDao().GetById(dto.IdModelloRipartizione.Value, false) : null; // ------------------------------------------ // Movimenti contabili // ------------------------------------------ item.Movimenti.Clear(); for (int i = 0; i < dto.Movimenti.Length; i++) { dto.Movimenti[i].IdDettaglio = item.ID; // Se non è valorizzata alcun sottoconto e nessuna descrizione uso la descrione presente sul dettaglio if (dto.Movimenti[i].IdSottoConto == null && (dto.Movimenti[i].Descrizione == null || dto.Movimenti[i].Descrizione.Trim() == string.Empty)) dto.Movimenti[i].Descrizione = item.Descrizione; int? id = dto.Movimenti[i].ID; if (id.GetValueOrDefault() > 0) { var movimentoCheck = daoFactory.GetMovimentoContabileDao().Find(id.GetValueOrDefault(), false); if (movimentoCheck == null) dto.Movimenti[i].ID = 0; } if ((dto.Movimenti[i].Stato == "U") || (dto.Movimenti[i].Stato == "I")) { var result = getMovimentoRepository().ManageDomainEntity(dto.Movimenti[i]); if (result.Movimento != null) id = result.Movimento.ID; else return result.Message; } var movimento = daoFactory.GetMovimentoContabileDao().GetById(id.Value, false); item.Movimenti.Add(movimento); movimento.DettaglioRiferimento = item; if (dtoMultiIva != null) { var movimentoPrincipale = IesiGenericCollections<MovimentoContabile>.GetByIndex(dtoMultiIva.Movimenti, i); if (movimentoPrincipale != null && movimentoPrincipale.ContoRiferimento != null && movimentoPrincipale.ContoRiferimento.ID == movimento.ContoRiferimento.ID) movimento.MovimentoPrincipaleMultiIva = movimentoPrincipale; } } } else { // Eccezione: Sul db c'è qualche cosa di più nuovo. _log.Error("Errore nel salvataggio del dettaglio Spesa id:" + dto.ID + " - il dato sul db è più recente di quello che si vuole salvare"); message = "Errore nel salvataggio del dettaglio Spesa id:" + dto.ID + " - il dato sul db è più recente di quello che si vuole salvare"; } } catch (Exception ex) { _log.Error("Errore nel salvataggio del dettaglio Spesa: " + Utility.GetMethodDescription() + " - id:" + dto.ID, ex); throw; } return message; }
private string insertDettaglio(DettaglioSpesaDTO dto, DettaglioSpesa dettaglioMultiIva, out DettaglioSpesa item) { string message = string.Empty; item = null; try { var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda); item = new DettaglioSpesa(daoFactory.GetSpesaDao().GetById(dto.IdSpesaRiferimento, false),dto.NumeroRiga) {AliquotaIva = dto.AliquotaIva, ImportoIva = dto.ImportoIva}; item.ImportoLordo = dto.ImportoLordo - item.SpesaRiferimento.AltreSpese.GetValueOrDefault(); item.Note = dto.Note; item.SoggettoRitenutaAcconto = dto.SoggettoRitenutaAcconto; item.Descrizione = dto.Descrizione; if(dto.IdModelloRipartizione != null) item.ModelloRipartizione = daoFactory.GetModelloRegistrazioneContabileDao().GetById(dto.IdModelloRipartizione.Value, false); daoFactory.GetDettaglioSpesaDao().SaveOrUpdate(item); // ------------------------------------------ // Movimenti contabili // ------------------------------------------ item.Movimenti.Clear(); for (var i = 0; i < dto.Movimenti.Length; i++) { try { dto.Movimenti[i].IdDettaglio = item.ID; // Se non è valorizzata alcun sottoconto e nessuna descrizione uso la descrione presente sul dettaglio if (dto.Movimenti[i].IdSottoConto == null && (dto.Movimenti[i].Descrizione == null || dto.Movimenti[i].Descrizione.Trim() == string.Empty)) dto.Movimenti[i].Descrizione = item.Descrizione; int? id = dto.Movimenti[i].ID; if ((dto.Movimenti[i].Stato == "U") || (dto.Movimenti[i].Stato == "I")) { // Se è presente modello recupero eventuali ripartizioni personalizzate if (item.ModelloRipartizione != null) { var contiModelloRegistrazioneContabile = item.ModelloRipartizione.Conti.ToList()[i]; if (contiModelloRegistrazioneContabile != null) { var listaUnita = contiModelloRegistrazioneContabile.Unita.Where(unita => unita.UnitaRiferimento != null).ToList(); if (listaUnita.Count > 0) { dto.Movimenti[i].DettaglioRipartizione = new SpeseUnitaDTO[listaUnita.Count]; for (var j = 0; j < listaUnita.Count; j++) { dto.Movimenti[i].DettaglioRipartizione[j] = new SpeseUnitaDTO { IdUnitaRiferimento = listaUnita.ToList()[j].UnitaRiferimento.ID }; if (contiModelloRegistrazioneContabile.ContoRiferimento.IsSpesePersonali && listaUnita.Count == 1) dto.Movimenti[i].DettaglioRipartizione[j].Importo = dto.Movimenti[i].Importo; } if (dto.Movimenti[i].DettaglioRipartizione.Length > 0) dto.Movimenti[i].IsRipartoPersonalizzato = true; } } } var resultMovimento = getMovimentoRepository().ManageDomainEntity(dto.Movimenti[i]); if (resultMovimento.Movimento != null) id = resultMovimento.Movimento.ID; else return resultMovimento.Message; } var movimento = daoFactory.GetMovimentoContabileDao().GetById(id.Value, false); if (dettaglioMultiIva != null) { var movimentoPrincipale = IesiGenericCollections<MovimentoContabile>.GetByIndex(dettaglioMultiIva.Movimenti, i); if (movimentoPrincipale != null && movimentoPrincipale.ContoRiferimento != null && movimentoPrincipale.ContoRiferimento.ID == movimento.ContoRiferimento.ID) movimento.MovimentoPrincipaleMultiIva = movimentoPrincipale; } item.Movimenti.Add(movimento); movimento.DettaglioRiferimento = item; if (item.ModelloRipartizione != null) { movimento.LottiAddebito = getAddebito("L", item.ModelloRipartizione, i); movimento.StabiliAddebito = getAddebito("S", item.ModelloRipartizione, i); movimento.GruppiAddebito = getAddebito("G", item.ModelloRipartizione, i); } } catch (Exception ex) { _log.ErrorFormat("Errore nell'inserimento del dettaglio Spesa - SINGOLO MOVIMENTO - {0} - movimento:{1} - spesa:{2}", ex, Utility.GetMethodDescription(), dto.Movimenti[i].ID, dto.IdSpesaRiferimento); throw; } } } catch (Exception ex) { _log.ErrorFormat("Errore nell'inserimento del dettaglio Spesa - {0} - spesa:{1} - modello:{2}", ex, Utility.GetMethodDescription(), dto.IdSpesaRiferimento, dto.IdModelloRipartizione); message = "Errore nell'inserimento del dettaglio Spesa: " + Utility.GetMethodDescription(); } return message; }
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 DettaglioSpesaDTO setDettaglioDto(DettaglioSpesa dettaglio, bool includeDettaglioMovimenti, bool detrazione = false) { try { var dto = new DettaglioSpesaDTO { ID = dettaglio.ID, AliquotaIva = dettaglio.AliquotaIva, Descrizione = dettaglio.Descrizione, IdSpesaRiferimento = dettaglio.SpesaRiferimento.ID, Imponibile = dettaglio.Imponibile, ImportoIva = dettaglio.ImportoIva, ImportoLordo = dettaglio.ImportoLordo, Note = dettaglio.Note, NumeroRiga = dettaglio.NumeroRiga, SoggettoRitenutaAcconto = dettaglio.SoggettoRitenutaAcconto, Version = dettaglio.Version }; if (dettaglio.ModelloRipartizione != null) dto.IdModelloRipartizione = dettaglio.ModelloRipartizione.ID; // ------------------------------------------ // Movimenti contabili // ------------------------------------------ var indexMovimento = 0; dto.Movimenti = new MovimentoContabileDTO[dettaglio.Movimenti.Count]; foreach (var movimento in dettaglio.Movimenti) { var movimentoDto = getMovimentoRepository().GetByDomainEntity(movimento, includeDettaglioMovimenti, true, detrazione); movimentoDto.Segno = "D"; dto.Movimenti[indexMovimento] = movimentoDto; indexMovimento++; } return dto; } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato nella creazione dell'istanza DTO per un dettaglio di una spesa - {0} - dettaglio:{1}", ex, Utility.GetMethodDescription(), dettaglio.ID); throw; } }
public void ReloadRipartizioneByDettaglio(DettaglioSpesa dettaglio) { foreach (var movimento in dettaglio.Movimenti) ReloadRipartizioneByMovimento(movimento); }
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; } }
/// <summary> /// Crea un movimento contabile valido. /// E' relativo al conto economico connesso alla registrazione di una spesa /// </summary> public MovimentoContabile(TestataMovimentoContabile testata, DettaglioSpesa dettaglio, CausaleContabile causale, int? numeroRiga, Conto conto, decimal? importo, string segno) { Causale = causale; DettaglioRiferimento = dettaglio; NumeroRiga = numeroRiga; ContoRiferimento = conto; Testata = testata; Importo = importo; Segno = segno; Stato = StatoMovimentoContabileEnum.Inserito; IsVisibileGestione = true; if (Testata != null) { Testata.Movimenti.Add(this); setNumeroRegistrazione(); } if (DettaglioRiferimento != null) DettaglioRiferimento.Movimenti.Add(this); }
public DettaglioSpesaDTO GetDettaglioByDomainEntity(DettaglioSpesa dettaglio) { try { return setDettaglioDto(dettaglio, false); } catch (Exception ex) { _log.ErrorFormat("Errore nella gestione dei dettagli delle Fatture/Spese - {0} - id:{1}", ex, Utility.GetMethodDescription(), dettaglio.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; } }
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 void ApplyModello(DettaglioSpesa dettaglio, int idModello, TipoMovimentoEnum tipo) { try { if (dettaglio.Movimenti.Count > 0) { _gruppiSelezionati.Clear(); _lottiSelezionati.Clear(); _stabiliSelezionati.Clear(); _unitaSelezionate.Clear(); var modello = _daoFactory.GetModelloRegistrazioneContabileDao().GetById(idModello, true); var testata = IesiGenericCollections<MovimentoContabile>.GetByIndex(dettaglio.Movimenti, 0).Testata; var oldMovimenti = new Dictionary<int, MovimentoContabile>(); var i = 0; foreach (var mov in dettaglio.Movimenti) { i++; oldMovimenti.Add(i, mov); if (mov.Testata != null) { mov.Testata.Movimenti.Remove(mov); mov.Testata = null; } if (mov.ContoRiferimento != null) { mov.ContoRiferimento.Movimenti.Remove(mov); mov.ContoRiferimento = null; } if (mov.CondominoRiferimento != null) { mov.CondominoRiferimento.Movimenti.Remove(mov); mov.CondominoRiferimento = null; } if (mov.EvasioneBancaria != null) { mov.EvasioneBancaria.MovimentiContabili.Remove(mov); mov.EvasioneBancaria = null; } if (mov.FornitoreRiferimento != null) { mov.FornitoreRiferimento.MovimentiContabili.Remove(mov); mov.FornitoreRiferimento = null; } if (mov.ContoCorrenteBancario != null) { mov.ContoCorrenteBancario.MovimentiContabili.Remove(mov); mov.ContoCorrenteBancario = null; } if (mov.Spesa != null) { mov.Spesa.MovimentiBollette.Remove(mov); mov.Spesa = null; } } dettaglio.Movimenti.Clear(); i = 0; decimal importoRipartito = 0; var totalePercentualiConti = modello.Conti.Sum(item => item.PercentualeRipartizione.GetValueOrDefault()); foreach (var conto in modello.Conti) { i++; decimal importoMovimento; var importoDettaglio = dettaglio.ImportoLordo.GetValueOrDefault(); if (dettaglio.NumeroRiga.GetValueOrDefault() == 1) importoDettaglio += dettaglio.SpesaRiferimento.AltreSpese.GetValueOrDefault() + dettaglio.SpesaRiferimento.AltreSpeseEsenti.GetValueOrDefault(); if (totalePercentualiConti != 0) importoMovimento = (importoDettaglio / totalePercentualiConti) * conto.PercentualeRipartizione.GetValueOrDefault(); else { importoMovimento = importoDettaglio; if (conto.PercentualeRipartizione.GetValueOrDefault() < 0) importoMovimento = importoMovimento * -1; } if (i == modello.Conti.Count) { if (tipo == TipoMovimentoEnum.Accredito) importoRipartito = importoRipartito*-1; importoMovimento = importoDettaglio - importoRipartito; } // se si tratta di un accredito devo invertire il segno dell'importo var segno = "D"; if (tipo == TipoMovimentoEnum.Accredito) { segno = "A"; importoMovimento = importoMovimento * -1; } var movimento = new MovimentoContabile(testata, dettaglio, _daoFactory.GetCausaleContabileDao().GetByCodice("IF"), i, conto.ContoRiferimento, importoMovimento, segno) {SottoContoRiferimento = conto.SottoContoRiferimento}; importoRipartito += importoMovimento; if (oldMovimenti.ContainsKey(i)) { movimento.Descrizione = oldMovimenti[i].Descrizione; movimento.PercentualeProprieta = oldMovimenti[i].PercentualeProprieta; } else movimento.Descrizione = modello.DescrizioneVoceFattura; if (conto.Unita.Count > 0) { movimento.IsRipartoPersonalizzato = true; foreach (var dettaglioModello in conto.Unita) { // Lotti if (dettaglioModello.LottoRiferimento != null) { if (!_lottiSelezionati.ContainsKey(GetKey(movimento))) _lottiSelezionati.Add(GetKey(movimento), GetLottiDataSource(GetKey(movimento), conto.ContoRiferimento.ID, dettaglio.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, null, false)); _lottiSelezionati[GetKey(movimento)].Rows.Find(dettaglioModello.LottoRiferimento.ID)["Selezionato"] = true; movimento.LottiAddebito += dettaglioModello.LottoRiferimento.ID + "&"; } // Stabili if (dettaglioModello.PalazzinaRiferimento != null) { if (!_stabiliSelezionati.ContainsKey(GetKey(movimento))) _stabiliSelezionati.Add(GetKey(movimento), GetStabiliDataSource(GetKey(movimento), conto.ContoRiferimento.ID, dettaglio.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, null, false)); _stabiliSelezionati[GetKey(movimento)].Rows.Find(dettaglioModello.PalazzinaRiferimento.ID)["Selezionato"] = true; movimento.StabiliAddebito += dettaglioModello.PalazzinaRiferimento.ID + "&"; } // Gruppi if (dettaglioModello.GruppoStabileRiferimento != null) { if (!_gruppiSelezionati.ContainsKey(GetKey(movimento))) _gruppiSelezionati.Add(GetKey(movimento), GetGruppiDataSource(GetKey(movimento), conto.ContoRiferimento.ID, dettaglio.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, null, false)); _gruppiSelezionati[GetKey(movimento)].Rows.Find(dettaglioModello.GruppoStabileRiferimento.ID)["Selezionato"] = true; movimento.GruppiAddebito += dettaglioModello.GruppoStabileRiferimento.ID + "&"; } // Unità Immobiliari if (dettaglioModello.UnitaRiferimento != null) { if (!_unitaSelezionate.ContainsKey(GetKey(movimento))) _unitaSelezionate.Add(GetKey(movimento), GetUnitaDataSource(GetKey(movimento), conto.ContoRiferimento.ID, dettaglio.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, false, movimento.Testata.EsercizioRiferimento, false)); var rows = _unitaSelezionate[GetKey(movimento)].Select($"IdUnitaImmobiliare = {dettaglioModello.UnitaRiferimento.ID}"); if (rows.Length == 1) rows[0]["Selezionato"] = true; else if(!rows.Any() && conto.ContoRiferimento.IsSpesePersonali) { var soggetto = conto.ContoRiferimento.PercentualeProprieta == 0 ? dettaglioModello.UnitaRiferimento.GetConduttorePrincipale(dettaglio.SpesaRiferimento.EsercizioRiferimento.DataChiusura) : dettaglioModello.UnitaRiferimento.GetProprietarioPrincipale(dettaglio.SpesaRiferimento.EsercizioRiferimento.DataChiusura); if (soggetto != null) { rows = _unitaSelezionate[GetKey(movimento)].Select($"IdSoggettoCondominio = {soggetto.ID}"); if (rows.Length == 1) rows[0]["Selezionato"] = true; } } } } if (!string.IsNullOrEmpty(movimento.LottiAddebito)) movimento.LottiAddebito = movimento.LottiAddebito.Substring(0, movimento.LottiAddebito.Length - 1); if (!string.IsNullOrEmpty(movimento.StabiliAddebito)) movimento.StabiliAddebito = movimento.StabiliAddebito.Substring(0, movimento.StabiliAddebito.Length - 1); if (!string.IsNullOrEmpty(movimento.GruppiAddebito)) movimento.GruppiAddebito = movimento.GruppiAddebito.Substring(0, movimento.GruppiAddebito.Length - 1); } else { // =========================================================================================== // BUGID#2159 - COMMENTATO: Con la nuova funzione di riparto aggregato NON devono // più essere usati gli oggetti SpeseUnita NON deve quindi essere ripartito lo specifico // movimento a meno che non sia previsto un riparto personalizzato a livello di modello // Sostuitita con calcolo degli addebiti specifici per Lotto, Stabile e Scala. // ---------------------------------------------------------------------------------- // Se sono presenti selezioni per Stabile, Scala o specifica unità le applico ... // ---------------------------------------------------------------------------------- movimento.LottiAddebito = string.Empty; movimento.StabiliAddebito = string.Empty; movimento.GruppiAddebito = string.Empty; foreach (var dettaglioModello in conto.Unita) { // Lotti if (dettaglioModello.LottoRiferimento != null) { if (!string.IsNullOrEmpty(movimento.LottiAddebito)) movimento.LottiAddebito += "&"; movimento.LottiAddebito += dettaglioModello.LottoRiferimento.ID; } // Stabili if (dettaglioModello.PalazzinaRiferimento != null) { if (!string.IsNullOrEmpty(movimento.StabiliAddebito)) movimento.StabiliAddebito += "&"; movimento.StabiliAddebito += dettaglioModello.PalazzinaRiferimento.ID; } // Gruppi if (dettaglioModello.GruppoStabileRiferimento != null) { if (!string.IsNullOrEmpty(movimento.GruppiAddebito)) movimento.GruppiAddebito += "&"; movimento.GruppiAddebito += dettaglioModello.GruppoStabileRiferimento.ID; } } } //// ---------------------------------------------------------------------------------- //// ... altrimenti seleziono tutte le unità ... //// ---------------------------------------------------------------------------------- //else // if (!_unitaSelezionate.ContainsKey(GetKey(movimento))) // _unitaSelezionate.Add(GetKey(movimento), GetUnitaDataSource(GetKey(movimento), conto.ContoRiferimento.ID, dettaglio.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, movimento.GetImportoConSegno(), true, movimento.Testata.EsercizioRiferimento)); // =========================================================================================== } } else { _log.WarnFormat("Presente dettaglio senza movimenti - {0} - dettaglio:{1} - modello:{1} - tipo:{2}", Utility.GetMethodDescription(), dettaglio.ID, idModello, tipo); } } catch (Exception ex) { _log.ErrorFormat("Errore durante l'applicazione del modello - {0} - dettaglio:{1} - modello:{1} - tipo:{2}", ex, Utility.GetMethodDescription(), dettaglio.ID, idModello, tipo); throw; } }
public void ApplyDettaglioSpesa(DettaglioSpesa dettaglio) { foreach (var movimento in dettaglio.Movimenti) { DataTable tb = null; if (movimento.DettaglioRipartizione.Count > 0) { string key = GetKey(movimento); tb = GetEmptyUnitaDataSource(); _unitaSelezionate.Add(key, tb); } if (tb != null) { if (!movimento.ContoRiferimento.IsSpesePersonali) { var listaUnita = _daoFactory.GetUnitaImmobiliareDao().GetByCondominio(dettaglio.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID); foreach (var unita in listaUnita) { var row = tb.NewRow(); row["IdUnitaImmobiliare"] = unita.ID; row["Nominativo"] = unita.Descrizione; row["Interno"] = unita.InternoCompleto; row["TipoUnita"] = unita.TipoUnitaImmobiliare.Descrizione; if (unita.Ordine != null) row["Ordine"] = unita.Ordine; row["Selezionato"] = isPresenteUnita(unita, movimento); tb.Rows.Add(row); } } else { var soggetti = _daoFactory.GetSoggettoCondominioDao().GetAttiviByCondominioData(dettaglio.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, null, null, dettaglio.SpesaRiferimento.EsercizioRiferimento.DataApertura.GetValueOrDefault()); foreach (var soggetto in soggetti) { try { var row = tb.NewRow(); row["IdSoggettoCondominio"] = soggetto.ID; row["Nominativo"] = soggetto.DisplayName; row["Interno"] = soggetto.UnitaImmobiliare.InternoCompleto; row["TipoUnita"] = soggetto.UnitaImmobiliare.TipoUnitaImmobiliare.Descrizione; row["TipoCondomino"] = soggetto.Tipo.ToString(); if (soggetto.UnitaImmobiliare.Ordine != null) row["Ordine"] = soggetto.UnitaImmobiliare.Ordine; row["DirittiReali"] = soggetto.DirittoReale.GetValueOrDefault().Description(); if(soggetto.PercentualeRiferimento != null) row["PercentualeSpese"] = soggetto.PercentualeRiferimento; row["Selezionato"] = false; row["ParentId"] = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.ID; row["ParentName"] = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.Descrizione; tb.Rows.Add(row); } catch (Exception ex) { _log.ErrorFormat("Errore nel calcolo del datasource delle ripartizioni spese (SINGOLO SOGGETTO) - {0} - soggetto:{1} - IdDettaglio:{2}", ex, Utility.GetMethodDescription(), soggetto.ID, dettaglio.ID); throw; } } } } } }
public ModelloRegistrazioneContabile CreateModelloRipartizione(DettaglioSpesa dettaglio) { return CreateModelloRipartizione(dettaglio.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, dettaglio.Movimenti, dettaglio.ImportoLordo.GetValueOrDefault(), "<DA MODIFICARE>", string.Empty); }
private ResultDettaglioSpesa manageDettaglioSpesa(DettaglioSpesaDTO dto, DettaglioSpesa dettaglioMultiIva) { DettaglioSpesa item = null; string result = string.Empty; // Controllo sullo stato U, D, I switch (dto.Stato.ToUpper()) { case "U": result = updateDettaglio(dto, dettaglioMultiIva, out item); break; case "I": result = insertDettaglio(dto, dettaglioMultiIva, out item); break; } if (!string.IsNullOrEmpty(result)) item = null; return new ResultDettaglioSpesa(item, result); }
public ResultBolletta SalvaBolletta(BollettaDTO dto, bool controlloDataRegistrazione) { try { var message = string.Empty; if (dto.IdFornitore > 0 && dto.IdEsercizio > 0) { foreach (var dettaglioDto in dto.Dettagli) { try { if (string.IsNullOrEmpty(dettaglioDto.AliquotaIva)) dettaglioDto.ImportoLordo = dettaglioDto.Imponibile; else { var aliquotaIva = new decimal(Library.Decodifica.Instance.GetElement("CodiceIva", dettaglioDto.AliquotaIva).ValoreNumerico); dettaglioDto.ImportoIva = dettaglioDto.Imponibile * aliquotaIva; dettaglioDto.ImportoLordo = dettaglioDto.Imponibile + dettaglioDto.ImportoIva; } } catch (Exception ex) { _log.ErrorFormat("Errore durante il salvataggio di una bolletta (Singolo Dettaglio) - {0} - dettaglio:{1} - idBolletta:{2} - pagata:{3}", ex, Library.Utility.GetMethodDescription(), dettaglioDto.ID, dto.ID, dto.Rid); throw; } } if (dto.Rid && (dto.IdContoPagamento == 0 || dto.IdSottoContoPagamento == 0)) { return new ResultBolletta(dto, "Se è selezionato il pagamento automatico tramite rid occorre selezionare un conto corrente di pagamento"); } var spesa = _daoFactory.GetSpesaDao().Find(dto.ID, false); var esercizio = _daoFactory.GetEsercizioDao().GetById(dto.IdEsercizio.GetValueOrDefault(), false); if (spesa != null) { spesa.Autorizzata = dto.Autorizzata; if(!dto.Rid && spesa.Pagamenti.Count > 0) return new ResultBolletta(dto, "Non è possibile aggiornare la registrazione perchè sono presenti dei pagamenti"); var messageAnnullamentoPagamenti = _pagamentoService.IsAllowAnnullamentoPagamentiSpesa(spesa.ID); if(!string.IsNullOrEmpty(messageAnnullamentoPagamenti.FatalMessage)) return new ResultBolletta(dto, "Non è possibile aggiornare la registrazione perchè sono presenti dei pagamenti non annullabili." + Environment.NewLine + messageAnnullamentoPagamenti.FatalMessage); spesa.FornitoreRiferimento = _daoFactory.GetFornitoreDao().GetById(dto.IdFornitore.GetValueOrDefault(), false); spesa.EsercizioRiferimento = esercizio; var scadenza = spesa.Scadenze.FirstOrDefault(); if (scadenza != null) { scadenza.Scadenza = dto.DataScadenza; scadenza.Importo = dto.Importo; // Annullo i pagamenti preesistenti var messageAnnullaPagamenti = _pagamentoService.AnnullamentoPagamentiSpesa(spesa.ID); if (!string.IsNullOrEmpty(messageAnnullaPagamenti)) { var utente = _daoFactory.GetUtenteDao().Find(dto.IdUtente, false); var username = "******"; if (utente != null) username = utente.Username; else _log.ErrorFormat("Non trovato idUtente - {0} - azienda:{1} - bolletta:{2}", Library.Utility.GetMethodDescription(), Security.Login.Instance.CurrentLogin().Azienda, dto.ID); _persistenceContext.RollbackAndCloseSession(username); message += Environment.NewLine + messageAnnullaPagamenti + Environment.NewLine; return new ResultBolletta(dto, message); } } } else { spesa = new Spesa(_daoFactory.GetFornitoreDao().GetById(dto.IdFornitore.GetValueOrDefault(), false), esercizio) { Autorizzata = dto.Autorizzata }; var protocollo = _protocolloService.GetProgressivo(TipoProtocollo.Fattura, esercizio.DataApertura.GetValueOrDefault().Year, spesa.EsercizioRiferimento.CondominioRiferimento); if (protocollo.Progressivo != null) { spesa.NumeroProtocollo = protocollo.Progressivo; spesa.AnnoArchiviazioneOttica = esercizio.DataApertura.GetValueOrDefault().Year; } else { message += protocollo.Message + Environment.NewLine; return new ResultBolletta(null, message); } spesa.Scadenze.Add(new ScadenzaFattura(spesa, dto.DataScadenza, dto.Importo)); } spesa.RidAutomatica = dto.Rid; spesa.IsRipartita = false; spesa.TipoDocumento = "BOLLETTA"; spesa.DataDocumento = dto.DataDocumento; spesa.NumeroDocumento = dto.NumeroDocumento; spesa.ImportoBolletta = dto.Importo; spesa.DataInizioCompetenza = dto.DataInizioCompetenza; spesa.DataFineCompetenza = dto.DataFineCompetenza; spesa.IsRipartoPersonalizzato = dto.IsRipartoPersonalizzato; spesa.IsAbilitataArchiviazioneOttica = dto.IsAbilitataArchiviazioneOttica; spesa.Utenza = _daoFactory.GetUtenzaDao().GetById(dto.IdUtenza, false); _daoFactory.GetSpesaDao().SaveOrUpdate(spesa); // --------------------------- // Dettagli // --------------------------- spesa.Dettagli.Clear(); const int index = 0; foreach (var dettaglioDto in dto.Dettagli) { var dettaglio = new DettaglioSpesa(spesa, index) { AliquotaIva = dettaglioDto.AliquotaIva, Descrizione = dettaglioDto.Descrizione, ID = dettaglioDto.ID, Note = dettaglioDto.Note, Tipo = (TipoDettaglioBollettaEnum)Enum.Parse(typeof (TipoDettaglioBollettaEnum), dettaglioDto.Tipo), Quantita = dettaglioDto.Quantita }; if (string.IsNullOrEmpty(dettaglioDto.AliquotaIva)) dettaglio.ImportoLordo = dettaglioDto.Imponibile; else { var aliquotaIva = new decimal(Library.Decodifica.Instance.GetElement("CodiceIva", dettaglioDto.AliquotaIva).ValoreNumerico); dettaglio.ImportoIva = dettaglioDto.Imponibile * aliquotaIva; dettaglio.ImportoLordo = dettaglioDto.Imponibile + dettaglio.ImportoIva; } spesa.Dettagli.Add(dettaglio); } // --------------------------- // Movimenti // --------------------------- _movimentoContabileService.SetMovimentoBolletta(dto, spesa, null, controlloDataRegistrazione); // ========================================================================================================================================== // BUGID#2159 - COMMENTATO: Con la nuova funzione di riparto aggregato NON devono // più essere usati gli oggetti SpeseUnita NON deve quindi essere ripartito lo specifico // movimento // Sostuitita con calcolo degli addebiti specifici per Lotto, Stabile e Scala. // --------------------------- // Ripartizione // --------------------------- foreach (var movimentoDto in dto.Movimenti) { var movimento = _daoFactory.GetMovimentoContabileDao().Find(movimentoDto.ID, false); if (movimento == null) { _log.Error("Errore durante il salvataggio di una bolletta - MOVIMENTO NON PIù ESISTENTE " + Library.Utility.GetMethodDescription() + " - movimento:" + movimentoDto.ID + " - idBolletta:" + dto.ID + " - pagata:" + dto.Rid); return new ResultBolletta(null, "E' stato cancellato in un'altra finestra il movimento di contabilità"); } if (!string.IsNullOrEmpty(movimentoDto.RipartoAggiornato)) { movimento.LottiAddebito = null; movimento.GruppiAddebito = null; movimento.StabiliAddebito = null; } switch (movimentoDto.RipartoAggiornato) { case "U": break; case "G": if (movimentoDto.Ripartizione.Gruppi != null && movimentoDto.Ripartizione.Gruppi.Count > 0) { var lista = movimentoDto.Ripartizione.Gruppi; foreach (var item in lista) { if (item.Selezionato) movimento.GruppiAddebito += item.ID + "&"; } // Se sono stati selezionati tutti i gruppi NON salvo l'elenco dei gruppi if (movimento.GruppiAddebito == spesa.EsercizioRiferimento.CondominioRiferimento.GetGruppiKey()) movimento.GruppiAddebito = string.Empty; if (!string.IsNullOrEmpty(movimento.GruppiAddebito) && movimento.GruppiAddebito.EndsWith("&")) movimento.GruppiAddebito = movimento.GruppiAddebito.Substring(0, movimento.GruppiAddebito.Length - 1); } break; case "S": if (movimentoDto.Ripartizione.Stabili != null && movimentoDto.Ripartizione.Stabili.Count > 0) { var lista = movimentoDto.Ripartizione.Stabili; foreach (var item in lista) { if (item.Selezionato) movimento.StabiliAddebito += item.ID + "&"; } // Se sono stati selezionati tutti gli stabili NON salvo l'elenco degli stabili if (movimento.StabiliAddebito == spesa.EsercizioRiferimento.CondominioRiferimento.GetStabiliKey()) movimento.StabiliAddebito = string.Empty; if (!string.IsNullOrEmpty(movimento.StabiliAddebito) && movimento.StabiliAddebito.EndsWith("&")) movimento.StabiliAddebito = movimento.StabiliAddebito.Substring(0, movimento.StabiliAddebito.Length - 1); } break; case "L": if (movimentoDto.Ripartizione.Lotti != null && movimentoDto.Ripartizione.Lotti.Count > 0) { var lista = movimentoDto.Ripartizione.Lotti; foreach (var item in lista) { if (item.Selezionato) movimento.LottiAddebito += item.ID + "&"; } // Se sono stati selezionati tutti i lotti NON salvo l'elenco dei lotti if (movimento.LottiAddebito == spesa.EsercizioRiferimento.CondominioRiferimento.GetLottiKey()) movimento.LottiAddebito = string.Empty; if (!string.IsNullOrEmpty(movimento.LottiAddebito) && movimento.LottiAddebito.EndsWith("&")) movimento.LottiAddebito = movimento.LottiAddebito.Substring(0, movimento.LottiAddebito.Length - 1); } break; } } //foreach (var movimentoDto in dto.Movimenti) //{ // var movimento = _daoFactory.GetMovimentoContabileDao().Find(movimentoDto.ID, false); // if (movimento == null) // { // // _log.Error("Errore durante il salvataggio di una bolletta - MOVIMENTO NON PIù ESISTENTE " + Library.Utility.GetMethodDescription() + " - movimento:" + movimentoDto.ID + " - idBolletta:" + dto.ID + " - pagata:" + pagata); // return new ResultBolletta(null, "E' stato cancellato in un'altra finestra il movimento di contabilità"); // } // foreach (var dettaglioRipartizione in movimento.DettaglioRipartizione) // { // dettaglioRipartizione.MovimentoRiferimento = null; // dettaglioRipartizione.UnitaRiferimento = null; // _daoFactory.GetSpeseUnitaDao().Delete(dettaglioRipartizione); // } // movimento.DettaglioRipartizione.Clear(); // if (!string.IsNullOrEmpty(movimentoDto.RipartoAggiornato)) // { // movimento.LottiAddebito = null; // movimento.GruppiAddebito = null; // movimento.StabiliAddebito = null; // } // switch (movimentoDto.RipartoAggiornato) // { // case "U": // if (movimentoDto.Ripartizione.UnitaImmobiliari != null && movimentoDto.Ripartizione.UnitaImmobiliari.Count > 0) // { // var lista = movimentoDto.Ripartizione.UnitaImmobiliari; // foreach (var item in lista) // { // if (item.Selezionato) // { // var dettaglioRipartizione = new SpeseUnita(null, _daoFactory.GetUnitaImmobiliareDao().GetById(item.ID, false), movimento); // _daoFactory.GetSpeseUnitaDao().SaveOrUpdate(dettaglioRipartizione); // } // } // } // break; // case "G": // if (movimentoDto.Ripartizione.Gruppi != null && movimentoDto.Ripartizione.Gruppi.Count > 0) // { // var lista = movimentoDto.Ripartizione.Gruppi; // foreach (var item in lista) // { // if (item.Selezionato) // { // var gruppo = _daoFactory.GetGruppoStabileDao().GetById(item.ID, false); // movimento.GruppiAddebito += gruppo.ID + "&"; // foreach (var unita in gruppo.UnitaImmobiliari) // { // var dettaglioRipartizione = new SpeseUnita(null, unita, movimento); // _daoFactory.GetSpeseUnitaDao().SaveOrUpdate(dettaglioRipartizione); // } // } // } // // Se sono stati selezionati tutti i gruppi NON salvo l'elenco dei gruppi // if (movimento.GruppiAddebito == spesa.EsercizioRiferimento.CondominioRiferimento.GetGruppiKey()) // movimento.GruppiAddebito = string.Empty; // if (!string.IsNullOrEmpty(movimento.GruppiAddebito) && movimento.GruppiAddebito.EndsWith("&")) // movimento.GruppiAddebito = movimento.GruppiAddebito.Substring(0, movimento.GruppiAddebito.Length - 1); // } // break; // case "S": // if (movimentoDto.Ripartizione.Stabili != null && movimentoDto.Ripartizione.Stabili.Count > 0) // { // var lista = movimentoDto.Ripartizione.Stabili; // foreach (var item in lista) // { // if (item.Selezionato) // { // var stabile = _daoFactory.GetPalazzinaDao().GetById(item.ID, false); // movimento.StabiliAddebito += stabile.ID + "&"; // foreach (var dettaglioRipartizione in stabile.GruppiStabile.SelectMany(gruppo => gruppo.UnitaImmobiliari.Select(unita => new SpeseUnita(null, unita, movimento)))) // { // _daoFactory.GetSpeseUnitaDao().SaveOrUpdate(dettaglioRipartizione); // } // } // } // // Se sono stati selezionati tutti gli stabili NON salvo l'elenco degli stabili // if (movimento.StabiliAddebito == spesa.EsercizioRiferimento.CondominioRiferimento.GetStabiliKey()) // movimento.StabiliAddebito = string.Empty; // if (!string.IsNullOrEmpty(movimento.StabiliAddebito) && movimento.StabiliAddebito.EndsWith("&")) // movimento.StabiliAddebito = movimento.StabiliAddebito.Substring(0, movimento.StabiliAddebito.Length - 1); // } // break; // case "L": // if (movimentoDto.Ripartizione.Lotti != null && movimentoDto.Ripartizione.Lotti.Count > 0) // { // var lista = movimentoDto.Ripartizione.Lotti; // foreach (var item in lista) // { // if (item.Selezionato) // { // var stabili = _daoFactory.GetPalazzinaDao().GetByLotto(_daoFactory.GetLottoDao().GetById(item.ID, false)); // movimento.LottiAddebito += item.ID + "&"; // foreach (var dettaglioRipartizione in stabili.SelectMany(stabile => stabile.GruppiStabile.SelectMany(gruppo => gruppo.UnitaImmobiliari.Select(unita => new SpeseUnita(null, unita, movimento))))) // { // _daoFactory.GetSpeseUnitaDao().SaveOrUpdate(dettaglioRipartizione); // } // } // } // // Se sono stati selezionati tutti i lotti NON salvo l'elenco dei lotti // if (movimento.LottiAddebito == spesa.EsercizioRiferimento.CondominioRiferimento.GetLottiKey()) // movimento.LottiAddebito = string.Empty; // if (!string.IsNullOrEmpty(movimento.LottiAddebito) && movimento.LottiAddebito.EndsWith("&")) // movimento.LottiAddebito = movimento.LottiAddebito.Substring(0, movimento.LottiAddebito.Length - 1); // } // break; // } //} // ========================================================================================================================================== // --------------------------- // Pagamenti // --------------------------- if (dto.Rid) { if (spesa.ImportoBolletta > 0) _pagamentoService.CreatePagamentiImmediatiBolletta(spesa, dto); else // nota accredito { var riscossioni = new List<RiscossioneNotaAccreditoDTO> { new RiscossioneNotaAccreditoDTO { IdNotaAccredito = spesa.ID, IdConto = dto.IdContoPagamento, IdSottoConto = dto.IdSottoContoPagamento, Importo = dto.Importo } }; _pagamentoService.RiscossioneNoteAccredito(riscossioni, dto.DataScadenza); } } //==================================================================== // Se il tipo utenza non è acqua la bolletta viene subito ripartita //==================================================================== // Aggiorno il selected sul DTO, necessario in caso di inserimento foreach (var movimentoDto in dto.Movimenti) { var movimento = _daoFactory.GetMovimentoContabileDao().GetById(movimentoDto.ID, false); if (movimentoDto.Ripartizione != null) { foreach (var itemDto in movimentoDto.Ripartizione.UnitaImmobiliari) itemDto.Selezionato = movimento.DettaglioRipartizione.Any(item => item.UnitaRiferimento.ID == itemDto.ID); } } if (spesa.Utenza != null && !spesa.Utenza.RipartoLetture) { foreach (var movimento in spesa.MovimentiBollette) _ripartizioneSpeseService.RicalcoloRipartizioneByMovimento(movimento); spesa.IsRipartita = true; } spesa.IsRipartoPersonalizzato = dto.IsRipartoPersonalizzato; dto.IdentificativoArchiviazioneOttica = _archiviazioneService.GetIdentificativoArchiviazione(spesa); spesa.SetStato(); dto.StatoSpesa = spesa.Stato; } else { _log.Warn("ATTENZIONE: Per la bolletta non è definito il fornitore o l'esercizio - " + Library.Utility.GetMethodDescription() + " - fornitore:" + dto.IdFornitore.GetValueOrDefault() + " - esercizio:" + dto.IdEsercizio.GetValueOrDefault() + " - idBolletta:" + dto.ID + " - pagata:" + dto.Rid); if (!(dto.IdFornitore > 0)) message += "Per la bolletta non è definito il FORNITORE" + Environment.NewLine; if (!(dto.IdEsercizio > 0)) message += "Per la bolletta non è definito l'ESERCIZIO" + Environment.NewLine; } if (!string.IsNullOrEmpty(message)) dto = null; return new ResultBolletta(dto, message); } catch (Exception ex) { _log.ErrorFormat("Errore durante il salvataggio di una bolletta - {0} - idBolletta:{1} - pagata:{2}", ex, Library.Utility.GetMethodDescription(), dto.ID, dto.Rid); throw; } }
public ResultDettaglioSpesa(DettaglioSpesa dettaglio, string message) { Dettaglio = dettaglio; Message = message; }
public SpesaInfoDTO InserimentoNotaAccredito(NotaAccreditoDTO notaDto, IList<StornoScadenzaDTO> scadenze) { try { var esercizio = _daoFactory.GetEsercizioDao().Find(notaDto.IdEsercizio, false); if(esercizio == null) throw new InvalidDataException("Non è stato necessario l'esercizio di riferimento"); var nota = _daoFactory.GetSpesaDao().Find(notaDto.ID, false); if (nota == null) { nota = new Spesa(_daoFactory.GetFornitoreDao().GetById(notaDto.IdFornitore, false), esercizio, null); _daoFactory.GetSpesaDao().SaveOrUpdate(nota); } var impostazioni = _daoFactory.GetImpostazioniAziendaDao().GetByAzienda(nota.EsercizioRiferimento.CondominioRiferimento.Azienda.ID); nota.TipoDocumento = "NOTACC"; nota.NumeroDocumento = notaDto.NumeroDocumento; nota.DataDocumento = notaDto.DataDocumento; nota.ImportoRitenuta = scadenze.Sum(item => item.ImportoRitenuta); nota.Stato = StatoSpesaEnum.Stornata; DettaglioSpesa dettaglio; if (notaDto.IdDettaglioSpesa == 0) { dettaglio = new DettaglioSpesa(nota, 1); _daoFactory.GetDettaglioSpesaDao().SaveOrUpdate(dettaglio); } else dettaglio = _daoFactory.GetDettaglioSpesaDao().GetById(notaDto.IdDettaglioSpesa, false); dettaglio.Descrizione = notaDto.Descrizione; dettaglio.ImportoLordo = scadenze.Sum(item => item.Importo + item.ImportoRitenuta); var message = StornoNoteAccredito(nota.ID, scadenze, dettaglio, esercizio, notaDto.DataRegistrazione); var identificativoArchiviazione = string.Empty; if (string.IsNullOrEmpty(message)) { var protocollo = _protocolloService.GetProgressivo(TipoProtocollo.Fattura, esercizio.DataApertura.GetValueOrDefault().Year, nota.EsercizioRiferimento.CondominioRiferimento); if (protocollo.Progressivo != null) { nota.NumeroProtocollo = protocollo.Progressivo; if (nota.IsAbilitataArchiviazioneOttica) identificativoArchiviazione = _archiviazioneOtticaService.GetIdentificativoArchiviazione(nota, true); } else message += protocollo.Message + Environment.NewLine; } return string.IsNullOrEmpty(message) ? new SpesaInfoDTO { Id = nota.ID, IdentificativoArchiviazione = identificativoArchiviazione, NumeroProtocollo = nota.NumeroProtocollo.GetValueOrDefault(), StampaEtichettaArchiviazione = impostazioni.UtilizzoEtichettatriceArchiviazioneOtticaFatture && nota.EsercizioRiferimento.CondominioRiferimento.IsAbilitataArchiviazioneOtticaPassivi.GetValueOrDefault(), EtichettatriceArchiviazione = impostazioni.EtichettatriceArchiviazioneOttica, TipoEtichettaArchiviazione = impostazioni.TipoEtichettaArchiviazioneOttica } : new SpesaInfoDTO { Id = 0, IdentificativoArchiviazione = null, NumeroProtocollo = 0, StampaEtichettaArchiviazione = false, EtichettatriceArchiviazione = string.Empty, TipoEtichettaArchiviazione = "Testo", Message = message }; } catch (Exception ex) { _log.ErrorFormat("Errore nell'inserimento di una nota di accredito - {0} - idNota:{1} - numeroNota:{2} - fornitore:{3} - esercizio:{4} - descrizione:{5}", ex, Utility.GetMethodDescription(), notaDto.ID, notaDto.NumeroDocumento, notaDto.IdFornitore, notaDto.IdEsercizio, notaDto.Descrizione); throw; } }
public ResultDettaglioSpesa ManageDettaglioDomainEntity(DettaglioSpesaDTO dettaglioDto, DettaglioSpesa dettaglioMultiIva) { try { return manageDettaglioSpesa(dettaglioDto, dettaglioMultiIva); } catch (Exception ex) { _log.ErrorFormat("Errore nella gestione dei dettagli delle Fatture/Spese - {0} - id:{1}", ex, Utility.GetMethodDescription(), dettaglioDto.ID); throw; } }
public virtual IUpdatableBusinessEntity Copy() { var dettaglio = new DettaglioSpesa(SpesaRiferimento, NumeroRiga) { AliquotaIva = AliquotaIva, Descrizione = Descrizione, ImportoIva = ImportoIva, ImportoLordo = ImportoLordo, ModelloRipartizione = ModelloRipartizione, Note = Note, SoggettoRitenutaAcconto = SoggettoRitenutaAcconto }; foreach (var mov in Movimenti) { dettaglio.Movimenti.Add((MovimentoContabile)mov.Copy()); } return dettaglio; }