/// <summary>
/// Crea un dettaglio di Spedizione per Archiviazione Ottica valido
/// </summary>
public SpedizioneArchiviazioneOtticaDettaglio(SpedizioneArchiviazioneOttica testata, TestataMovimentoContabile testataMovimentoRiferimento)
{
Testata = testata;
TestataMovimentoRiferimento = testataMovimentoRiferimento;
if (Testata != null)
Testata.Dettaglio.Add(this);
}
public TestataMovimentoContabileDTO GetByDomainEntity(TestataMovimentoContabile testata)
{
try
{
if (testata != null)
return setDto(testata);
throw new InvalidOperationException("Errore nel caricamento delle testate dei movimenti contabili: " + Library.Utility.GetMethodDescription() + ": La Testata è NULL.");
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel caricamento delle testate dei movimenti contabili - {0} - testata:{1}", ex, Library.Utility.GetMethodDescription(), testata != null ? testata.ID.ToString() : "<NULL>");
throw;
}
}
/// <summary>
/// Crea un movimento contabile valido.
/// </summary>
public MovimentoContabile(TestataMovimentoContabile testata, CausaleContabile causale, int? numeroRiga, SottoConto sottoConto, decimal? importo, string segno)
{
Causale = causale;
NumeroRiga = numeroRiga;
SottoContoRiferimento = sottoConto;
ContoRiferimento = sottoConto.ContoRiferimento;
Testata = testata;
Importo = importo;
Segno = segno;
Stato = StatoMovimentoContabileEnum.Inserito;
IsVisibileGestione = true;
if (Testata != null)
{
Testata.Movimenti.Add(this);
setNumeroRegistrazione();
}
}
private SpesaDTO convertTestataToDto(TestataMovimentoContabile item)
{
try
{
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
var movimentiNumeroUno = item.Movimenti.Where(mov => mov.NumeroRiga == 1).ToList();
if(movimentiNumeroUno.Count > 1)
_log.WarnFormat("Trovato più di un movimento con numero riga 1 per una testata di movimento contabile - {0} - id:{1} - azienda:{2}", Utility.GetMethodDescription(), item.ID, _info.Azienda);
var primoMovimento = movimentiNumeroUno.FirstOrDefault();
var importo = item.GetImportoSpesa();
var dto = new SpesaDTO
{
IdEsercizio = item.EsercizioRiferimento.ID,
DescrizioneEsercizio = item.EsercizioRiferimento.DisplayName,
DescrizioneCondominio = item.EsercizioRiferimento.CondominioRiferimento.DisplayName,
IsAbilitataArchiviazioneOttica = item.IsAbilitataArchiviazioneOttica
};
if (item.SpesaRiferimento == null)
{
if (primoMovimento != null && primoMovimento.FornitoreRiferimento != null)
{
dto.IdFornitore = primoMovimento.FornitoreRiferimento.ID;
dto.DisplayFornitore = primoMovimento.FornitoreRiferimento.DisplayName;
}
}
else
{
dto.IdFornitore = item.SpesaRiferimento.FornitoreRiferimento.ID;
dto.DisplayFornitore = item.SpesaRiferimento.FornitoreRiferimento.DisplayName;
dto.NumeroDocumento = item.SpesaRiferimento.NumeroDocumento;
dto.DataDocumento = item.SpesaRiferimento.DataDocumento;
}
dto.IdTestata = item.ID;
if (importo != null)
{
dto.Imponibile = importo.Value;
dto.ImportoLordo = importo.Value;
}
dto.TipoDocumento = "Movimento";
dto.StatoSpesa = StatoSpesaEnum.Pagata;
if (item.Movimenti.Any(mov => mov.Stato == StatoMovimentoContabileEnum.Evaso))
dto.StatoSpesa = StatoSpesaEnum.Evasa;
dto.DisplayName = item.Descrizione;
dto.IdentificativoArchiviazioneOttica = getArchiviazioneOtticaService().GetIdentificativoArchiviazione(item);
dto.DataRegistrazione = item.DataRegistrazione.GetValueOrDefault();
dto.IsRipartoPersonalizzato = item.Movimenti.Any(mov => mov.IsRipartoPersonalizzato);
if (item.AddebitoCompetenze.Count > 0)
{
var firstOrDefault = item.AddebitoCompetenze.FirstOrDefault();
if (firstOrDefault != null)
dto.IdAddebitoCompetenze = firstOrDefault.ID;
}
// ------------------------------------------
// Nominativo Spesa Personale
// ------------------------------------------
var nominativoSpesaPersonale = string.Empty;
var movimentiPersonali = from mov in item.Movimenti
where mov.ContoRiferimento.IsSpesePersonali
select mov;
foreach (var mov in movimentiPersonali)
{
foreach (var spesaUnita in mov.DettaglioRipartizione)
{
if (spesaUnita.Importo.GetValueOrDefault() != 0)
{
if (!string.IsNullOrEmpty(nominativoSpesaPersonale))
{
if (!nominativoSpesaPersonale.Contains("<br/>"))
nominativoSpesaPersonale = "<b>" + nominativoSpesaPersonale + "</b><br/>";
else
nominativoSpesaPersonale += "<br/>";
}
if (spesaUnita.UnitaRiferimento != null)
{
if (mov.ContoRiferimento.PercentualeProprieta == 1)
{
var proprietario = spesaUnita.UnitaRiferimento.GetProprietarioPrincipale(item.EsercizioRiferimento.DataChiusura);
if(proprietario != null)
nominativoSpesaPersonale += proprietario.DisplayName;
}
else
{
var conduttore = spesaUnita.UnitaRiferimento.GetConduttorePrincipale(item.EsercizioRiferimento.DataChiusura);
if (conduttore != null)
nominativoSpesaPersonale += conduttore.DisplayName;
else
{
var proprietario = spesaUnita.UnitaRiferimento.GetProprietarioPrincipale(item.EsercizioRiferimento.DataChiusura);
if(proprietario != null)
nominativoSpesaPersonale += proprietario.DisplayName;
}
}
}
else
nominativoSpesaPersonale += spesaUnita.SoggettoCondominio.DisplayName;
}
}
}
dto.NominativoSpesaPersonale = nominativoSpesaPersonale;
// ------------------------------------------
// Scale Addebito
// ------------------------------------------
var scaleElaborate = new List<int>();
var movimenti = from itemScala in item.Movimenti
where !string.IsNullOrEmpty(itemScala.GruppiAddebito)
select itemScala;
dto.ScaleAddebito = getScaleAddebito(movimenti, scaleElaborate, daoFactory);
// ------------------------------------------
// Conti - Sottoconti Addebito
// ------------------------------------------
var descrizioniConti = new List<string>();
var descrizioniSottoConti = new List<string>();
var movimentiConti = from itemConto in item.Movimenti
select itemConto;
var descrizioni = getContiSottocontiDettagliAddebito(movimentiConti, descrizioniConti, descrizioniSottoConti, null, true, false, item.EsercizioRiferimento);
dto.DescrizioneBilancio = descrizioni[0];
dto.DescrizioneSottoconto = descrizioni[1];
return dto;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella creazione dell'istanza DTO per una testata di movimento contabile - {0} - id:{1}", ex, Utility.GetMethodDescription(), item.ID);
throw;
}
}
public string IsAllowDeleteTestata(TestataMovimentoContabile testata)
{
var message = new StringBuilder();
if (testata.EsercizioRiferimento.Stato == StatoEsercizioEnum.Chiuso)
message.Append("La spesa è relativa ad un esercizio chiuso." + Environment.NewLine);
if (testata.MovimentiEvasione.Count > 0)
message.Append("La spesa è associata ad un altro movimento. Occorre eliminare prima il movimento dipendente." + Environment.NewLine);
// Documenti inviati per archiviazione
if (testata.SpedizioniArchiviazioneOttica.Count > 0)
{
var descrizioneSpese = string.Empty;
foreach (var dettaglio in testata.SpedizioniArchiviazioneOttica)
{
if (dettaglio.SpesaRiferimento != null)
{
descrizioneSpese += string.Format("{0} Ft. n.{1} del {2:d} - Forn.{3}{4}",
_archiviazioneOtticaService.GetIdentificativoArchiviazione(dettaglio.SpesaRiferimento, true),
dettaglio.SpesaRiferimento.NumeroDocumento,
dettaglio.SpesaRiferimento.DataDocumento.GetValueOrDefault(),
dettaglio.SpesaRiferimento.FornitoreRiferimento.DisplayName,
Environment.NewLine);
}
else if(dettaglio.TestataMovimentoRiferimento != null)
{
descrizioneSpese += string.Format("{0} Mov.:{1} del {2:d}", _archiviazioneOtticaService.GetIdentificativoArchiviazione(dettaglio.TestataMovimentoRiferimento), dettaglio.TestataMovimentoRiferimento.Descrizione, dettaglio.TestataMovimentoRiferimento.DataRegistrazione.GetValueOrDefault());
}
}
message.Append("Alla spesa è associato un documento che è già stato spedito per l'archiviazione ottica. Verificare le seguenti fatture:" + Environment.NewLine + descrizioneSpese);
}
// Solleciti associati
var solleciti = _daoFactory.GetSollecitoDao().GetByTestataMovimentoContabile(testata.ID);
if (solleciti.Count > 0)
{
var descrizioneSolleciti = Environment.NewLine;
foreach (var sollecito in solleciti)
{
if (sollecito != null)
{
try
{
if (sollecito.Soggetto != null)
descrizioneSolleciti = string.Format("{0} - Sollecito di {1}{2}", descrizioneSolleciti, sollecito.Soggetto.DisplayName, Environment.NewLine);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella funzione - {0} - sollecito:{1}", ex, Utility.GetMethodDescription(), sollecito.ID);
throw;
}
}
}
message.Append("Alla spesa sono associati " + solleciti.Count + " solleciti con addebito di spese, il movimento sarà automaticamente annullato se sono annullati gli addebiti dalla lista solleciti:" + Environment.NewLine + descrizioneSolleciti + Environment.NewLine);
}
return message.ToString();
}
public TestataMovimentoContabile SetMovimentiInserimentoSpesa(Spesa spesa, TestataMovimentoContabile testata, DateTime dataRegistrazione)
{
var message = IsAllowDataRegistrazione(new List<int> {spesa.EsercizioRiferimento.CondominioRiferimento.ID}, spesa.EsercizioRiferimento, dataRegistrazione);
if (message.Count == 0)
{
_daoFactory.GetSpesaDao().SaveOrUpdate(spesa);
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("IF");
if (testata == null)
testata = new TestataMovimentoContabile(spesa.EsercizioRiferimento, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null);
testata.SpesaRiferimento = spesa;
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
// ------------------------------------------------
// Conto economico
// ------------------------------------------------
var numeroRiga = 0;
var importoEconomico = 0m;
foreach (var dettaglio in spesa.Dettagli)
{
if (numeroRiga == 0)
testata.Descrizione = dettaglio.GetDescrizione();
foreach (var movimento in dettaglio.Movimenti)
{
movimento.Testata = testata;
movimento.IsMovimentoEconomico = true;
testata.Movimenti.Add(movimento);
numeroRiga++;
movimento.NumeroRiga = numeroRiga;
if (movimento.Importo < 0)
_log.WarnFormat("Presente importo movimento con segno negativo - {0} - movimento:{1}", Utility.GetMethodDescription(), movimento.ID);
importoEconomico += Math.Round(movimento.GetImportoPerSpesa(true).GetValueOrDefault(), 2);
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimento);
}
}
foreach (var movimento in spesa.MovimentiBollette)
{
movimento.Testata = testata;
movimento.IsMovimentoEconomico = true;
testata.Movimenti.Add(movimento);
numeroRiga++;
movimento.NumeroRiga = numeroRiga;
if (movimento.GetImportoConSegno() < 0)
{
movimento.Segno = "A";
movimento.Importo = movimento.GetImportoConSegno()*-1;
}
importoEconomico += movimento.Importo.GetValueOrDefault();
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimento);
}
// ------------------------------------------------
// Debiti VS Fornitori
// ------------------------------------------------
var importoTotale = spesa.ImportoLordo + spesa.AltreSpeseEsenti.GetValueOrDefault();
var importoTotaleArrotondato = Math.Round(importoTotale, 2);
numeroRiga++;
var segno = "A";
if (importoTotale < 0)
{
segno = "D";
importoTotaleArrotondato = importoTotaleArrotondato*-1;
}
var movimentoPatrimoniale = new MovimentoContabile(testata, spesa.FornitoreRiferimento, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(spesa.EsercizioRiferimento.ID, spesa.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoFornitori()), importoTotaleArrotondato, segno)
{
Descrizione = $"Fatt. n. {spesa.NumeroDocumento} del {spesa.DataDocumento.GetValueOrDefault():d}"
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);
// ------------------------------------------------
// Eventuale arrotondamento
// ------------------------------------------------
if (spesa.TipoDocumento == "NOTACC" || spesa.ImportoLordo < 0)
importoTotaleArrotondato = importoTotaleArrotondato*-1;
setMovimentoArrotondamento(importoTotaleArrotondato, importoEconomico, numeroRiga, spesa, testata, causale, null);
return testata;
}
var ex = new InvalidDataException($"La data di registrazione {dataRegistrazione:d} non è valida");
_log.ErrorFormat("Data di registrazione non valida - {0} - data:{1} - spesa:{2} - dataRegistrazione:{3}", ex, Utility.GetMethodDescription(), dataRegistrazione, spesa.ID, dataRegistrazione);
throw ex;
}
public void CalcolaNumeroRiga(TestataMovimentoContabile testata)
{
var firstOrDefault = testata.Movimenti.OrderByDescending(mov => mov.NumeroRiga).FirstOrDefault();
if (firstOrDefault != null)
{
var ultimoNumeroRiga = firstOrDefault.NumeroRiga.GetValueOrDefault();
foreach (var movimento in testata.Movimenti)
{
if (movimento.NumeroRiga == null || movimento.NumeroRiga == 0)
{
ultimoNumeroRiga++;
movimento.NumeroRiga = ultimoNumeroRiga;
}
}
}
}
public string SetTestataContabileGenerica(TestataMovimentoContabileGenericoDTO dto)
{
try
{
var message = string.Empty;
var numeroRiga = 0;
if (dto.IdEsercizio > 0)
{
if (dto.Movimenti.Sum(mov => mov.ImportoDare.GetValueOrDefault()) !=
dto.Movimenti.Sum(mov => mov.ImportoAvere.GetValueOrDefault()))
message = "Il totale Dare:" + dto.Movimenti.Sum(mov => mov.ImportoDare.GetValueOrDefault()).ToString("c") + " non corrisponde col totale Avere:" + dto.Movimenti.Sum(mov => mov.ImportoAvere.GetValueOrDefault()).ToString("c") + Environment.NewLine;
else if (dto.DataRegistrazione == null)
message = "Deve essere definita la data di registrazione" + Environment.NewLine;
else
{
var esercizio = _daoFactory.GetEsercizioDao().Find(dto.IdEsercizio.GetValueOrDefault(), false);
if (esercizio != null && esercizio.Stato == StatoEsercizioEnum.Aperto)
{
// controllo data registrazione
var messageData = IsAllowDataRegistrazione(new List<int> {esercizio.CondominioRiferimento.ID}, esercizio, dto.DataRegistrazione.GetValueOrDefault());
if (messageData.Count > 0)
{
_log.WarnFormat("Data di registrazione non valida - {0} - data:{1} - esercizio:{2}", Utility.GetMethodDescription(), dto.DataRegistrazione.GetValueOrDefault(), esercizio.ID);
return messageData.Aggregate(message, (current, mess) => current + (mess + Environment.NewLine));
}
var causale = _daoFactory.GetCausaleContabileDao().GetById(dto.IdCausale, false);
var testata = _daoFactory.GetTestataMovimentoContabileDao().Find(dto.ID, false);
if (testata == null)
{
testata = new TestataMovimentoContabile(esercizio, dto.DataRegistrazione.Value, TipoTestataMovimentoContabileEnum.Manuale, null) {IsAllowUpdate = false};
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
}
else
{
// ----------------------------------------------------------
// Verifico che tutti i movimenti siano aggiornabili
// ----------------------------------------------------------
message = testata.Movimenti.Select(movimento => IsAllowUpdateMovimento(movimento.ID)).Where(messageMovimento => !string.IsNullOrEmpty(messageMovimento)).Aggregate(message, (current, messageMovimento) => current + string.Format("{0}{1}", messageMovimento, Environment.NewLine));
if (!string.IsNullOrEmpty(message))
return message;
// ----------------------------------------------------------
testata.EsercizioRiferimento = esercizio;
testata.DataRegistrazione = dto.DataRegistrazione.Value;
testata.Movimenti.Clear();
}
testata.Descrizione = dto.Descrizione;
foreach (var movimentoDto in dto.Movimenti)
{
numeroRiga++;
var conto = _daoFactory.GetContoDao().GetById(movimentoDto.IdConto.GetValueOrDefault(), false);
string segno;
decimal importo;
if (movimentoDto.ImportoAvere > 0)
{
importo = movimentoDto.ImportoAvere.GetValueOrDefault();
segno = "A";
}
else
{
importo = movimentoDto.ImportoDare.GetValueOrDefault();
segno = "D";
}
var movimento = _daoFactory.GetMovimentoContabileDao().Find(movimentoDto.ID, false);
if (movimento == null)
{
movimento = new MovimentoContabile(testata, causale, numeroRiga, conto, importo, segno) {Descrizione = movimentoDto.Descrizione};
if (movimentoDto.IdFornitore != null && movimentoDto.IdFornitore.GetValueOrDefault() > 0)
movimento.FornitoreRiferimento = _daoFactory.GetFornitoreDao().GetById(movimentoDto.IdFornitore.Value, false);
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimento);
}
else
{
movimento.Causale = causale;
movimento.Segno = segno;
movimento.Importo = importo;
movimento.ContoRiferimento = conto;
movimento.NumeroRiga = numeroRiga;
movimento.Descrizione = movimentoDto.Descrizione;
if (movimentoDto.IdFornitore != null && movimentoDto.IdFornitore.GetValueOrDefault() > 0)
movimento.FornitoreRiferimento = _daoFactory.GetFornitoreDao().GetById(movimentoDto.IdFornitore.Value, false);
}
testata.Movimenti.Add(movimento);
if (movimentoDto.IdSottoConto != null)
{
if (movimentoDto.IdSottoConto > 0)
{
var sottoConto = _daoFactory.GetSottoContoDao().GetById(movimentoDto.IdSottoConto.Value, false);
movimento.SottoContoRiferimento = sottoConto;
}
else if (movimentoDto.IdSottoConto < 0)
{
if (movimento.ContoRiferimento.Codice == _pianoContiService.GetCodiceContoBancario())
{
var banca = _daoFactory.GetDatiBancariCondominiDao().Find(movimentoDto.IdSottoConto.Value*-1, false);
if (banca != null)
movimento.ContoCorrenteBancario = banca;
}
else if (movimento.ContoRiferimento.Codice == _pianoContiService.GetCodiceContoFornitori())
{
var fornitore = _daoFactory.GetFornitoreDao().Find(movimentoDto.IdSottoConto.Value*-1, false);
if (fornitore != null)
movimento.FornitoreRiferimento = fornitore;
}
else if (movimento.ContoRiferimento.Codice == _pianoContiService.GetCodiceContoVersamentiCondomini() || movimento.ContoRiferimento.Codice == _pianoContiService.GetCodiceContoRateCondomini())
{
var soggetto = _daoFactory.GetSoggettoCondominioDao().Find(movimentoDto.IdSottoConto.Value*-1, false);
if (soggetto != null)
movimento.CondominoRiferimento = soggetto;
}
}
}
}
// Aggiorno l'importo dell'eventuale versamento associato
foreach (var movimentoContabile in testata.Movimenti)
{
var versamento = _daoFactory.GetVersamentoSoggettoDao().GetByMovimentoContabile(movimentoContabile);
if (versamento != null)
versamento.Importo = movimentoContabile.Importo.GetValueOrDefault();
}
}
else
{
if (esercizio != null)
message += "La registrazione non è possibile perchè l'esercizio è chiuso." + Environment.NewLine;
else
{
message += "L'esercizio non è più presente nel database." + Environment.NewLine;
_log.WarnFormat("Tentativo di registrare una testata generica di movimento contabile per un esercizio inesistente - {0} - esercizio:{1} - testata:{2}", Utility.GetMethodDescription(), dto.IdEsercizio, dto.ID);
}
}
}
}
return message;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante l'aggiornamento della testata generica di movimento contabile - {0}", Utility.GetMethodDescription(), ex);
throw;
}
}
public TestataMovimentoContabile SetMovimentiVersamentiDopoChiusura(Esercizio esercizioStraordinario)
{
try
{
TestataMovimentoContabile testata = null;
var contoVersamentiCondomini = _daoFactory.GetContoDao().GetByCodice(esercizioStraordinario.ID, esercizioStraordinario.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoVersamentiCondomini());
var movimenti = GetMovimentiByContiData(esercizioStraordinario.CondominioRiferimento.ID, esercizioStraordinario.DataChiusura.GetValueOrDefault().AddDays(1), DateTime.MaxValue, new List<int> { contoVersamentiCondomini.ID });
if (movimenti.Any())
{
testata = new TestataMovimentoContabile(esercizioStraordinario, esercizioStraordinario.DataChiusura, TipoTestataMovimentoContabileEnum.Automatica, null)
{
AperturaChiusuraConti = true,
Descrizione = "Versamento dopo data chiusura"
};
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("VC");
var contoVersamentiDopoChiusura = _pianoContiService.GetContoVersamentiSuccessiviAllaChiusura(esercizioStraordinario);
var numeroRiga = 0;
foreach (var movimentoContabile in movimenti)
{
try
{
if (movimentoContabile.CondominoRiferimento != null)
{
var descrizione = string.Format("Versamento dopo data chiusura - {0} del {1}", movimentoContabile.CondominoRiferimento.DisplayName, movimentoContabile.Testata.DataRegistrazione.GetValueOrDefault().ToShortDateString());
numeroRiga++;
var movimentoVersamento = new MovimentoContabile(testata, causale, numeroRiga, movimentoContabile.ContoRiferimento, movimentoContabile.Importo, movimentoContabile.Segno);
movimentoVersamento.CondominoRiferimento = movimentoContabile.CondominoRiferimento;
movimentoVersamento.Descrizione = descrizione;
numeroRiga++;
var movimentoContoTemporaneo = new MovimentoContabile(testata, causale, numeroRiga, contoVersamentiDopoChiusura, movimentoContabile.Importo, invertiSegno(movimentoContabile.Segno));
movimentoContoTemporaneo.CondominoRiferimento = movimentoContabile.CondominoRiferimento;
movimentoContoTemporaneo.Descrizione = descrizione;
// Nella stessa testata del versamento originale aggiungo il movimento di chiusura del conto temporaneo
var numeroRigaChiusura = movimentoContabile.Testata.Movimenti.Max(item => item.NumeroRiga) + 1;
var movimentoVersamentoChiusura = new MovimentoContabile(movimentoContabile.Testata, causale, numeroRigaChiusura, movimentoContabile.ContoRiferimento, movimentoContabile.Importo, invertiSegno(movimentoContabile.Segno));
movimentoVersamentoChiusura.CondominoRiferimento = movimentoContabile.CondominoRiferimento;
movimentoVersamentoChiusura.Descrizione = descrizione;
numeroRigaChiusura++;
var movimentoContoTemporaneoChiusura = new MovimentoContabile(movimentoContabile.Testata, causale, numeroRigaChiusura, contoVersamentiDopoChiusura, movimentoContabile.Importo, movimentoContabile.Segno);
movimentoContoTemporaneoChiusura.CondominoRiferimento = movimentoContabile.CondominoRiferimento;
movimentoContoTemporaneoChiusura.Descrizione = descrizione;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la registrazione dei movimenti per i versamenti eseguiti dopo la chiusura - SINGOLO MOVIMENTO - {0} - esercizio:{1} - movimento:{2}", ex, Utility.GetMethodDescription(), esercizioStraordinario.ID, movimentoContabile.ID);
throw;
}
}
}
return testata;
}
catch (Exception ex)
{
var idEsercizio = string.Empty;
if (esercizioStraordinario != null)
idEsercizio = esercizioStraordinario.ID.ToString();
_log.FatalFormat("Errore inaspettato durante la registrazione dei movimenti per i versamenti eseguiti dopo la chiusura - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), idEsercizio);
throw;
}
}
private void setMovimentoArrotondamento(decimal importoAvere, decimal importoDare, int numeroRiga, Spesa spesa, TestataMovimentoContabile testata, CausaleContabile causale, LogTransazione logTransazione)
{
if (importoAvere != importoDare)
{
var importoArrotondamento = importoAvere - importoDare;
numeroRiga++;
var segno = "D";
if (importoArrotondamento < 0)
{
segno = "A";
importoArrotondamento = importoArrotondamento * -1;
}
var contoArrotondamenti = _pianoContiService.GetContoArrotondamenti(testata.EsercizioRiferimento);
_daoFactory.GetContoDao().SaveOrUpdate(contoArrotondamenti);
var movimentoArrotondamento = new MovimentoContabile(testata, causale, numeroRiga, contoArrotondamenti, importoArrotondamento, segno)
{
Descrizione = spesa != null ? string.Format("Arrotondamento Fatt. n. {0} del {1:d}", spesa.NumeroDocumento, spesa.DataDocumento.GetValueOrDefault()) : string.Format("Arrotondamento per {0}", testata.GetDescrizione())
};
if(logTransazione == null)
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoArrotondamento);
}
}
private void setMovimentoArrotondamento(TestataMovimentoContabile testata, CausaleContabile causale, LogTransazione logTransazione)
{
var importoDare = 0m;
var importoAvere = 0m;
foreach (var movimento in testata.Movimenti)
{
if (movimento.Segno == "D")
importoDare += movimento.Importo.GetValueOrDefault();
else
importoAvere += movimento.Importo.GetValueOrDefault();
}
var differenza = importoAvere - importoDare;
if (differenza != 0)
{
var numeroRiga = testata.Movimenti.Max(item => item.NumeroRiga.GetValueOrDefault()) + 1;
setMovimentoArrotondamento(importoAvere, importoDare, numeroRiga, null, testata, causale, null);
}
}
public void SetMovimentoArrotondamento(Spesa spesa, TestataMovimentoContabile testata, CausaleContabile causale, LogTransazione logTransazione)
{
var importoTotale = testata.Movimenti.Where(item => item.Segno == "A").Sum(item => Math.Round(item.Importo.GetValueOrDefault(), 2, MidpointRounding.AwayFromZero));
var importoEconomico = testata.Movimenti.Where(item => item.Segno == "D").Sum(item => Math.Round(item.Importo.GetValueOrDefault(), 2, MidpointRounding.AwayFromZero));
var numeroRiga = testata.Movimenti.Max(item => item.NumeroRiga.GetValueOrDefault()) + 1;
setMovimentoArrotondamento(importoTotale, importoEconomico, numeroRiga, spesa, testata, causale, logTransazione);
}
public IList<MovimentoContabile> SetMovimentoBolletta(BollettaDTO bolletta, Spesa spesa, TestataMovimentoContabile testata, LogTransazione logTransazione, bool controlloDataRegistrazione)
{
try
{
IList<MovimentoContabile> movimentiEconomici = new List<MovimentoContabile>();
CausaleContabile causale;
if (spesa.Utenza != null && spesa.Utenza.RipartoLetture)
causale = _daoFactory.GetCausaleContabileDao().GetByCodice("IA");
else
causale = _daoFactory.GetCausaleContabileDao().GetByCodice("IF");
if (testata == null && spesa.TestateMovimenti.Count > 0)
{
testata = spesa.TestateMovimenti.FirstOrDefault();
if (testata != null)
{
testata.EsercizioRiferimento = spesa.EsercizioRiferimento;
testata.DataRegistrazione = bolletta.DataRegistrazione;
}
}
var dataRegistrazione = DateTime.Today;
if (bolletta.DataRegistrazione != null)
dataRegistrazione = bolletta.DataRegistrazione.GetValueOrDefault();
if (testata == null)
{
testata = new TestataMovimentoContabile(spesa.EsercizioRiferimento, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null) { SpesaRiferimento = spesa };
spesa.TestateMovimenti.Add(testata);
testata.IsAllowUpdate = false;
if(logTransazione == null)
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
else
testata.LogTransazione = logTransazione;
}
// controllo data registrazione
IList<string> message = new List<string>();
if(controlloDataRegistrazione)
message = IsAllowDataRegistrazione(new List<int> { spesa.EsercizioRiferimento.CondominioRiferimento.ID }, spesa.EsercizioRiferimento, testata.DataRegistrazione.GetValueOrDefault());
if (message.Count > 0)
{
var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", testata.DataRegistrazione.GetValueOrDefault()));
_log.ErrorFormat("Data di registrazione non valida - {0} - data:{1} - spesa:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), testata.DataRegistrazione.GetValueOrDefault(), spesa.ID, spesa.EsercizioRiferimento.ID);
throw ex;
}
testata.Descrizione = bolletta.Descrizione;
testata.DataRegistrazione = dataRegistrazione;
// -------------------------------------------
// Elimino movimenti cancellati
// -------------------------------------------
foreach (var mov in testata.Movimenti.Where(item => item.NumeroRiga > 1).ToList())
DeleteSingoloMovimento(mov);
// -------------------------------------------
// Movimenti Economici
// -------------------------------------------
var numeroRiga = 1;
var importoEconomico = 0m;
foreach (var movimentoDto in bolletta.Movimenti)
{
if (movimentoDto.IdConto != null)
{
var importo = Math.Round(movimentoDto.Importo.GetValueOrDefault(), 2);
importoEconomico += importo;
var segno = "D";
if (importo < 0)
{
segno = "A";
importo = importo * -1;
}
var movimento = _daoFactory.GetMovimentoContabileDao().Find(movimentoDto.ID, false);
numeroRiga++;
if (movimento != null)
{
movimento.ContoRiferimento = _daoFactory.GetContoDao().GetById(movimentoDto.IdConto.Value, false);
movimento.Segno = segno;
movimento.Importo = importo;
movimento.Causale = causale;
}
else
{
movimento = new MovimentoContabile(testata, spesa, causale, testata.Movimenti.Count + 1, _daoFactory.GetContoDao().GetById(movimentoDto.IdConto.Value, false), importo, segno);
if(logTransazione == null)
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimento);
}
movimento.IsMovimentoEconomico = true;
movimento.NumeroRiga = numeroRiga;
movimento.Descrizione = movimentoDto.Descrizione;
if (movimentoDto.IdSottoConto != null && movimentoDto.IdSottoConto > 0)
movimento.SottoContoRiferimento = _daoFactory.GetSottoContoDao().GetById(movimentoDto.IdSottoConto.Value, false);
movimentoDto.ID = movimento.ID;
movimentiEconomici.Add(movimento);
}
else
{
_log.ErrorFormat("Movimento senza conto associato - {0} - bolletta:{1}", Utility.GetMethodDescription(), bolletta.ID);
throw (new Exception("Movimento senza conto associato - " + Utility.GetMethodDescription() + " - idBolletta:" + bolletta.ID));
}
}
// ------------------------------------------------
// Debiti VS Fornitori
// ------------------------------------------------
var causalePatrimoniale = _daoFactory.GetCausaleContabileDao().GetByCodice("IF");
var importoTotale = spesa.ImportoBolletta.GetValueOrDefault();
var importoPatrimoniale = importoTotale;
var segnoPatrimoniale = "A";
if (importoTotale < 0)
{
segnoPatrimoniale = "D";
importoTotale = importoTotale * -1;
}
var movimentoPatrimoniale = (testata.Movimenti.Where(item => !item.IsMovimentoEconomico && !item.ContoRiferimento.IsArrotondamento)).FirstOrDefault();
if (movimentoPatrimoniale == null)
{
movimentoPatrimoniale = new MovimentoContabile(testata, spesa.FornitoreRiferimento, causalePatrimoniale, 1, _daoFactory.GetContoDao().GetByCodice(spesa.EsercizioRiferimento.ID, spesa.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoFornitori()), importoTotale, segnoPatrimoniale);
if(logTransazione == null)
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);
}
else
{
movimentoPatrimoniale.NumeroRiga = 1;
movimentoPatrimoniale.Importo = importoTotale;
movimentoPatrimoniale.Segno = segnoPatrimoniale;
}
movimentoPatrimoniale.Descrizione = $"Fatt. n. {spesa.NumeroDocumento} del {spesa.DataDocumento.GetValueOrDefault():d}";
// ------------------------------------------------
// Eventuale arrotondamento
// ------------------------------------------------
setMovimentoArrotondamento(importoPatrimoniale, importoEconomico, numeroRiga, spesa, testata, causale, logTransazione);
return movimentiEconomici;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella creazione del movimento di registrazione delle bollette - {0} - bolletta:{1}", ex, Utility.GetMethodDescription(), bolletta.ID);
throw;
}
}
public TestataMovimentoContabile SetMovimentoSpesaPersonale(Esercizio esercizio, TestataMovimentoContabile testata, SoggettoCondominio soggetto, Conto conto, string descrizione, decimal importo, DateTime dataRegistrazione)
{
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("IA");
if (testata == null)
{
testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null) {Descrizione = "Calcolo interessi di mora", IsAllowUpdate = true};
}
// controllo data registrazione
var message = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, testata.DataRegistrazione.GetValueOrDefault());
if (message.Count > 0)
{
var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", testata.DataRegistrazione.GetValueOrDefault()));
_log.FatalFormat("Data di registrazione non valida - {0} - data:{1} - soggetto:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), testata.DataRegistrazione.GetValueOrDefault(), soggetto.ID, esercizio.ID);
throw ex;
}
var movimento = new MovimentoContabile(testata, causale, testata.Movimenti.Count() + 1, conto, importo, "D") {Descrizione = descrizione};
switch (soggetto.Tipo)
{
case TipoSoggetto.Proprietario:
movimento.PercentualeProprieta = 1;
break;
case TipoSoggetto.Conduttore:
movimento.PercentualeProprieta = 0;
break;
}
movimento.IsRipartoPersonalizzato = true;
new SpeseUnita(importo, null, soggetto, movimento);
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
return testata;
}
public MovimentoContabile SetMovimentoBancarioGenerico(DatiBancariCondomini banca, Esercizio esercizioRiferimento, SottoConto sottoconto, decimal importo, string descrizione, DateTime dataRegistrazione, CausaleContabile causale)
{
try
{
var message = IsAllowDataRegistrazione(new List<int> { esercizioRiferimento.CondominioRiferimento.ID }, esercizioRiferimento, dataRegistrazione);
if (message.Count > 0)
{
var ex = new InvalidDataException($"La data di registrazione {dataRegistrazione} non è valida");
_log.FatalFormat("Data di registrazione non valida - {0} - data:{1} - esercizio:{2}", ex, Utility.GetMethodDescription(), dataRegistrazione, esercizioRiferimento.ID);
throw ex;
}
var testata = new TestataMovimentoContabile(esercizioRiferimento, dataRegistrazione, TipoTestataMovimentoContabileEnum.Manuale, null)
{
Descrizione = descrizione,
IsAbilitataArchiviazioneOttica = false,
IsAllowUpdate = true
};
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
// -------------------------------------------------
// Segno Movimento
// ------------------------------------------------
string segnoContoEconomico = "D";
if (importo > 0)
segnoContoEconomico = "A";
else
importo = importo * -1;
// ------------------------------------------------
// Conto economico
// ------------------------------------------------
var movimentoContoEconomico = new MovimentoContabile(testata, causale, 1, sottoconto, importo, segnoContoEconomico) {Descrizione = descrizione};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoContoEconomico);
_ripartizioneService.SalvaRipartizione(movimentoContoEconomico, esercizioRiferimento.CondominioRiferimento.ID);
// ------------------------------------------------
// BANCA
// ------------------------------------------------
var movimentoBancario = new MovimentoContabile(testata, causale, 2, _daoFactory.GetContoDao().GetByCodice(esercizioRiferimento.ID, esercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoBancario()), importo, invertiSegno(segnoContoEconomico))
{
Descrizione = descrizione,
Stato = StatoMovimentoContabileEnum.Evaso,
ContoCorrenteBancario = banca
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoBancario);
return movimentoBancario;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella contabilizzazione di un movimento bancario - {0} - importo:{1} - descrizione:{2} - data registrazione:{3:d}", ex, Utility.GetMethodDescription(), importo, descrizione, dataRegistrazione);
throw;
}
}
public TestataMovimentoContabile ChiusuraContiPatrimoniali(Esercizio esercizio)
{
try
{
var testata = new TestataMovimentoContabile(esercizio, esercizio.DataChiusura, TipoTestataMovimentoContabileEnum.Automatica, null) {AperturaChiusuraConti = true};
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("OC");
var contoTransitorio = _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, "998");
// =======================================================================================
// Registro tutti movimenti di chiusura dei conti
// =======================================================================================
var index = 0;
foreach (var conto in esercizio.CondominioRiferimento.Conti)
{
if (conto.Tipo == TipoContoEconomicoEnum.Patrimoniale && conto.Codice != _pianoContiService.GetCodiceContoRateCondomini() && conto.Codice != "910")
{
try
{
// ================
// Conto Fornitori
// ================
if (conto.Codice == _pianoContiService.GetCodiceContoFornitori())
{
var saldi = getSaldoContoFornitori(esercizio.ID, conto.ID);
_log.DebugFormat("Chiusura conti - CONTO FORNITORI - {0} - esercizio:{1} - count:{2} - importo:{3}", Utility.GetMethodDescription(), esercizio.ID, saldi.Count, saldi.Sum(item => item.Value));
foreach (var kvp in saldi)
{
try
{
if (kvp.Value != 0)
{
var saldo = kvp.Value;
// ---------------------------------------------------------------------------------------
// Movimento di chiusura
// ---------------------------------------------------------------------------------------
_log.DebugFormat("Chiusura conti - SINGOLO FORNITORE - {0} - fornitore:{1} {2} - esercizio:{3} - importo:{4}", Utility.GetMethodDescription(), kvp.Key.ID, kvp.Key.DisplayName, esercizio.ID, saldo);
index++;
var segno = "D";
if (saldo < 0)
{
segno = "A";
saldo = saldo * -1;
}
new MovimentoContabile(testata, kvp.Key, causale, index, conto, saldo, segno)
{
FornitoreRiferimento = kvp.Key,
Descrizione = string.Format("Chiusura conto '{0} {1}' - {2} Esercizio '{3}'", conto.Codice, conto.Descrizione, kvp.Key.DisplayName, esercizio.DisplayName),
Stato = StatoMovimentoContabileEnum.Evaso
};
// ---------------------------------------------------------------------------------------
// Registro la contropartita in un conto transitorio
// ---------------------------------------------------------------------------------------
var saldoContropartita = kvp.Value;
index++;
segno = "A";
if (saldoContropartita < 0)
{
segno = "D";
saldoContropartita = saldoContropartita * -1;
}
index++;
new MovimentoContabile(testata, causale, index, contoTransitorio, saldoContropartita, segno)
{
FornitoreRiferimento = kvp.Key,
Stato = StatoMovimentoContabileEnum.Evaso,
Descrizione = string.Format("Chiusura di bilancio - conto '{0} {1}' - {2} Esercizio '{3}'", conto.Codice, conto.Descrizione, kvp.Key.DisplayName, esercizio.DisplayName)
};
}
}
catch (Exception ex)
{
_log.FatalFormat("Errore inaspettato durante la chiusura dei conti patrimoniali - (SINGOLO FORNITORE) - {0} - fornitore:{1} - conto:{2} {3} - esercizio:{4}", ex, Utility.GetMethodDescription(), kvp.Key.ID, conto.ID, conto.Descrizione, esercizio.ID);
throw;
}
}
}
// ================
// Conto Banca
// ================
else if (conto.Codice == _pianoContiService.GetCodiceContoBancario())
{
var saldi = getSaldoContoBanca(esercizio.ID, conto.ID);
_log.DebugFormat("Chiusura conti - CONTO BANCA - {0} - esercizio:{1} - count:{2} - importo:{3}", Utility.GetMethodDescription(), esercizio.ID, saldi.Count, saldi.Sum(item => item.Value));
foreach (var kvp in saldi)
{
try
{
if (kvp.Value != 0)
{
var saldo = kvp.Value;
// ---------------------------------------------------------------------------------------
// Movimento di chiusura
// ---------------------------------------------------------------------------------------
_log.DebugFormat("Chiusura conti - SINGOLO FORNITORE - {0} - contoCorrente:{1} {2} - esercizio:{3} - importo:{4}", Utility.GetMethodDescription(), kvp.Key.ID, kvp.Key.DisplayName, esercizio.ID, saldo);
index++;
var segno = "D";
if (saldo < 0)
{
segno = "A";
saldo = saldo * -1;
}
new MovimentoContabile(testata, causale, index, conto, saldo, segno)
{
ContoCorrenteBancario = kvp.Key,
Descrizione = string.Format("Chiusura conto '{0} {1}' - {2} Esercizio '{3}'", conto.Codice, conto.Descrizione, kvp.Key.DisplayName, esercizio.DisplayName),
Stato = StatoMovimentoContabileEnum.Evaso
};
// ---------------------------------------------------------------------------------------
// Registro la contropartita in un conto transitorio
// ---------------------------------------------------------------------------------------
var saldoContropartita = kvp.Value;
index++;
segno = "A";
if (saldoContropartita < 0)
{
segno = "D";
saldoContropartita = saldoContropartita * -1;
}
index++;
new MovimentoContabile(testata, causale, index, contoTransitorio, saldoContropartita, segno)
{
ContoCorrenteBancario = kvp.Key,
Stato = StatoMovimentoContabileEnum.Evaso,
Descrizione = string.Format("Chiusura di bilancio - conto '{0} {1}' - {2} Esercizio '{3}'", conto.Codice, conto.Descrizione, kvp.Key.DisplayName, esercizio.DisplayName)
};
}
}
catch (Exception ex)
{
_log.FatalFormat("Errore inaspettato durante la chiusura dei conti patrimoniali - (SINGOLO FORNITORE) - {0} - contoCorrente:{1} - conto:{2} {3} - esercizio:{4}", ex, Utility.GetMethodDescription(), kvp.Key.ID, conto.ID, conto.Descrizione, esercizio.ID);
throw;
}
}
}
// ================
// Conto Condomini
// ================
else if (conto.Codice == _pianoContiService.GetCodiceContoRateCondomini() || conto.Codice == _pianoContiService.GetCodiceContoVersamentiCondomini())
{
var saldi = getSaldoContoCondomini(esercizio.ID, conto.ID);
_log.DebugFormat("Chiusura conti - CONTO CONDOMINI - {0} - esercizio:{1} - count:{2} - importo:{3}", Utility.GetMethodDescription(), esercizio.ID, saldi.Count, saldi.Sum(item => item.Value));
foreach (var kvp in saldi)
{
try
{
if (kvp.Value != 0)
{
var saldo = kvp.Value;
// ---------------------------------------------------------------------------------------
// Movimento di chiusura
// ---------------------------------------------------------------------------------------
SoggettoCondominio soggettoCondominio = null;
var nomeCondomino = string.Empty;
if (kvp.Key > 0)
{
soggettoCondominio = _daoFactory.GetSoggettoCondominioDao().GetById(kvp.Key, false);
nomeCondomino = soggettoCondominio.DisplayName;
}
_log.DebugFormat("Chiusura conti - SINGOLO CONDOMINO - {0} - condomino:{1} {2} - esercizio:{3} - importo:{4}", Utility.GetMethodDescription(), kvp, nomeCondomino, esercizio.ID, saldo);
var segno = "D";
if (saldo < 0)
{
segno = "A";
saldo = saldo * -1;
}
index++;
new MovimentoContabile(testata, causale, index, conto, saldo, segno)
{
CondominoRiferimento = soggettoCondominio,
Stato = StatoMovimentoContabileEnum.Evaso,
Descrizione = string.Format("Chiusura conto '{0} {1}' - {2} Esercizio '{3}'", conto.Codice, conto.Descrizione, nomeCondomino, conto.EsercizioRiferimento == null ? esercizio.DisplayName : conto.EsercizioRiferimento.DisplayName),
};
// ---------------------------------------------------------------------------------------
// Registro la contropartita in un conto transitorio
// ---------------------------------------------------------------------------------------
var saldoContropartita = kvp.Value;
index++;
segno = "A";
if (saldoContropartita < 0)
{
segno = "D";
saldoContropartita = saldoContropartita * -1;
}
index++;
new MovimentoContabile(testata, causale, index, contoTransitorio, saldoContropartita, segno)
{
CondominoRiferimento = soggettoCondominio,
Stato = StatoMovimentoContabileEnum.Evaso,
Descrizione = string.Format("Chiusura di bilancio - conto '{0} {1}' - {2} Esercizio '{3}'", conto.Codice, conto.Descrizione, nomeCondomino, esercizio.DisplayName)
};
}
}
catch (Exception ex)
{
_log.FatalFormat("Errore inaspettato durante la chiusura dei conti patrimoniali - (SINGOLO CONDOMINO) - {0} - condomino:{1} - conto:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), kvp.Key, conto.Descrizione, esercizio.ID);
throw;
}
}
}
else
{
// ================
// Altri Conti
// ================
var idConti = new List<int> { conto.ID };
var movimenti = GetMovimentiByContiData(esercizio.CondominioRiferimento.ID, esercizio.DataApertura.GetValueOrDefault(), esercizio.DataChiusura.GetValueOrDefault(), idConti);
var movimentiPerSottoconto = movimenti.GroupBy(item => item.SottoContoRiferimento);
foreach (var sottoconto in movimentiPerSottoconto)
{
var saldo = sottoconto.Sum(item => item.GetImportoConSegno(false, true).GetValueOrDefault());
var saldoContropartita = saldo;
if (saldo != 0)
{
// ---------------------------------------------------------------------------------------
// Movimento di chiusura
// ---------------------------------------------------------------------------------------
var idSottoconto = "<NULL>";
var descrizioneSottoconto = "<NULL>";
if (sottoconto.Key != null)
{
idSottoconto = sottoconto.Key.ID.ToString();
descrizioneSottoconto = sottoconto.Key.Descrizione;
}
_log.DebugFormat("Chiusura conti - SINGOLO SOTTOCONTO - {0} - sottconto:{1} {2} - esercizio:{3} - importo:{4}", Utility.GetMethodDescription(), idSottoconto, descrizioneSottoconto, esercizio.ID, saldo);
index++;
var segno = "D";
if (saldo < 0)
{
segno = "A";
saldo = saldo * -1;
}
new MovimentoContabile(testata, causale, index, conto, saldo, segno)
{
SottoContoRiferimento = sottoconto.Key,
Descrizione = sottoconto.Key != null ? string.Format("Chiusura conto '{0} {1}' - {2} Esercizio '{3}'", conto.Codice, conto.Descrizione, sottoconto.Key.Descrizione, esercizio.DisplayName) : string.Format("Chiusura conto {0} - Esercizio '{1}'", conto.Descrizione, esercizio.DisplayName),
Stato = StatoMovimentoContabileEnum.Evaso
};
// ---------------------------------------------------------------------------------------
// Registro la contropartita in un conto transitorio
// ---------------------------------------------------------------------------------------
index++;
segno = "A";
if (saldoContropartita < 0)
{
segno = "D";
saldoContropartita = saldoContropartita * -1;
}
index++;
new MovimentoContabile(testata, causale, index, contoTransitorio, saldoContropartita, segno)
{
SottoContoRiferimento = sottoconto.Key,
Stato = StatoMovimentoContabileEnum.Evaso,
Descrizione = sottoconto.Key != null ? string.Format("Chiusura di bilancio '{0} {1}' - {2} Esercizio '{3}'", conto.Codice, conto.Descrizione, sottoconto.Key.Descrizione, esercizio.DisplayName) : string.Format("Chiusura di bilancio {0} - Esercizio '{1}'", conto.Descrizione, esercizio.DisplayName),
};
}
}
}
}
catch (Exception ex)
{
_log.FatalFormat("Errore inaspettato durante la chiusura dei conti patrimoniali - (SINGOLO CONTO) - {0} - conto:{1} {2} - esercizio:{3}", ex, Utility.GetMethodDescription(), conto.ID, conto.Descrizione, esercizio.ID);
throw;
}
}
}
// Solo se sono presenti movimenti
if (testata.Movimenti.Count > 0)
{
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
return testata;
}
return null;
}
catch (Exception ex)
{
_log.FatalFormat("Errore inaspettato durante la chiusura dei conti patrimoniali - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), esercizio.ID);
throw;
}
}
public string AperturaContiPatrimoniali(Esercizio esercizio)
{
try
{
var message = string.Empty;
if (esercizio.GetEsercizioPrecedente() != null)
{
var testata = new TestataMovimentoContabile(esercizio, esercizio.DataApertura, TipoTestataMovimentoContabileEnum.Automatica, null) { AperturaChiusuraConti = true };
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("AC");
var contoTransitorio = _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, "999");
// ---------------------------------------------------------------------------------------
// Registro tutti movimenti di apertura dei conti
// ---------------------------------------------------------------------------------------
var index = 0;
var testate = _daoFactory.GetTestataMovimentoContabileDao().GetTestateMovimentiByEsercizioCausale(esercizio.GetEsercizioPrecedente(), _daoFactory.GetCausaleContabileDao().GetByCodice("OC")).Where(item => item.AperturaChiusuraConti).ToList();
if (testate.Count > 1)
{
_log.ErrorFormat("ATTENZIONE: Trovata più di una testata con causale di chiusura 'OC' nell'esercizio - {0} - esercizio:{1}", Utility.GetMethodDescription(), esercizio.ID);
return string.Format("Trovata più di una testata di chiusura nell'esercizio: '{0}'", esercizio.DisplayName);
}
else if(testate.Count == 0)
{
_log.ErrorFormat("ATTENZIONE: Non è stata trovata nessuna causale di chiusura 'OC' nell'esercizio - {0} - esercizio:{1}", Utility.GetMethodDescription(), esercizio.ID);
return string.Format("Non è stata trovata nessuna testata di chiusura nell'esercizio: '{0}'", esercizio.DisplayName);
}
else
{
foreach (var movimento in testate[0].Movimenti)
{
var importo = movimento.GetImportoSenzaSegno();
index++;
if (movimento.ContoRiferimento.Codice != "998")
{
new MovimentoContabile(testata, causale, index, movimento.ContoRiferimento, importo, invertiSegno(movimento.Segno))
{
Descrizione = movimento.Descrizione.Replace("Chiusura", "Apertura"),
Stato = StatoMovimentoContabileEnum.Evaso,
FornitoreRiferimento = movimento.FornitoreRiferimento,
CondominoRiferimento = movimento.CondominoRiferimento,
ContoCorrenteBancario = movimento.ContoCorrenteBancario,
SottoContoRiferimento = movimento.SottoContoRiferimento
};
}
else
{
new MovimentoContabile(testata, causale, index, contoTransitorio, importo, invertiSegno(movimento.Segno))
{
Descrizione = movimento.Descrizione.Replace("Chiusura", "Apertura"),
Stato = StatoMovimentoContabileEnum.Evaso,
FornitoreRiferimento = movimento.FornitoreRiferimento,
CondominoRiferimento = movimento.CondominoRiferimento,
ContoCorrenteBancario = movimento.ContoCorrenteBancario,
SottoContoRiferimento = movimento.SottoContoRiferimento
};
}
}
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
}
}
return message;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante l'apertura dei conti patrimoniali - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), esercizio.ID);
throw;
}
}
public TestataMovimentoContabile SetMovimentiRiscaldamentoAcqua(Esercizio esercizio, int idContoAcquaRiscaldata, int idContoRiscaldamento, string descrizioneMovimentoAcqua, string descrizioneMovimentoRiscaldamento, IList<ImportiDTO> importiRiscaldamento, DateTime dataRegistrazione, bool checkDataRegistrazione)
{
// controllo data registrazione
if (checkDataRegistrazione)
{
var message = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
if (message.Count > 0)
{
var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", dataRegistrazione));
_log.Fatal("Data di registrazione non valida - " + Utility.GetMethodDescription() + " - data:" + dataRegistrazione + " - IdEsercizio:" + esercizio.ID, ex);
throw ex;
}
}
var testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null)
{
Descrizione = descrizioneMovimentoAcqua,
IsAbilitataArchiviazioneOttica = false,
IsAllowUpdate = true
};
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("SC");
// -------------------------------------------------
// Calcolo Importo
// ------------------------------------------------
var importo = importiRiscaldamento.Sum(item => item.Importo);
// -------------------------------------------------
// Segno Movimento
// ------------------------------------------------
var segnoContoEconomico = "D";
if (importo < 0)
{
segnoContoEconomico = "A";
importo = importo * -1;
}
// ------------------------------------------------
// Conto economico da addebitare
// ------------------------------------------------
var contoEconomico = _daoFactory.GetContoDao().GetById(idContoAcquaRiscaldata, false);
var movimentoContoEconomicoAddebito = new MovimentoContabile(testata, causale, 1, contoEconomico, importo, segnoContoEconomico)
{
Descrizione = descrizioneMovimentoAcqua,
IsRipartoPersonalizzato = true,
RipartoTramiteLetture = true
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoContoEconomicoAddebito);
_ripartizioneService.SalvaRipartizione(movimentoContoEconomicoAddebito, importiRiscaldamento, false);
// ------------------------------------------------
// Conto economico da accreditare
// ------------------------------------------------
var movimentoContoEconomicoAccredito = new MovimentoContabile(testata, causale, 2, _daoFactory.GetContoDao().GetById(idContoRiscaldamento, false), importo, invertiSegno(segnoContoEconomico)) {Descrizione = descrizioneMovimentoRiscaldamento};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoContoEconomicoAccredito);
return testata;
}
public TestataResult SetBilancioApertura(TestataMovimentoContabileGestioneDTO testataDto)
{
try
{
if(testataDto.DataRegistrazione == null)
throw new InvalidDataException("Non è definita la data di registrazione");
var message = string.Empty;
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("AB");
var numeroRiga = 0;
var esercizio = _daoFactory.GetEsercizioDao().GetById(testataDto.CodiceEsercizio, false);
var saldiCondomini = _daoFactory.GetSaldoSoggettoDao().GetByEsercizioStabileScala(esercizio, null, null);
// Controllo correttezza importi
TestataMovimentoContabile testata = null;
if (testataDto.Movimenti.Sum(mov => mov.ImportoDare.GetValueOrDefault()) != testataDto.Movimenti.Sum(mov => mov.ImportoAvere.GetValueOrDefault()))
message = "Il totale Dare:" + testataDto.Movimenti.Sum(mov => mov.ImportoDare.GetValueOrDefault()).ToString("c") + " non corrisponde col totale Avere:" + testataDto.Movimenti.Sum(mov => mov.ImportoAvere.GetValueOrDefault()).ToString("c") + Environment.NewLine;
else if (testataDto.DataRegistrazione == null)
message = "Deve essere definita la data di registrazione" + Environment.NewLine;
else
{
foreach (var movimentoDto in testataDto.Movimenti)
{
if (movimentoDto.Stato == "U")
{
var conto = _daoFactory.GetContoDao().GetById(movimentoDto.IdConto.GetValueOrDefault(), false);
if (conto.Codice == _pianoContiService.GetCodiceContoVersamentiCondomini() && saldiCondomini.Count == 0)
{
message = "Prima di registrare il bilancio di apertura occorre inserire i saldi iniziali dei condomini" + Environment.NewLine;
break;
}
}
}
}
if(string.IsNullOrEmpty(message))
{
// controllo data registrazione
var messageData = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, testataDto.DataRegistrazione.GetValueOrDefault());
if (messageData.Count > 0)
{
_log.WarnFormat("Data di registrazione non valida - {0} - data:{1} - esercizio:{2}", Utility.GetMethodDescription(), testataDto.DataRegistrazione.GetValueOrDefault(), esercizio.ID);
return new TestataResult(null, messageData.Aggregate(message, (current, mess) => current + (mess + Environment.NewLine)));
}
const string hql = "FROM Esercizio ES WHERE ES.CondominioRiferimento = :condominio AND ES.DataApertura >= :data AND ES.DataChiusura <= :data AND ES.Gestione = :gestione";
var listaEsercizi = _daoFactory.GetEsercizioDao().GetByQuery(hql, new[] { new QueryParam("condominio", esercizio.CondominioRiferimento), new QueryParam("data", testataDto.DataRegistrazione.Value), new QueryParam("gestione", Conversione.ToHQLParameter(GestioneEsercizioEnum.Ordinario)) });
if (listaEsercizi.Count == 1)
esercizio = listaEsercizi[0];
testata = _daoFactory.GetTestataMovimentoContabileDao().Find(testataDto.ID, false);
if (testata == null)
{
testata = new TestataMovimentoContabile(esercizio, testataDto.DataRegistrazione.Value, TipoTestataMovimentoContabileEnum.Automatica, null) {AperturaBilancio = true};
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
}
else
{
testata.EsercizioRiferimento = esercizio;
testata.DataRegistrazione = testataDto.DataRegistrazione.Value;
}
testata.Descrizione = testataDto.Descrizione;
foreach (var movimentoDto in testataDto.Movimenti)
{
if (movimentoDto.Stato == "U")
{
var conto = _daoFactory.GetContoDao().GetById(movimentoDto.IdConto.GetValueOrDefault(), false);
string segno;
decimal importo;
if (movimentoDto.ImportoAvere > 0)
{
importo = movimentoDto.ImportoAvere.GetValueOrDefault();
segno = "A";
}
else
{
importo = movimentoDto.ImportoDare.GetValueOrDefault();
segno = "D";
}
// =========================================================================================
// Per il conto versamenti SOLO ESERCIZIO ORDINARIO spalmo l'importo in base ai versamenti dei singoli condomini
// Elimino tutti i movimenti presenti
// =========================================================================================
MovimentoContabile movimento = null;
if (conto.Codice == _pianoContiService.GetCodiceContoVersamentiCondomini() && conto.EsercizioRiferimento == null)
{
// elimino i movimenti
var movimentiOld = testata.Movimenti.Where(item => item.ContoRiferimento.Codice == _pianoContiService.GetCodiceContoVersamentiCondomini()).ToList();
bool deleteOriginalMovimento = movimentoDto.ID > 0;
foreach (var movimentoContabile in movimentiOld)
{
if (movimentoContabile.ID == movimentoDto.ID)
deleteOriginalMovimento = false;
DeleteSingoloMovimento(movimentoContabile);
}
if(deleteOriginalMovimento)
DeleteSingoloMovimento(_daoFactory.GetMovimentoContabileDao().Find(movimentoDto.ID, false));
// creo i nuovi movimenti
foreach (var saldoSoggetto in saldiCondomini)
{
var importoCondomino = saldoSoggetto.Importo;
segno = "D";
if (importoCondomino < 0)
{
segno = "A";
importoCondomino = importoCondomino*-1;
}
numeroRiga++;
movimento = new MovimentoContabile(testata, causale, numeroRiga, conto, importoCondomino, segno) {Descrizione = movimentoDto.Descrizione};
if (string.IsNullOrEmpty(movimento.Descrizione))
movimento.Descrizione = string.Format("Apertura Conto {0}", saldoSoggetto.Soggetto.DisplayName);
movimento.CondominoRiferimento = saldoSoggetto.Soggetto;
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimento);
testata.Movimenti.Add(movimento);
}
}
else
{
movimento = _daoFactory.GetMovimentoContabileDao().Find(movimentoDto.ID, false);
if (movimento == null)
{
numeroRiga++;
movimento = new MovimentoContabile(testata, causale, numeroRiga, conto, importo, segno) {Descrizione = movimentoDto.Descrizione};
if (string.IsNullOrEmpty(movimento.Descrizione))
movimento.Descrizione = "Apertura Conto";
if (movimentoDto.IdFornitore != null && movimentoDto.IdFornitore.GetValueOrDefault() > 0)
movimento.FornitoreRiferimento = _daoFactory.GetFornitoreDao().GetById(movimentoDto.IdFornitore.Value, false);
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimento);
testata.Movimenti.Add(movimento);
}
else
{
numeroRiga++;
movimento.Segno = segno;
movimento.Importo = importo;
movimento.ContoRiferimento = conto;
movimento.NumeroRiga = numeroRiga;
movimento.Descrizione = movimentoDto.Descrizione;
if (movimentoDto.IdFornitore != null && movimentoDto.IdFornitore.GetValueOrDefault() > 0)
movimento.FornitoreRiferimento = _daoFactory.GetFornitoreDao().GetById(movimentoDto.IdFornitore.Value, false);
testata.Movimenti.Add(movimento);
}
}
if (movimento != null)
{
movimentoDto.IdMovimentoRiferimento = movimento.ID;
if (movimentoDto.IdSpesa > 0)
movimento.Spesa = _daoFactory.GetSpesaDao().GetById(movimentoDto.IdSpesa, false);
if (movimentoDto.IdSottoConto != null)
{
if (movimentoDto.IdSottoConto > 0)
{
if (movimento.ContoRiferimento.Codice != _pianoContiService.GetCodiceContoFornitori() && movimento.ContoRiferimento.Codice != _pianoContiService.GetCodiceContoRitenuta() && movimento.ContoRiferimento.Codice != _pianoContiService.GetCodiceContoVersamentiCondomini() && movimento.ContoRiferimento.Codice != _pianoContiService.GetCodiceContoRateCondomini())
{
var sottoConto = _daoFactory.GetSottoContoDao().GetById(movimentoDto.IdSottoConto.Value, false);
movimento.SottoContoRiferimento = sottoConto;
}
}
else
{
try
{
if (movimento.ContoRiferimento != null && !string.IsNullOrEmpty(movimento.ContoRiferimento.Codice))
{
if (movimento.ContoRiferimento.Codice == _pianoContiService.GetCodiceContoBancario())
{
var banca = _daoFactory.GetDatiBancariCondominiDao().Find(movimentoDto.IdSottoConto.Value * -1, false);
if (banca != null)
movimento.ContoCorrenteBancario = banca;
}
else if (movimento.ContoRiferimento.Codice == _pianoContiService.GetCodiceContoVersamentiCondomini())
{
var soggettoCondominio = _daoFactory.GetSoggettoCondominioDao().Find(movimentoDto.IdSottoConto.Value*-1, false);
if (soggettoCondominio != null)
movimento.CondominoRiferimento = soggettoCondominio;
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore imprevisto - CONTO CORRENTE - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), esercizio.ID);
}
}
}
}
}
}
}
return new TestataResult(testata, message);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante l'aggiornamento della quadratura iniziale dei contabili - {0}", ex, Utility.GetMethodDescription());
throw;
}
}
public TestataMovimentoContabile SetMovimentiContatoreCondominiale(Esercizio esercizio, IList<ImportoMovimento> importiAccredito, IList<ImportiDTO> addebitiContatoriDivisionali, DateTime dataRegistrazione, Conto contoAddebito, SottoConto sottoContoAddebito, string descrizione)
{
// controllo data registrazione
var message = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
if (message.Count > 0)
{
var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", dataRegistrazione));
_log.FatalFormat("Data di registrazione non valida - {0} - data:{1} - esercizio:{2}", ex, Utility.GetMethodDescription(), dataRegistrazione, esercizio.ID);
throw ex;
}
var testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null)
{
Descrizione = descrizione,
IsAbilitataArchiviazioneOttica = false,
IsAllowUpdate = true
};
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("SC");
// -------------------------------------------------
// Calcolo Importo
// ------------------------------------------------
var importo = importiAccredito.Sum(item => item.Importo);
// -------------------------------------------------
// Segno Movimento
// ------------------------------------------------
var segnoContoEconomico = "D";
if (importo < 0)
{
segnoContoEconomico = "A";
importo = importo * -1;
}
// ------------------------------------------------
// Conto economico da addebitare
// ------------------------------------------------
var movimentoContoEconomicoAddebito = new MovimentoContabile(testata, causale, 1, contoAddebito, importo, segnoContoEconomico)
{
SottoContoRiferimento = sottoContoAddebito,
Descrizione = descrizione,
IsRipartoPersonalizzato = true
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoContoEconomicoAddebito);
// ------------------------------------------------
// Conto economico da accreditare
// ------------------------------------------------
foreach (var item in importiAccredito)
{
var movimentoContoEconomicoAccredito = new MovimentoContabile(testata, causale, 2, _daoFactory.GetContoDao().GetById(item.IdConto, false), item.Importo, invertiSegno(segnoContoEconomico)) { Descrizione = descrizione, IsRipartoPersonalizzato = true };
if(item.IdSottoConto > 0)
movimentoContoEconomicoAccredito.SottoContoRiferimento = _daoFactory.GetSottoContoDao().GetById(item.IdSottoConto.GetValueOrDefault(), false);
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoContoEconomicoAccredito);
// Ripartizione tra le unità immobiliari
var totaleMillesimi = addebitiContatoriDivisionali.Sum(mill => mill.Importo);
foreach (var importiDTO in addebitiContatoriDivisionali)
{
var unita = _daoFactory.GetUnitaImmobiliareDao().GetById(importiDTO.Id, false);
var importoUnita = (movimentoContoEconomicoAccredito.GetImportoConSegno() * importiDTO.Importo) / totaleMillesimi;
var spesaUnita = new SpeseUnita(importoUnita, unita, null, movimentoContoEconomicoAccredito);
_daoFactory.GetSpeseUnitaDao().SaveOrUpdate(spesaUnita);
}
}
return testata;
}
public void DeleteTestata(TestataMovimentoContabile testata)
{
// --------------------------------------------------------------------
// Aggiunto codice per rimuovere tutti i riferimenti bugid#4143
// --------------------------------------------------------------------
var movimenti = testata.Movimenti.ToList();
foreach (var movimentoContabile in movimenti)
{
movimentoContabile.Testata = null;
testata.Movimenti.Remove(movimentoContabile);
if (movimentoContabile.ContoRiferimento != null)
{
movimentoContabile.ContoRiferimento.Movimenti.Remove(movimentoContabile);
movimentoContabile.ContoRiferimento = null;
}
if (movimentoContabile.FornitoreRiferimento != null)
{
movimentoContabile.FornitoreRiferimento.MovimentiContabili.Remove(movimentoContabile);
movimentoContabile.FornitoreRiferimento = null;
}
if (movimentoContabile.CondominoRiferimento != null)
{
movimentoContabile.CondominoRiferimento.Movimenti.Remove(movimentoContabile);
movimentoContabile.CondominoRiferimento = null;
}
if (movimentoContabile.ContoCorrenteBancario != null)
{
movimentoContabile.ContoCorrenteBancario.MovimentiContabili.Remove(movimentoContabile);
movimentoContabile.ContoCorrenteBancario = null;
}
if (movimentoContabile.EvasioneBancaria != null)
{
movimentoContabile.EvasioneBancaria.MovimentiContabili.Remove(movimentoContabile);
movimentoContabile.EvasioneBancaria = null;
}
}
testata.Movimenti.Clear();
_daoFactory.GetTestataMovimentoContabileDao().Delete(testata);
// --------------------------------------------------------------------
}
public string SetMovimentoAccreditoInteressiMora(Esercizio esercizio, TestataMovimentoContabile testata, Conto conto, string descrizione, decimal importo, DateTime dataRegistrazione)
{
try
{
var message = string.Empty;
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("RI");
if (testata == null)
testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null) {IsAllowUpdate = true};
// controllo data registrazione
var messageData = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, testata.DataRegistrazione.GetValueOrDefault());
if (messageData.Count > 0)
{
var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", testata.DataRegistrazione.GetValueOrDefault()));
_log.ErrorFormat("Data di registrazione non valida - {0} - data:{1} - conto:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), testata.DataRegistrazione.GetValueOrDefault(), conto.ID, esercizio.ID);
throw ex;
}
var movimento = new MovimentoContabile(testata, causale, testata.Movimenti.Count() + 1, conto, importo, "A") {Descrizione = descrizione};
_ripartizioneService.ReloadRipartizioneByMovimento(movimento);
return message;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella creazione del movimento di accredito per interessi di mora - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), esercizio.ID);
throw;
}
}
private decimal getImportoSquadrato(TestataMovimentoContabile testata, bool escludiArrotonadamento = false)
{
var importo = 0m;
foreach (var movimento in testata.Movimenti)
{
if(escludiArrotonadamento && movimento.ContoRiferimento.IsArrotondamento)
continue;
if (movimento.Segno == "D")
importo -= movimento.Importo.GetValueOrDefault();
else
importo += movimento.Importo.GetValueOrDefault();
}
return importo;
}
public TestataMovimentoContabile SetMovimentiSollecito(Esercizio esercizio, IList<Sollecito> solleciti, DateTime dataRegistrazione, Conto conto, SottoConto sottoconto)
{
try
{
// controllo data registrazione
var message = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
if (message.Count > 0)
{
var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", dataRegistrazione));
_log.FatalFormat("Data di registrazione non valida - {0} - data:{1} - conto:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), dataRegistrazione, conto.ID, esercizio.ID);
throw ex;
}
var testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null)
{
Descrizione = "Addebito solleciti del " + dataRegistrazione.ToShortDateString(),
IsAllowUpdate = true
};
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("IA");
var numeroRiga = 0;
// Contropartita
numeroRiga++;
var contoContropartita = _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, "913");
new MovimentoContabile(testata, causale, numeroRiga, contoContropartita, solleciti.Sum(item => item.ImportoCompetenza.GetValueOrDefault()), "A");
foreach (var soll in solleciti)
{
numeroRiga++;
var movimento = new MovimentoContabile(testata, causale, numeroRiga, conto, soll.ImportoCompetenza, "D") {SottoContoRiferimento = sottoconto};
if (soll.Soggetto != null)
movimento.CondominoRiferimento = soll.Soggetto;
soll.MovimentoEconomico = movimento;
movimento.IsRipartoPersonalizzato = true;
var soggetto = soll.Soggetto ?? soll.Persona.SoggettiCondominio.FirstOrDefault(item => item.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.CondominioRiferimento.ID == soll.Esercizio.CondominioRiferimento.ID);
if (soggetto != null)
{
movimento.CondominoRiferimento = soggetto;
switch (soggetto.Tipo)
{
case TipoSoggetto.Proprietario:
movimento.PercentualeProprieta = 1;
break;
case TipoSoggetto.Conduttore:
movimento.PercentualeProprieta = 0;
break;
}
new SpeseUnita(soll.ImportoCompetenza, null, soggetto, movimento);
}
}
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
return testata;
}
catch (Exception ex)
{
_log.Fatal("Errore inaspettato nella creazione del movimento di addebito competenze per sollecito - " + Utility.GetMethodDescription() + " - IdEsercizio:" + esercizio.ID.ToString(), ex);
throw;
}
}
public void SetMovimentiPagamenti(Disposizione disposizione, string tipoConto, LogTransazione logTransazione)
{
try
{
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("PF");
var lista = new Dictionary<Esercizio, TestataMovimentoContabile>(disposizione.Pagamenti.Count);
foreach (var pag in disposizione.Pagamenti)
{
try
{
var numeroRiga = 0;
var esercizioRiferimento = getEsercizioCompetenza(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento, pag.Data.GetValueOrDefault());
if (esercizioRiferimento == null)
{
var ex = new InvalidDataException(string.Format("Non trovato nessun esercizio attivo"));
_log.FatalFormat("Non trovato nessun esercizio attivo - {0} - condominio:{1} - disposizione:{2} - tipoConto:{3}", ex, Utility.GetMethodDescription(), pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, disposizione.ID, tipoConto);
throw ex;
}
var message = IsAllowDataRegistrazione(new List<int> { esercizioRiferimento.CondominioRiferimento.ID }, esercizioRiferimento, pag.Data.GetValueOrDefault());
if (message.Count == 0)
{
// ================================================
// Testata
// ================================================
TestataMovimentoContabile testata;
if (lista.ContainsKey(esercizioRiferimento))
testata = lista[esercizioRiferimento];
else
{
testata = new TestataMovimentoContabile(esercizioRiferimento, pag.Data, TipoTestataMovimentoContabileEnum.Automatica, logTransazione);
if(logTransazione == null)
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
// Per ora ritengo opportuno avere una testata di movimento contabile distinta per ogni pagamento.
// Per avere un testata che accorpi diversi pagamenti è sufficiente scommentare la riga successiva.
//lista.Add(esercizioRiferimento, testata);
}
// ================================================
// Debiti VS Fornitori
// ------------------------------------------------
// Se è già presente un movimento contabile legato alla ritenute
// vuol dire che il pagamento stato annullato.
// In questo caso il movimento di ritenuta non deve essere generato
// ================================================
numeroRiga++;
var importoFornitori = pag.Importo.GetValueOrDefault();
if (pag.RitenutaAcconto != null && pag.RitenutaAcconto.MovimentoContabileCreazione == null)
importoFornitori += pag.RitenutaAcconto.Importo.GetValueOrDefault();
var movimentoPatrimoniale = new MovimentoContabile(testata, pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.ID, pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoFornitori()), importoFornitori, "D")
{
Descrizione = string.Format("Pagamento Fatt. n.{0} del {1:d}", pag.ScadenzaRiferimento.SpesaRiferimento.NumeroDocumento, pag.ScadenzaRiferimento.SpesaRiferimento.DataDocumento.GetValueOrDefault())
};
if(logTransazione == null)
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);
// ================================================
// Ritenuta
// ================================================
decimal importoRitenuta = 0;
if (pag.ScadenzaRiferimento.SpesaRiferimento.Detrazione.GetValueOrDefault() == 0 && pag.RitenutaAcconto != null && pag.RitenutaAcconto.MovimentoContabileCreazione == null && pag.RitenutaAcconto.Importo != null && pag.RitenutaAcconto.Importo.GetValueOrDefault() != 0)
{
numeroRiga++;
var segnoRitenuta = "A";
importoRitenuta = pag.RitenutaAcconto.Importo.GetValueOrDefault();
if (pag.RitenutaAcconto.Importo.GetValueOrDefault() < 0)
{
segnoRitenuta = "D";
importoRitenuta = importoRitenuta * -1;
}
var movimentoRitenuta = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.ID, pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoRitenuta()), importoRitenuta, segnoRitenuta)
{
FornitoreRiferimento = movimentoPatrimoniale.FornitoreRiferimento
};
if (!string.IsNullOrEmpty(pag.ScadenzaRiferimento.SpesaRiferimento.NumeroDocumento) && pag.ScadenzaRiferimento.SpesaRiferimento.DataDocumento != null)
movimentoRitenuta.Descrizione = "Ritenuta Fatt. n." + pag.ScadenzaRiferimento.SpesaRiferimento.NumeroDocumento + " del " + pag.ScadenzaRiferimento.SpesaRiferimento.DataDocumento.Value.ToShortDateString();
pag.RitenutaAcconto.MovimentoContabileCreazione = movimentoRitenuta;
if(logTransazione == null)
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoRitenuta);
}
// ================================================
// Conto Patrimoniale
// ================================================
numeroRiga++;
if (pag.Conto == null)
{
switch (tipoConto)
{
case "B":
pag.Conto = _daoFactory.GetContoDao().GetByCodice(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.ID, pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoBancario());
break;
case "C":
pag.Conto = _daoFactory.GetContoDao().GetByCodice(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.ID, pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, "903");
break;
}
}
var segnoPagamento = "A";
var importoPagamento = importoFornitori - importoRitenuta;
if (importoPagamento < 0)
{
segnoPagamento = "D";
importoPagamento = importoPagamento * -1;
// Inverto segno e importo anche per il movimento di Debiti v/Fornitori
movimentoPatrimoniale.Segno = invertiSegno("D");
movimentoPatrimoniale.Importo = importoFornitori * -1;
}
var movimentoBancario = new MovimentoContabile(testata, causale, numeroRiga, pag.Conto, importoPagamento, segnoPagamento)
{
Descrizione = movimentoPatrimoniale.GetDescrizione(),
NumeroAssegno = pag.NumeroAssegno,
FornitoreRiferimento =
pag.ScadenzaRiferimento.SpesaRiferimento.
FornitoreRiferimento,
SottoContoRiferimento = pag.SottoConto,
ContoCorrenteBancario = pag.ContoCorrenteBancario
};
pag.MovimentoContabile = movimentoBancario;
if (logTransazione == null)
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoBancario);
}
else
{
var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", pag.Data.GetValueOrDefault()));
_log.FatalFormat("Data di registrazione non valida - {0} - data:{1} - pagamento:{2} - disposizione:{3} - tipoConto:{4} - esercizio:{5}", ex, Utility.GetMethodDescription(), pag.Data.GetValueOrDefault(), pag.ID, disposizione.ID, tipoConto, esercizioRiferimento.ID);
throw ex;
}
}
catch (Exception ex)
{
_log.FatalFormat("Errore inaspettato durante la scrittura dei movimenti per pagamenti - (SINGOLO PAGAMENTO) - {0} - pagamento:{1} - disposizione:{2}", ex, Utility.GetMethodDescription(), pag.ID, disposizione.ID);
throw;
}
}
}
catch (Exception ex)
{
_log.FatalFormat("Errore inaspettato durante la scrittura dei movimenti per pagamenti - {0} - disposizione:{1}", ex, Utility.GetMethodDescription(), disposizione.ID);
throw;
}
}
public TestataMovimentoContabile SetMovimentiAddebitoCompetenze(Esercizio esercizio, AddebitoCompetenza addebito, DateTime dataRegistrazione, Conto conto, SottoConto sottoConto, string descrizione)
{
try
{
// controllo data registrazione
var message = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
if (message.Count > 0)
{
var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", dataRegistrazione));
_log.ErrorFormat("Data di registrazione non valida - {0} - data:{1} - addebito:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), dataRegistrazione, addebito.ID, esercizio.ID);
throw ex;
}
// se la testata è automatica non è possibile aggiornare gli importi nel dettaglio, se manuale è possibile l'aggiornamento.
// per ora la testata viene inserita come manuale.
//TestataMovimentoContabile testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, Sfera.Enums.TipoTestataMovimentoContabileEnum.Automatica);
var testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Manuale, null) {Descrizione = descrizione, IsAllowUpdate = true};
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("IA");
var numeroRiga = 0;
// Contropartita
numeroRiga++;
var contoContropartita = _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, "913");
new MovimentoContabile(testata, causale, numeroRiga, contoContropartita, addebito.Dettaglio.Sum(item => item.Importo), "A") {Descrizione = descrizione};
foreach (var item in addebito.Dettaglio)
{
try
{
numeroRiga++;
var movimento = new MovimentoContabile(testata, causale, numeroRiga, conto, item.Importo, "D")
{
SottoContoRiferimento = sottoConto,
Descrizione = descrizione,
CondominoRiferimento = item.Soggetto
};
item.MovimentoContabile = movimento;
switch (item.Soggetto.Tipo)
{
case TipoSoggetto.Proprietario:
movimento.PercentualeProprieta = 1;
break;
case TipoSoggetto.Conduttore:
movimento.PercentualeProprieta = 0;
break;
}
movimento.IsRipartoPersonalizzato = true;
new SpeseUnita(item.Importo, null, item.Soggetto, movimento);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella creazione del movimento di addebito competenze per sollecito - SINGOLO DETTAGLIO - {0} - item:{1}", ex, Utility.GetMethodDescription(), item.ID);
throw;
}
}
addebito.TestataMovimento = testata;
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
return testata;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella creazione del movimento di addebito competenze per sollecito - {0} - esercizio:{1} - dataRegistrazione:{2} - addebito:{3} - conto:{4} - sottoconto:{5} - descrizione:{6}", ex, Utility.GetMethodDescription(), esercizio != null ? esercizio.ID.ToString() : "<NULL>", dataRegistrazione, addebito != null ? addebito.ID.ToString() : "<NULL>", conto != null ? conto.ID.ToString() : "<NULL>", sottoConto != null ? sottoConto.ID.ToString() : "<NULL>", descrizione);
throw;
}
}
public MovimentoContabile SetMovimentiStornoPagamento(Pagamento pag, decimal importo, DateTime dataRegistrazione)
{
try
{
var esercizio = _daoFactory.GetEsercizioDao().GetEsercizioCompetenza(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento, dataRegistrazione);
var message = IsAllowDataRegistrazione(new List<int> { pag.ScadenzaRiferimento.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 = "A";
if (importo < 0)
{
segno = "D";
importo = importo * -1;
}
var movimentoPatrimoniale = new MovimentoContabile(testata, pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento, causale, numeroRiga,
_daoFactory.GetContoDao().GetByCodice(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.ID,
pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoFornitori()), importo, segno)
{
Descrizione = "Storno Fatt. n." + pag.ScadenzaRiferimento.SpesaRiferimento.NumeroDocumento + " del " + pag.ScadenzaRiferimento.SpesaRiferimento.DataDocumento.GetValueOrDefault().ToShortDateString()
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);
// ================================================
// Conto Patrimoniale
// ================================================
numeroRiga++;
var movimentoBancario = new MovimentoContabile(testata, causale, numeroRiga, pag.Conto, importo, invertiSegno(segno))
{
Descrizione = movimentoPatrimoniale.Descrizione,
FornitoreRiferimento = pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento,
SottoContoRiferimento = pag.SottoConto,
ContoCorrenteBancario = pag.ContoCorrenteBancario
};
pag.MovimentoContabileStorno = movimentoBancario;
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoBancario);
return movimentoBancario;
}
var ex = new InvalidDataException(string.Format("La data di registrazione {0:d} non è valida", dataRegistrazione));
_log.ErrorFormat("Data di registrazione non valida - {0} - data:{1} - pagamento:{2} - importo:{3}", ex, Utility.GetMethodDescription(), dataRegistrazione, pag.ID, importo);
throw ex;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella funzione - {0} - data:{1} - pagamento:{2} - importo:{3}", ex, Utility.GetMethodDescription(), dataRegistrazione, pag.ID, importo);
throw;
}
}
public TestataMovimentoContabile SetMovimentiAddebitoCompetenze(AddebitoCompetenzaDTO addebito)
{
try
{
// se la testata è automatica non è possibile aggiornare gli importi nel dettaglio, se manuale è possibile l'aggiornamento.
// per ora la testata viene inserita come manuale.
TestataMovimentoContabile testata;
var esercizio = _daoFactory.GetEsercizioDao().Find(addebito.IdEsercizio, false);
var dataRegistrazione = addebito.DataRegistrazioneMovimentoContabile;
// controllo data registrazione
var messageData = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
if (messageData.Count == 0)
{
testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Manuale, null) {Descrizione = addebito.Descrizione, IsAllowUpdate = true};
var causale = _daoFactory.GetCausaleContabileDao().Find(addebito.IdCausale, false) ?? _daoFactory.GetCausaleContabileDao().GetByCodice("IA");
var numeroRiga = 0;
// Contropartita
numeroRiga++;
var contoContropartita = _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, "913");
new MovimentoContabile(testata, causale, numeroRiga, contoContropartita, addebito.Dettaglio.Sum(item => item.Importo), "A") {Descrizione = addebito.Descrizione};
foreach (var item in addebito.Dettaglio)
{
try
{
if (item.Importo != 0)
{
numeroRiga++;
var conto = _daoFactory.GetContoDao().Find(item.IdConto, false);
if (conto != null)
{
SottoConto sottoConto = null;
if (item.IdSottoConto != null)
sottoConto = _daoFactory.GetSottoContoDao().GetById(item.IdSottoConto.Value, false);
var soggetto = _daoFactory.GetSoggettoCondominioDao().Find(item.IdCondomino.GetValueOrDefault(), false);
if (soggetto != null)
{
var movimento = new MovimentoContabile(testata, causale, numeroRiga, conto, item.Importo, "D")
{
SottoContoRiferimento = sottoConto,
Descrizione = item.DescrizioneMovimentoContabile,
CondominoRiferimento = soggetto
};
switch (soggetto.Tipo)
{
case TipoSoggetto.Proprietario:
movimento.PercentualeProprieta = 1;
break;
case TipoSoggetto.Conduttore:
movimento.PercentualeProprieta = 0;
break;
}
movimento.IsRipartoPersonalizzato = true;
new SpeseUnita(item.Importo, null, soggetto, movimento);
var dettaglio = _daoFactory.GetDettaglioAddebitoCompetenzaDao().Find(item.ID, false);
if (dettaglio != null)
{
dettaglio.MovimentoContabile = movimento;
dettaglio.Soggetto = soggetto;
}
}
}
}
}
catch (Exception ex)
{
_log.Fatal(
"Errore inaspettato nella creazione del movimento di addebito competenze per sollecito - SINGOLO SOGGETTO - " +
Utility.GetMethodDescription() + " - id:" + item.ID + " - importo:" +
item.Importo + " - soggetto:" + item.IdCondomino + " - conto:" + item.IdConto +
" - sottoconto:" + item.IdSottoConto.GetValueOrDefault() + " - addebito:" + addebito.ID +
" - IdEsercizio:" + addebito.IdEsercizio, ex);
throw;
}
}
var addebitoItem = _daoFactory.GetAddebitoCompetenzaDao().Find(addebito.ID, false);
if (addebitoItem != null)
addebitoItem.TestataMovimento = testata;
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
}
else
{
var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", dataRegistrazione));
_log.Fatal("Data di registrazione non valida - " + Utility.GetMethodDescription() + " - data:" + dataRegistrazione + " - addebito:" + addebito.ID + " - IdEsercizio:" + addebito.IdEsercizio, ex);
throw ex;
}
return testata;
}
catch (Exception ex)
{
_log.Fatal("Errore inaspettato nella creazione del movimento di addebito competenze per sollecito - " + Utility.GetMethodDescription() + " - addebito:" + addebito.ID + " - IdEsercizio:" + addebito.IdEsercizio, ex);
throw;
}
}
private void deleteTestata(TestataMovimentoContabile testata, IDaoFactory daoFactory)
{
testata.SpesaRiferimento = null;
testata.EsercizioRiferimento = null;
// --------------------------------------------------------------------
// Aggiunto codice per rimuovere tutti i riferimenti bugid#4143
// --------------------------------------------------------------------
var movimenti = testata.Movimenti.ToList();
foreach (var movimentoContabile in movimenti)
{
movimentoContabile.Testata = null;
testata.Movimenti.Remove(movimentoContabile);
if (movimentoContabile.ContoRiferimento != null)
{
movimentoContabile.ContoRiferimento.Movimenti.Remove(movimentoContabile);
movimentoContabile.ContoRiferimento = null;
}
if (movimentoContabile.FornitoreRiferimento != null)
{
movimentoContabile.FornitoreRiferimento.MovimentiContabili.Remove(movimentoContabile);
movimentoContabile.FornitoreRiferimento = null;
}
}
testata.Movimenti.Clear();
daoFactory.GetTestataMovimentoContabileDao().Delete(testata);
// --------------------------------------------------------------------
}
public string ChiusuraContiEconomici(Esercizio esercizio, IEnumerable<ReportRipartizioneBilancioDTO> ripartizione)
{
try
{
var message = string.Empty;
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("C1");
var contoCondomini = _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoVersamentiCondomini());
// =======================================================================================
// Tutti i conti economici sono chiusi nel conto Crediti v/condomini
// =======================================================================================
var testataEconomico = new TestataMovimentoContabile(esercizio, esercizio.DataChiusura, TipoTestataMovimentoContabileEnum.Automatica, null) { AperturaChiusuraConti = true };
var conti = esercizio.CondominioRiferimento.Conti.Where(item => item.Tipo == TipoContoEconomicoEnum.Economico && item.PresenteBilancio).ToList();
var contiChiusuraStraordinario = getContiEconomiciChiusuraStraordinario(esercizio.CondominioRiferimento.ID);
foreach (var conto in conti)
{
try
{
var importoConto = Math.Round(GetSaldoConto(esercizio.ID, conto.ID, contiChiusuraStraordinario), 2);
var importoRipartizione = 0m;
var reportRipartizioneBilancioDtos = ripartizione as IList<ReportRipartizioneBilancioDTO> ?? ripartizione.ToList();
var conto1 = conto;
var spesePerCondomino = reportRipartizioneBilancioDtos.Where(item => item.IdConto == conto1.ID && item.IdPartecipante > 0).GroupBy(item => item.IdPartecipante);
var indexEconomico = 0;
foreach (var reportRipartizioneBilancioDTO in spesePerCondomino)
{
try
{
var soggetto = _daoFactory.GetSoggettoCondominioDao().GetById(reportRipartizioneBilancioDTO.Key, false);
var importo = Math.Round(reportRipartizioneBilancioDTO.Sum(item => item.Importo.GetValueOrDefault()), 2);
importoRipartizione += importo;
if (importo != 0)
{
var segno = "A";
if (importo < 0)
{
segno = "D";
importo = importo * -1;
}
// ---------------------------------------------------------------------
// Chiusura conto economico
// ---------------------------------------------------------------------
indexEconomico++;
var descrizione = string.Format("Chiusura conto '{0} {1}' - {2} Esercizio '{3}'", conto.Codice, conto.Descrizione, soggetto.DisplayName, esercizio.DisplayName);
new MovimentoContabile(testataEconomico, causale, 1, conto, importo, segno)
{
Descrizione = descrizione,
CondominoRiferimento = soggetto,
Stato = StatoMovimentoContabileEnum.Evaso
};
}
}
catch (Exception ex)
{
_log.FatalFormat("Errore inaspettato durante la chiusura dei conti economici (SINGOLO SOGGETTO) - {0} - conto:{1} - soggetto:{1}", ex, Utility.GetMethodDescription(), conto.ID, reportRipartizioneBilancioDTO.Key);
throw;
}
}
// ---------------------------------------------------------------------
// Contropartita crediti v/condomini
// ---------------------------------------------------------------------
var segnoConto = "D";
var importoRipartoConto = importoRipartizione;
if (importoRipartoConto < 0)
{
segnoConto = "A";
importoRipartoConto = importoRipartoConto * -1;
}
indexEconomico++;
new MovimentoContabile(testataEconomico, causale, indexEconomico, contoCondomini, importoRipartoConto, segnoConto)
{
Descrizione = string.Format("Chiusura conto '{0} {1}' - Esercizio '{2}'", conto.Codice, conto.Descrizione, esercizio.DisplayName),
Stato = StatoMovimentoContabileEnum.Evaso,
};
// ---------------------------------------------------------------------
// L'importo del conto non corrisponde con l'importo della ripartizione (dovuto all'arrotondamento tipico del riparto spese)
// ---------------------------------------------------------------------
if (importoConto != importoRipartizione)
{
var importoArrotondamento = importoConto - importoRipartizione;
var segno = "A";
if (importoArrotondamento < 0)
{
segno = "D";
importoArrotondamento = importoArrotondamento * -1;
}
// Conto economico
// ---------------------------------------------------------------------
indexEconomico++;
var descrizione = string.Format("Arrotondamento per riparto conto '{0} {1}' - Esercizio '{2}'", conto.Codice, conto.Descrizione, esercizio.DisplayName);
new MovimentoContabile(testataEconomico, causale, 1, conto, importoArrotondamento, segno)
{
Descrizione = descrizione,
Stato = StatoMovimentoContabileEnum.Evaso
};
// Contropartita conto Arrotondamenti
// ---------------------------------------------------------------------
indexEconomico++;
var contoArrotondamenti = _pianoContiService.GetContoArrotondamenti(esercizio);
_daoFactory.GetContoDao().SaveOrUpdate(contoArrotondamenti);
new MovimentoContabile(testataEconomico, causale, indexEconomico, contoArrotondamenti, importoArrotondamento, invertiSegno(segno))
{
Descrizione = descrizione,
Stato = StatoMovimentoContabileEnum.Evaso,
};
}
}
catch (Exception ex)
{
_log.FatalFormat("Errore inaspettato durante la chiusura dei conti economici (SINGOLO CONTO) - {0} - conto:{1}", ex, Utility.GetMethodDescription(), conto.ID);
throw;
}
}
if (testataEconomico.Movimenti.Count > 0)
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testataEconomico);
return message;
}
catch (Exception ex)
{
_log.FatalFormat("Errore inaspettato durante la chiusura dei conti economici - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), esercizio.ID);
throw;
}
}