public SpeseUnitaDTO GetByDomainEntity(SpeseUnita spesa)
{
try
{
return setSpeseUnitaDto(spesa);
}
catch (Exception ex)
{
_log.Error("Errore nel caricamento delle spese per unità immobiliare - " + Library.Utility.GetMethodDescription() + " - id:" + spesa.ID, ex);
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 TestataMovimentoContabile TrasferimentoSaldiStraordinarioInOrdinario(int idEsercizioStraordinario, int idEsercizioOrdinario, string nomeContoOrdinario, int ordineConto, IBilancioService bilancioService, DateTime? dataChiusura, bool chiusuraTemporanea)
{
try
{
var esercizioStraordinario = _daoFactory.GetEsercizioDao().GetById(idEsercizioStraordinario, false);
var esercizioOrdinario = _daoFactory.GetEsercizioDao().GetById(idEsercizioOrdinario, false);
if (!chiusuraTemporanea)
{
var messagesDataRegistrazione = _movimentiContabiliService.IsAllowDataRegistrazione(new List<int> {esercizioStraordinario.CondominioRiferimento.ID}, esercizioOrdinario, dataChiusura.GetValueOrDefault());
if (messagesDataRegistrazione.Count > 0)
{
var messageDataRegistrazione = messagesDataRegistrazione.Aggregate(string.Empty, (current, mess) => current + (mess + Environment.NewLine));
var ex = new InvalidDataException($"La data di registrazione {dataChiusura.GetValueOrDefault()} non è valida" + Environment.NewLine + messageDataRegistrazione);
_log.Fatal(ex.Message, ex);
throw ex;
}
var contoOrdinario = new Conto(esercizioOrdinario.CondominioRiferimento, TipoContoEconomicoEnum.Economico, TipoPeriodoCompetenzaContabile.Esercizio, nomeContoOrdinario, false, false, false)
{
PresenteBilancio = true,
CustomField = false,
EsercizioRiferimento = esercizioOrdinario,
Ordine = ordineConto,
Codice = ordineConto.ToString(CultureInfo.InvariantCulture).PadLeft(3, '0'),
PercentualeProprieta = 1,
IsSpesePersonali = true,
TrasferimentoSaldiStraordinario = true
};
var contoArrotondamenti = _pianoContiService.GetContoArrotondamenti(esercizioOrdinario);
_daoFactory.GetContoDao().SaveOrUpdate(contoArrotondamenti);
var sottocontoOrdinario = new SottoConto(contoOrdinario, nomeContoOrdinario);
esercizioStraordinario.ContoEconomicoOrdinarioChiusuraStraordinario = contoOrdinario;
var items = bilancioService.GetDataSourceRipartizioneBilancioConsuntivo(esercizioStraordinario.ID, null, null, null, null, null, null, false, false, TipoAccorpamentoRateEnum.Nessuno, false, false, false, false, null).ToList();
var ripartoEconomici = items.Where(item => item.OrdineConto < 9900).ToList();
var testata = new TestataMovimentoContabile(esercizioOrdinario, dataChiusura, TipoTestataMovimentoContabileEnum.Automatica, null);
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
esercizioStraordinario.TestataContabileChiusura = testata;
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("ST");
// ===========================================================================
// Movimenti Chiusura/Apertura conti economici
// ---------------------------------------------------------------------------
// Chiusura di tutti i conti economici della gestione starordianaria (in avere),
// aprendo un conto economico "<CONTO ECONOMICO SALDI STRAORDINARIA>" nella gestione ordinaria (in dare), per il totale della spesa.
// La spesa deve essere ripartita sulla base dei conti utilizzati nella gestione straordinaria.
// I conti devono essere addebitati per soggetto.
// ===========================================================================
var numeroRiga = 0;
foreach (var itemRiparto in ripartoEconomici)
{
// Gli arrotondamenti hanno IdPartecipante == 0, queste righe devono essere usate per registrare i movimenti di arrotondamento.
if (itemRiparto.IdPartecipante > 0)
{
var importo = itemRiparto.Importo.GetValueOrDefault();
if (importo != 0)
{
try
{
var soggetto = _daoFactory.GetSoggettoCondominioDao().GetById(itemRiparto.IdPartecipante, false);
// ---------------------------------------------
// Apertura conto economico nell'ordinario
// ---------------------------------------------
numeroRiga++;
var movimentoAperturaOrdinario = new MovimentoContabile(testata, causale, 1, contoOrdinario, numeroRiga, "D")
{
Descrizione = $"Saldo Gestione Straordinaria '{esercizioStraordinario.Descrizione}' - {soggetto.DisplayName}",
CondominoRiferimento = soggetto,
SottoContoRiferimento = sottocontoOrdinario
};
// Calcolo del segno
var segnoEconomico = "D";
if (importo < 0)
{
segnoEconomico = "A";
importo = importo * -1;
}
movimentoAperturaOrdinario.Segno = segnoEconomico;
movimentoAperturaOrdinario.Importo = importo;
// ---------------------------------------------
// Chiusura conto economico nello straordinario
// ---------------------------------------------
numeroRiga++;
var movimentoChiusuraStraordinario = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetById(itemRiparto.IdConto, false), importo, invertiSegno(segnoEconomico)) { Descrizione = string.Format("Chiusura conto {0}: '{1}' - {2}", itemRiparto.DescrizioneConto, esercizioStraordinario.Descrizione, soggetto.DisplayName), CondominoRiferimento = movimentoAperturaOrdinario.CondominoRiferimento };
// ---------------------------------------------
// Dettaglio spesa unità
// ---------------------------------------------
var spesaUnita = new SpeseUnita(itemRiparto.Importo, null, soggetto, movimentoAperturaOrdinario);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante il trasferimento saldi dell'esercizio straordinario all'ordinario - MOVIMENTO CONTO ECONOMICO - {0} - importo:{1} - idEsercizioStraordinario:{2} - idEsercizioOrdinario:{3} - nomeContoOrdinario:{4} - ordineConto:{5}", ex, Library.Utility.GetMethodDescription(), importo, idEsercizioStraordinario, idEsercizioOrdinario, nomeContoOrdinario, ordineConto);
throw;
}
}
}
else
{
// ---------------------------------------------
// Apertura conto economico nell'ordinario
// ---------------------------------------------
var importo = itemRiparto.Importo;
numeroRiga++;
var movimentoAperturaOrdinario = new MovimentoContabile(testata, causale, 1, contoArrotondamenti, numeroRiga, "D") { Descrizione = $"Saldo Gestione Straordinaria '{esercizioStraordinario.Descrizione}'" };
// Calcolo del segno
var segnoEconomico = "D";
if (importo < 0)
{
segnoEconomico = "A";
importo = importo * -1;
}
movimentoAperturaOrdinario.Segno = segnoEconomico;
movimentoAperturaOrdinario.Importo = importo;
// ---------------------------------------------
// Chiusura conto economico nello straordinario
// ---------------------------------------------
numeroRiga++;
var movimentoChiusuraStraordinario = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetById(itemRiparto.IdConto, false), importo, invertiSegno(segnoEconomico)) { Descrizione = $"Arrondamento chiusura conto {itemRiparto.DescrizioneConto}: '{esercizioStraordinario.Descrizione}'"
};
}
}
// ===========================================================================
// Movimenti Chiusura/Apertura crediti v/condomini gestione straordinaria
// ---------------------------------------------------------------------------
// Chiusura del conto Crediti v/condomini della "<GESTIONE STRAORDINARIA>"
// per i versamenti effettuati nella gestione straordinaria, sul conto "<CONTO ECONOMICO SALDI STRAORDINARIA>",
// accreditando i singoli soggetti.
// ===========================================================================
var ripartoVersamenti = items.Where(item => item.OrdineConto == 9992).ToList();
// Aggiungo soggetti con saldo inziale ma senza versamenti
var saldiIniziali = items.Where(item => item.OrdineConto == 9991).ToList();
var ripartoSaldiIniziali = new List<ReportRipartizioneBilancioDTO>(saldiIniziali.Count);
foreach (var reportRipartizioneBilancioDTO in saldiIniziali)
{
if (ripartoVersamenti.All(item => item.IdPartecipante != reportRipartizioneBilancioDTO.IdPartecipante))
{
reportRipartizioneBilancioDTO.Importo = reportRipartizioneBilancioDTO.Importo.GetValueOrDefault()*-1;
ripartoVersamenti.Add(reportRipartizioneBilancioDTO);
}
else
ripartoSaldiIniziali.Add(reportRipartizioneBilancioDTO);
}
var contoVersamentiEsercizioStraordinario = _daoFactory.GetContoDao().GetByCodice(esercizioStraordinario.ID, esercizioStraordinario.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoVersamentiCondomini());
foreach (var itemRiparto in ripartoVersamenti)
{
var importo = itemRiparto.Importo.GetValueOrDefault();
// aggiungo eventuale saldo iniziale
var itemSaldoIniziale = ripartoSaldiIniziali.FirstOrDefault(item => item.IdPartecipante == itemRiparto.IdPartecipante);
var importoSaldoIniziale = 0m;
if (itemSaldoIniziale != null)
importoSaldoIniziale = itemSaldoIniziale.Importo.GetValueOrDefault();
importo -= importoSaldoIniziale;
try
{
// Gli arrotondamenti hanno IdPartecipante == 0, escludo queste righe.
if (itemRiparto.IdPartecipante > 0)
{
var soggetto = _daoFactory.GetSoggettoCondominioDao().GetById(itemRiparto.IdPartecipante, false);
// ---------------------------------------------
// Apetura conto economico nell'ordinario
// ---------------------------------------------
numeroRiga++;
var movimentoAperturaOrdinario = new MovimentoContabile(testata, causale, numeroRiga, contoOrdinario, 0, "D")
{
Descrizione = $"Saldo Gestione Straordinaria '{esercizioStraordinario.Descrizione}' - {soggetto.DisplayName}",
CondominoRiferimento = soggetto,
SottoContoRiferimento = sottocontoOrdinario
};
// Calcolo del segno
var segnoEconomico = "A";
if (importo < 0)
{
segnoEconomico = "D";
importo = importo * -1;
}
movimentoAperturaOrdinario.Segno = segnoEconomico;
movimentoAperturaOrdinario.Importo = importo;
// ---------------------------------------------
// Chiusura conto crediti v/condomini nello straordinario
// ---------------------------------------------
numeroRiga++;
var movimentoChiusuraStraordinario = new MovimentoContabile(testata, causale, numeroRiga, contoVersamentiEsercizioStraordinario, importo, invertiSegno(segnoEconomico)) { Descrizione = string.Format("Chiusura conto {0}: '{1}' - {2}", contoVersamentiEsercizioStraordinario.Descrizione, esercizioStraordinario.Descrizione, soggetto.DisplayName), CondominoRiferimento = movimentoAperturaOrdinario.CondominoRiferimento };
// ---------------------------------------------
// Dettaglio spesa unità
// ---------------------------------------------
var spesaUnita = new SpeseUnita((itemRiparto.Importo.GetValueOrDefault() - importoSaldoIniziale) * -1, null, soggetto, movimentoAperturaOrdinario);
}
}
catch (Exception ex)
{
_log.FatalFormat("Errore inaspettato durante il trasferimento saldi dell'esercizio straordinario all'ordinario - MOVIMENTO VERSAMENTI - {0} - importo:{1} - idEsercizioStraordinario:{2} - idEsercizioOrdinario:{3} - nomeContoOrdinario:{4} - ordineConto:{5}", ex, Library.Utility.GetMethodDescription(), importo, idEsercizioStraordinario, idEsercizioOrdinario, nomeContoOrdinario, ordineConto);
throw;
}
}
return testata;
}
else
{
// ====================================================================
// Chiusura temporanea dei conti
// ====================================================================
var movimentiEconomici = _daoFactory.GetMovimentoContabileDao().GetByEsercizioEconomici(esercizioStraordinario, esercizioOrdinario.DataApertura, esercizioOrdinario.DataChiusura);
var contoPatrimoniale = _pianoContiService.GetContoChiusuraStraordinario(esercizioStraordinario);
var testataChiusura = new TestataMovimentoContabile(esercizioStraordinario, dataChiusura, TipoTestataMovimentoContabileEnum.Automatica, null)
{
EsercizioOrdinarioChiusura = esercizioOrdinario,
Descrizione = $"Chiusura esercizio straordinario: '{esercizioStraordinario.DisplayName}' per chiusura dell'ordinario: '{esercizioOrdinario.DisplayName}'"
};
var causaleChiusura = _daoFactory.GetCausaleContabileDao().GetByCodice("C2");
var index = 0;
// =================================================
// Calcolo tutti i saldi dei conti
// =================================================
var saldiContoSottoconto = new Dictionary<string, MovimentoContabile>();
foreach (var movimentoContabile in movimentiEconomici)
{
var key = _movimentiContabiliService.GetKeyContoSottoconto(movimentoContabile);
if (saldiContoSottoconto.ContainsKey(key))
{
var movimentoChiusura = saldiContoSottoconto[key];
movimentoChiusura.Importo += movimentoContabile.GetImportoConSegno();
}
else
{
index++;
var movimentoChiusura = new MovimentoContabile(testataChiusura, causaleChiusura, index, movimentoContabile.ContoRiferimento, movimentoContabile.GetImportoConSegno(), string.Empty)
{
Descrizione = $"Chiusura esercizio straordinario: '{esercizioStraordinario.DisplayName}' per chiusura dell'ordinario: '{esercizioOrdinario.DisplayName}'",
CondominoRiferimento = movimentoContabile.CondominoRiferimento,
FornitoreRiferimento = movimentoContabile.FornitoreRiferimento,
ContoCorrenteBancario = movimentoContabile.ContoCorrenteBancario
};
saldiContoSottoconto.Add(key, movimentoChiusura);
}
}
// =================================================
// Elaboro i segni e creo le contropartite
// =================================================
foreach (var kvp in saldiContoSottoconto)
{
var movimentoContabile = kvp.Value;
if (movimentoContabile.ContoRiferimento.Tipo == TipoContoEconomicoEnum.Economico)
{
movimentoContabile.Segno = "A";
if (movimentoContabile.Importo < 0)
{
movimentoContabile.Segno = "D";
movimentoContabile.Importo = movimentoContabile.Importo*-1;
}
}
else if (movimentoContabile.ContoRiferimento.Tipo == TipoContoEconomicoEnum.Patrimoniale)
{
movimentoContabile.Segno = "D";
if (movimentoContabile.Importo < 0)
{
movimentoContabile.Segno = "A";
movimentoContabile.Importo = movimentoContabile.Importo * -1;
}
}
var movimentoPatrimoniale = new MovimentoContabile(testataChiusura, causaleChiusura, index, contoPatrimoniale, movimentoContabile.Importo, invertiSegno(movimentoContabile.Segno))
{
Descrizione = $"Chiusura conto '{kvp.Value.ContoRiferimento.Descrizione}' esercizio straordinario: '{esercizioStraordinario.DisplayName}' per chiusura dell'ordinario: '{esercizioOrdinario.DisplayName}'"
};
}
return testataChiusura;
}
}
catch (Exception ex)
{
_log.FatalFormat("Errore inaspettato durante il trasferimento saldi dell'esercizio straordinario all'ordinario - {0} - idEsercizioStraordinario:{1} - idEsercizioOrdinario:{2} - nomeContoOrdinario:{3} - ordineConto:{4} - dataChiusura:{5:d}", ex, Library.Utility.GetMethodDescription(), idEsercizioStraordinario, idEsercizioOrdinario, nomeContoOrdinario, ordineConto, dataChiusura.GetValueOrDefault());
throw;
}
}
private bool update(SpeseUnitaDTO spesaDto, out SpeseUnita spesa)
{
var result = false;
spesa = null;
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
try
{
spesa = daoFactory.GetSpeseUnitaDao().GetById(spesaDto.ID, false);
// Condizione necessaria per il controllo del fatto che sul DB ho una versione uguale o più vecchia
if (spesaDto.Version == spesa.Version)
{
spesa.Importo = spesaDto.Importo;
spesa.MovimentoRiferimento = daoFactory.GetMovimentoContabileDao().GetById(spesaDto.IdMovimentoRiferimento, false);
if(spesaDto.IdUnitaRiferimento != null)
spesa.UnitaRiferimento = daoFactory.GetUnitaImmobiliareDao().GetById(spesaDto.IdUnitaRiferimento.GetValueOrDefault(), false);
if (spesaDto.IdSoggetto != null)
spesa.SoggettoCondominio = daoFactory.GetSoggettoCondominioDao().GetById(spesaDto.IdSoggetto.GetValueOrDefault(), false);
result = true;
}
else
{
// Eccezione: Sul db c'è qualche cosa di più nuovo.
_log.Error("Errore nel salvataggio della gestione dei riparti delle unità id:" + spesaDto.ID.ToString() + " - il dato sul db è più recente di quello che si vuole salvare");
}
}
catch (Exception ex)
{
_log.Error("Errore nel salvataggio della gestione dei riparti delle unità - " + Library.Utility.GetMethodDescription() + " - id:" + spesaDto.ID.ToString(), ex);
throw;
}
return result;
}
private bool insert(SpeseUnitaDTO spesaDto, out SpeseUnita spesa)
{
bool result;
spesa = null;
try
{
if (_movimento != null)
{
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
UnitaImmobiliare unitaImmobiliare = null;
if (spesaDto.IdUnitaRiferimento != null)
unitaImmobiliare = daoFactory.GetUnitaImmobiliareDao().Find(spesaDto.IdUnitaRiferimento.GetValueOrDefault(), false);
SoggettoCondominio soggettoCondominio = null;
if (spesaDto.IdSoggetto != null)
soggettoCondominio = daoFactory.GetSoggettoCondominioDao().Find(spesaDto.IdSoggetto.GetValueOrDefault(), false);
spesa = new SpeseUnita(spesaDto.Importo, unitaImmobiliare, soggettoCondominio, _movimento);
daoFactory.GetSpeseUnitaDao().SaveOrUpdate(spesa);
}
result = true;
}
catch (Exception ex)
{
_log.Error("Errore nell'inserimento del riparto delle unità - " + Library.Utility.GetMethodDescription(), ex);
result = false;
}
return result;
}
private bool isAddebitatoScalaStabile(SpeseUnita spesaUnita, int? idStabile, int? idScala)
{
if (idStabile != null || idScala != null)
{
var unita = spesaUnita.UnitaRiferimento;
if (unita == null && spesaUnita.SoggettoCondominio != null)
unita = spesaUnita.SoggettoCondominio.UnitaImmobiliare;
if (unita != null)
{
if (idStabile != null)
return unita.GruppoStabileRiferimento.PalazzinaRiferimento.ID == idStabile.Value;
else
return unita.GruppoStabileRiferimento.ID == idScala.Value;
}
}
return true;
}
private SpeseUnitaDTO setSpeseUnitaDto(SpeseUnita spesa)
{
try
{
var dto = new SpeseUnitaDTO
{
ID = spesa.ID,
Importo = spesa.Importo,
IdMovimentoRiferimento = spesa.MovimentoRiferimento.ID,
};
if (spesa.UnitaRiferimento != null)
{
dto.IdUnitaRiferimento = spesa.UnitaRiferimento.ID;
dto.DescrizioneUnitaRiferimento = spesa.UnitaRiferimento.Descrizione;
}
if (spesa.SoggettoCondominio != null)
{
dto.IdSoggetto = spesa.SoggettoCondominio.ID;
dto.DescrizioneUnitaRiferimento = spesa.SoggettoCondominio.DisplayName;
}
return dto;
}
catch (Exception ex)
{
if (spesa != null)
{
_log.Error("Errore nel caricamento del riparto spese per unità - " + Library.Utility.GetMethodDescription() + " - id:" + spesa.ID, ex);
}
else
{
_log.Error("Errore nel caricamento del riparto spese per unità - " + Library.Utility.GetMethodDescription() + " - Spesa --> null", ex);
}
throw;
}
}
public virtual IUpdatableBusinessEntity Copy()
{
var spesa = new SpeseUnita(Importo, UnitaRiferimento, SoggettoCondominio, MovimentoRiferimento);
return spesa;
}
private string setRipartoBolletta(Spesa spesa, IList<ImportiDTO> addebitiCalcolati, Conto contoMillesimiSpalo, decimal importoTotaleBollette, IList<RipartoBollette> calcoli, IList<SoggettoCondominio> soggettiAttivi)
{
try
{
var message = string.Empty;
spesa.IsRipartita = true;
// ==================================================
// Calcolo il riparto
// ==================================================
var importoTotaleAddebitato = addebitiCalcolati.Sum(item => item.Importo);
var index = 0;
foreach (var movimento in spesa.MovimentiBollette)
{
try
{
foreach (var speseUnita in movimento.DettaglioRipartizione)
speseUnita.MovimentoRiferimento = null;
movimento.DettaglioRipartizione.Clear();
// Individuo quali sono i consumi da considerare
//var addebitiCalcolatiDaConsiderare = addebitiCalcolati.Where(importoPerUnita => movimento.DettaglioRipartizione.Any(item => item.UnitaRiferimento.ID == importoPerUnita.Id)).ToList();
var unitaDaConsiderare = GetUnitaContoModello(movimento, index);
var addebitiCalcolatiDaConsiderare = addebitiCalcolati.Where(importoPerUnita => unitaDaConsiderare.Any(item => item.ID == importoPerUnita.Id)).ToList();
var percentualeMovimento = (movimento.GetImportoConSegno().GetValueOrDefault() * 100) / importoTotaleBollette;
var importoMovimentoAddebitato = (importoTotaleAddebitato * percentualeMovimento) / 100;
var importoMovimentoSpalo = movimento.GetImportoConSegno().GetValueOrDefault() - importoMovimentoAddebitato;
// Calcolo il riparto per ogni unità
foreach (var importoPerUnita in addebitiCalcolati)
{
try
{
var unita = _daoFactory.GetUnitaImmobiliareDao().GetById(importoPerUnita.Id, false);
// Riparto importo addebitato
var importo = _millesimiService.GetRipartoImportoValori(unita, importoMovimentoAddebitato, addebitiCalcolatiDaConsiderare);
// Riparto spalo
if (contoMillesimiSpalo == null)
importo += _millesimiService.GetRipartoImportoValori(unita, importoMovimentoSpalo, addebitiCalcolatiDaConsiderare);
else
importo += _millesimiService.GetRipartoImporto(unita, contoMillesimiSpalo, importoMovimentoSpalo, null, spesa.EsercizioRiferimento).GetValueOrDefault();
// Aggiorno l'importo a Bilancio sul calcolo acqua
if (calcoli != null)
{
var riparto = (from item in calcoli
where item.UnitaImmobiliare != null && item.UnitaImmobiliare.ID == importoPerUnita.Id
select item).SingleOrDefault();
if (riparto != null)
riparto.ImportoBilancio = riparto.ImportoBilancio.GetValueOrDefault() + importo;
}
// =======================================================================================
// Riparto la spese tra tutti i condomini partecipanti nell'unità immobiliare
// =======================================================================================
// -------------------------
// Proprietario
// -------------------------
var proprietariPrincipali = (from item in soggettiAttivi
where
item.Tipo == TipoSoggetto.Proprietario &&
item.UnitaImmobiliare.ID == unita.ID &&
item.Principale.GetValueOrDefault()
select item).ToList();
if (proprietariPrincipali.Count > 1)
{
if (proprietariPrincipali.All(item => item.DataInizio == null) || proprietariPrincipali.All(item => item.DataFine == null))
_log.Warn("Trovato più di un PROPRIETARIO principale - " + Library.Utility.GetMethodDescription() + " - idUnita: " + unita.ID + " - idEsercizio: " + movimento.Testata.EsercizioRiferimento.ID);
}
var proprietarioPrincipale = proprietariPrincipali.OrderByDescending(item => item.DataInizio.GetValueOrDefault()).FirstOrDefault(item => item.DataFine == null);
// Se il proprietario non è presente lo cerco tra tutti i proprietari
if (proprietarioPrincipale == null)
{
proprietarioPrincipale = (from item in unita.Proprietari
where item.DataInizio == null || item.DataInizio.Value < movimento.Testata.EsercizioRiferimento.DataChiusura
orderby item.DataInizio.GetValueOrDefault() descending
select item).FirstOrDefault();
}
var importoConduzione = _ripartizioneSpeseService.GetImportoCompetenza(importo.GetValueOrDefault(), movimento, TipoSoggetto.Conduttore);
var importoProprieta = _ripartizioneSpeseService.GetImportoCompetenza(importo.GetValueOrDefault(), movimento, TipoSoggetto.Proprietario);
// --------------------------------------------
// Importo di proprietà
// --------------------------------------------
if (importoProprieta != 0)
{
var soggProp = new List<ImportiDTO>();
// --------------------------------------------------------------------
// Individuo tutti i soggetti tra cui ripartire l'importo
// --------------------------------------------------------------------
var conto = movimento.ContoRiferimento;
var soggPropRip = (from itemSogg in conto.SoggettiRipartizione
where itemSogg.Soggetto.Tipo == TipoSoggetto.Proprietario && itemSogg.Soggetto.UnitaImmobiliare.ID == unita.ID
select itemSogg).ToList();
// In presenza di ripartizioni personalizzate occorre dividere l'importo addebito alla proprietà tra i diversi proprietari
if (soggPropRip.Count > 0)
{
var totaleSoggPropRip = soggPropRip.Sum(item => item.PercentualeRipartizione);
soggProp.AddRange(from sogg in soggPropRip
let soggettoRipartizione = sogg.Soggetto
select new ImportiDTO
{
Id = soggettoRipartizione.ID,
Importo = (importoProprieta * sogg.PercentualeRipartizione) / totaleSoggPropRip
});
}
else if (soggPropRip.Count == 0)
{
var proprietariAttivi = soggettiAttivi.Where(item => item.Tipo == TipoSoggetto.Proprietario && item.UnitaImmobiliare.ID == unita.ID).ToList();
if (proprietariAttivi.Count == 0 && proprietarioPrincipale != null)
proprietariAttivi.Add(proprietarioPrincipale);
if (proprietariAttivi.Sum(item => item.PercentualeRiferimento) != 100)
{
if (proprietariAttivi.All(item => item.DataInizio == null) || proprietariAttivi.All(item => item.DataFine == null))
_log.Warn("ATTENZIONE: La somma della percentuale di riparto non è 100 - " + Library.Utility.GetMethodDescription() + " (Spese - Proprietari) - idUnita:" + unita.ID + " - idSpesa: " + spesa.ID + " - idEsercizio: " + movimento.Testata.EsercizioRiferimento.ID);
if (proprietariAttivi.Count == 1)
proprietariAttivi[0].PercentualeRiferimento = 100m;
}
soggProp.AddRange(proprietariAttivi.Select(soggAttivo => new ImportiDTO { Id = soggAttivo.ID, Importo = (importoProprieta * soggAttivo.PercentualeRiferimento.GetValueOrDefault()) / 100 }));
}
foreach (var importiDTO in soggProp)
{
var soggetto = soggettiAttivi.FirstOrDefault(item => item.ID == importiDTO.Id) ?? _daoFactory.GetSoggettoCondominioDao().Find(importiDTO.Id, false);
var spesaUnita = new SpeseUnita(importiDTO.Importo, null, soggetto, movimento);
_daoFactory.GetSpeseUnitaDao().SaveOrUpdate(spesaUnita);
}
}
// --------------------------------------------
// Importo di conduzione
// --------------------------------------------
if (importoConduzione > 0)
{
var soggCond = new List<ImportiDTO>();
var soggCondRip = (from itemSogg in movimento.ContoRiferimento.SoggettiRipartizione
where
itemSogg.Soggetto.Tipo == TipoSoggetto.Conduttore &&
itemSogg.Soggetto.UnitaImmobiliare.ID == unita.ID
select itemSogg).ToList();
if (soggCondRip.Count > 0)
{
var totaleSoggCondRip = soggCondRip.Sum(item => item.PercentualeRipartizione);
soggCond.AddRange(soggCondRip.Select(sogg => new ImportiDTO
{
Id = sogg.Soggetto.ID,
Importo = (importoConduzione * sogg.PercentualeRipartizione) / totaleSoggCondRip
}));
}
else if (soggCondRip.Count == 0)
{
var conduttoriAttivi = (from item in soggettiAttivi
where item.Tipo == TipoSoggetto.Conduttore && item.UnitaImmobiliare.ID == unita.ID
select item).ToList();
if (!conduttoriAttivi.Any())
{
conduttoriAttivi = (from item in soggettiAttivi
where item.Tipo == TipoSoggetto.Proprietario && item.UnitaImmobiliare.ID == unita.ID
select item).ToList();
}
if (conduttoriAttivi.Sum(item => item.PercentualeRiferimento) != 100)
{
_log.Warn("ATTENZIONE: La somma della percentuale di riparto non è 100 - " + Library.Utility.GetMethodDescription() + " (Spese - Conduttori) - idUnita:" + unita.ID + " - idSpesa: " + spesa.ID + " - idEsercizio: " + movimento.Testata.EsercizioRiferimento.ID);
if (conduttoriAttivi.Count == 1)
conduttoriAttivi[0].PercentualeRiferimento = 100m;
}
soggCond.AddRange(conduttoriAttivi.Select(soggAttivo => new ImportiDTO { Id = soggAttivo.ID, Importo = (importoConduzione * soggAttivo.PercentualeRiferimento.GetValueOrDefault()) / 100 }));
}
foreach (var importiDTO in soggCond)
{
var soggetto = soggettiAttivi.FirstOrDefault(item => item.ID == importiDTO.Id) ?? _daoFactory.GetSoggettoCondominioDao().Find(importiDTO.Id, false);
var spesaUnita = new SpeseUnita(importiDTO.Importo, null, soggetto, movimento);
_daoFactory.GetSpeseUnitaDao().SaveOrUpdate(spesaUnita);
}
}
}
catch (Exception ex)
{
_log.Error("Errore durante la ripartizione di una bolletta - SINGOLA UNITA' - " + Library.Utility.GetMethodDescription() + " - unità:" + importoPerUnita.Id + " - movimento:" + movimento.ID + " - idBolletta:" + spesa.ID, ex);
throw;
}
}
index++;
}
catch (Exception ex)
{
_log.Error("Errore durante la ripartizione di una bolletta - SINGOLO MOVIMENTO - " + Library.Utility.GetMethodDescription() + " - movimento:" + movimento.ID + " - idBolletta:" + spesa.ID, ex);
throw;
}
}
return message;
}
catch (Exception ex)
{
_log.Error("Errore durante la ripartizione di una bolletta - " + Library.Utility.GetMethodDescription() + " - idBolletta:" + spesa.ID, ex);
throw;
}
}
public void SalvaRipartizione(MovimentoContabile movimento, IList<ImportiDTO> importi, bool spesaPersonale)
{
foreach (var importo in importi)
{
SpeseUnita spesaUnita;
if(!spesaPersonale)
spesaUnita = new SpeseUnita(importo.Importo, _daoFactory.GetUnitaImmobiliareDao().GetById(importo.Id, false), null, movimento);
else
spesaUnita = new SpeseUnita(importo.Importo, null, _daoFactory.GetSoggettoCondominioDao().GetById(importo.Id, false), movimento);
_daoFactory.GetSpeseUnitaDao().SaveOrUpdate(spesaUnita);
}
}
public void SalvaRipartizione(MovimentoContabile movimento, int idCondominio, bool defaultSelezionato)
{
var lista = new List<SpeseUnita>(movimento.DettaglioRipartizione.Count);
lista.AddRange(movimento.DettaglioRipartizione);
foreach (var spesaOld in lista)
{
movimento.DettaglioRipartizione.Remove(spesaOld);
spesaOld.MovimentoRiferimento = null;
}
var tb = GetUnitaDataSource(GetKey(movimento), movimento.ContoRiferimento.ID, idCondominio, defaultSelezionato, movimento.Testata.EsercizioRiferimento, false);
foreach (DataRow row in tb.Rows)
{
if (row["Selezionato"] != DBNull.Value && (bool)row["Selezionato"])
{
SpeseUnita spesaUnita;
if(row["IdUnitaImmobiliare"] != null && row["IdUnitaImmobiliare"] != DBNull.Value)
spesaUnita = new SpeseUnita(null, _daoFactory.GetUnitaImmobiliareDao().GetById((int)row["IdUnitaImmobiliare"], false), null, movimento);
else
spesaUnita = new SpeseUnita(null, null, _daoFactory.GetSoggettoCondominioDao().GetById((int)row["IdSoggettoCondominio"], false), movimento);
_daoFactory.GetSpeseUnitaDao().SaveOrUpdate(spesaUnita);
}
}
}
private void setRipartizione(MovimentoContabile movimento)
{
if (movimento.ContoRiferimento.Ripartizione && !movimento.ContoRiferimento.IsSpesePersonali)
{
if ((!movimento.IsRipartoPersonalizzato || !string.IsNullOrEmpty(movimento.GruppiAddebito)))
{
movimento.DettaglioRipartizione.Clear();
List<int> idScale = null;
if (!string.IsNullOrEmpty(movimento.GruppiAddebito))
{
var scale = movimento.GruppiAddebito.Split('&');
idScale = new List<int>(scale.Length);
idScale.AddRange(scale.Select(int.Parse));
}
var millesimi = _millesimiService.GetByConto(movimento.ContoRiferimento, null, idScale, movimento.Testata.EsercizioRiferimento);
foreach (var millesimo in millesimi)
{
var unita = _daoFactory.GetUnitaImmobiliareDao().GetById(millesimo.IdUnitaRiferimento, false);
var valoreMillesimo = _millesimiService.GetRipartoImporto(unita, movimento.ContoRiferimento, movimento.GetImportoConSegno().GetValueOrDefault(), millesimi, movimento.Testata.EsercizioRiferimento, null);
if (valoreMillesimo != null)
{
var riparto = new SpeseUnita(valoreMillesimo, unita, null, movimento);
movimento.DettaglioRipartizione.Add(riparto);
}
}
}
else
RicalcoloRipartizioneByMovimento(movimento);
}
else
RicalcoloRipartizioneByMovimento(movimento);
}
/// <summary>
/// Restituisce l'importo di competenza di una spesa per un singolo soggetto
/// </summary>
/// <param name="spesa">Spesa addebitata all'intera unità immobiliare</param>
/// <param name="tipoSoggetto">Tipo di soggetto per il quale si vuole calcolare l'importo di competenza</param>
/// <param name="anno">Se definito l'importo è proporzionato alla percentuale di spesa effettivamente pagata, se non definito non viene usata tale proporzione.
/// <remarks>Solo per il calcolo dell'importo di competenza per la stampa del bilancio per detrazioni 36 e 55 deve essere definito l'anno e quindi usata la proporzione relativa al pagamento della spesa</remarks>
/// </param>
/// <param name="detrazione">Detrazione da considerare</param>
/// <returns>L'importo di competenza</returns>
public decimal GetImportoCompetenza(SpeseUnita spesa, TipoSoggetto tipoSoggetto, int? anno, int? detrazione)
{
decimal importoCompetenza = 0;
if (spesa.GetImporto() != 0)
{
if (spesa.SoggettoCondominio != null)
return tipoSoggetto == spesa.SoggettoCondominio.Tipo ? spesa.GetImporto() * spesa.GetMovimentoRiferimento().GetPercentualePagata(anno, detrazione) : 0;
var contoRiferimento = spesa.GetMovimentoRiferimento().ContoRiferimento;
var sottoContoRiferimento = spesa.GetMovimentoRiferimento().SottoContoRiferimento;
// ---------------------------------------------
// Calcolo percentuale proprietà
// ---------------------------------------------
var percentualeProprieta = spesa.GetMovimentoRiferimento().ContoRiferimento.PercentualeProprieta;
if (sottoContoRiferimento?.PercentualeProprieta != null)
percentualeProprieta = sottoContoRiferimento.PercentualeProprieta.GetValueOrDefault();
// Se definita devo usare la specifica ripartizione per spesa
if (spesa.GetMovimentoRiferimento().PercentualeProprieta != null)
percentualeProprieta = spesa.GetMovimentoRiferimento().PercentualeProprieta.GetValueOrDefault();
// Se è definita devo usare la ripartizione per conto
if (contoRiferimento.SoggettiRipartizione.Any(item => item.Soggetto.UnitaImmobiliare.ID == spesa.UnitaRiferimento.ID))
{
percentualeProprieta = (contoRiferimento.SoggettiRipartizione.Where(
item =>
item.Soggetto.Tipo == TipoSoggetto.Proprietario &&
item.Soggetto.UnitaImmobiliare.ID == spesa.UnitaRiferimento.ID)).Sum(item => item.PercentualeRipartizione);
}
// ---------------------------------------------
// Calcolo Importo Competenza
// ---------------------------------------------
var importoCompetenzaProprietario = spesa.GetImporto() * spesa.GetMovimentoRiferimento().GetPercentualePagata(anno, detrazione) * percentualeProprieta;
if (tipoSoggetto == TipoSoggetto.Proprietario)
importoCompetenza = importoCompetenzaProprietario;
else
importoCompetenza = spesa.GetImporto() * spesa.GetMovimentoRiferimento().GetPercentualePagata(anno, detrazione) - importoCompetenzaProprietario;
}
return importoCompetenza;
}
public void CloneRipartizioneByMovimento(MovimentoContabile movimentoNew, MovimentoContabile movimentoOld)
{
IList<MillesimoDTO> millesimi = new List<MillesimoDTO>();
if(!movimentoOld.ContoRiferimento.IsSpesePersonali)
millesimi = (from item in _millesimiService.GetByConto(movimentoOld.ContoRiferimento, null , null, movimentoOld.Testata.EsercizioRiferimento)
where
(
from item2 in movimentoOld.DettaglioRipartizione
where item2?.UnitaRiferimento != null
select item2.UnitaRiferimento.ID
).Contains(item.IdUnitaRiferimento)
select item).ToList();
var count = movimentoOld.DettaglioRipartizione.Count;
foreach (var spesaUnita in movimentoOld.DettaglioRipartizione)
{
decimal? importo = 0;
if (movimentoOld.ContoRiferimento.IsSpesePersonali)
importo = movimentoNew.GetImportoConSegno() / count;
else if(spesaUnita.UnitaRiferimento != null)
importo = _millesimiService.GetRipartoImporto(spesaUnita.UnitaRiferimento, movimentoOld.ContoRiferimento, movimentoNew.GetImportoConSegno().GetValueOrDefault(), millesimi, movimentoOld.Testata.EsercizioRiferimento, null);
else
_log.WarnFormat("ATTENZIONE: trovato movimento NON di spese personali con dettaglio ripartizione senza unità definita - {0} - idSpesaUnita:{1} - idMovimentoInteressi:{2} - idMovimentoBase:{3}", Utility.GetMethodDescription(), spesaUnita.ID, movimentoNew.ID, movimentoOld.ID);
if (importo > 0)
{
var spesaNew = new SpeseUnita(importo, spesaUnita.UnitaRiferimento, spesaUnita.SoggettoCondominio, movimentoNew);
_daoFactory.GetSpeseUnitaDao().SaveOrUpdate(spesaNew);
}
}
if (movimentoNew.Importo != movimentoNew.DettaglioRipartizione.Sum(item => item.Importo))
_log.WarnFormat("ATTENZIONE: l'importo degli interessi/sanzione non corrisponde con con l'importo della ripartizione - {0} - idMovimentoInteressi:{1} - idMovimentoBase:{2} - importoInteressi:{3} - importoRipartizione:{4}", Utility.GetMethodDescription(), movimentoNew.ID, movimentoOld.ID, movimentoNew.Importo.GetValueOrDefault(), movimentoNew.DettaglioRipartizione.Sum(item => item.Importo).GetValueOrDefault());
}