public virtual string GetDescrizione(Esercizio esercizio, Condominio condominio, IRipartizioneSpesa movimento)
{
var descrizione = Descrizione;
if (!string.IsNullOrEmpty(descrizione) && descrizione.Contains("$"))
{
try
{
// ==========================================
// Applico il template
// ==========================================
// ------------------------------------------
// Creo le stringhe
// ------------------------------------------
DateTime? dataAperturaEsercizio = null;
DateTime? dataChiusuraEsercizio = null;
var fornitore = string.Empty;
if (esercizio == null && condominio != null)
esercizio = condominio.GetCurrentEsercizioOrdinario();
if (esercizio != null)
{
dataAperturaEsercizio = esercizio.DataApertura.GetValueOrDefault();
dataChiusuraEsercizio = esercizio.DataChiusura.GetValueOrDefault();
}
if (movimento != null && movimento.FornitoreRiferimento != null)
fornitore = movimento.FornitoreRiferimento.DisplayName;
// ------------------------------------------
// NVelocity
// ------------------------------------------
var memoryEngine = NVelocityEngineFactory.CreateNVelocityMemoryEngine(true);
System.Collections.IDictionary context = new System.Collections.Hashtable();
context.Add("fornitore", fornitore);
if (dataAperturaEsercizio != null)
{
context.Add("dataaperturaesercizio", dataAperturaEsercizio.GetValueOrDefault().ToShortDateString());
context.Add("meseiniziocompetenza", Utility.GetMonthName(dataAperturaEsercizio.Value.Month, false));
context.Add("annoiniziocompetenza", dataAperturaEsercizio.GetValueOrDefault().Year);
}
if (dataChiusuraEsercizio != null)
{
context.Add("datachiusuraesercizio", dataChiusuraEsercizio.GetValueOrDefault().ToShortDateString());
context.Add("mesefinecompetenza", Utility.GetMonthName(dataChiusuraEsercizio.Value.Month, false));
context.Add("annofinecompetenza", dataChiusuraEsercizio.GetValueOrDefault().Year);
}
descrizione = memoryEngine.Process(context, descrizione);
if (!string.IsNullOrEmpty(descrizione))
descrizione = descrizione.Trim();
}
catch (Exception ex)
{
_log.Error("Errore nella applicazione del template per la testata di movimento - " + Utility.GetMethodDescription() + " - id:" + ID, ex);
}
}
return descrizione;
}
private string getBilancioMovimentoKey(IRipartizioneSpesa movimento)
{
return movimento.ID + "_" + Guid.NewGuid();
}
private IEnumerable<SpeseUnitaRipartoDTO> getRiparto(IRipartizioneSpesa movimento, List<IGrouping<int, Millesimo>> millesimiGroupByConto, int? anno, int? detrazione, Esercizio esercizio, bool dettaglioSottoConto)
{
try
{
var importoProprieta = _ripartizioneService.GetImportoCompetenza(movimento.GetImportoConSegno(detrazione != null).GetValueOrDefault(), movimento, TipoSoggetto.Proprietario, anno, detrazione);
var importoConduzione = _ripartizioneService.GetImportoCompetenza(movimento.GetImportoConSegno(detrazione != null).GetValueOrDefault(), movimento, TipoSoggetto.Conduttore, anno, detrazione);
var millesimiConto = millesimiGroupByConto.Where(item => item.Key == movimento.ContoRiferimento.ID).ToList();
var millesimiAttivi = new List<Millesimo>(millesimiConto.Count);
foreach (var millesimoConto in millesimiConto)
{
try
{
var millesimiGroupByUnita = millesimoConto.GroupBy(item => item.UnitaRiferimento.ID).ToList();
foreach (var spesa in movimento.DettaglioRipartizione)
{
try
{
IGrouping<int, Millesimo> millesimi = null;
if (spesa.UnitaRiferimento != null)
millesimi = millesimiGroupByUnita.FirstOrDefault(item => item.Key == spesa.UnitaRiferimento.ID);
else if (spesa.SoggettoCondominio != null)
millesimi = millesimiGroupByUnita.FirstOrDefault(item => item.Key == spesa.SoggettoCondominio.UnitaImmobiliare.ID);
if (millesimi != null)
millesimiAttivi.AddRange(millesimi.ToList());
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel calcolo del riparto - SINGOLA SPESA - {0} - movimento:{1} - anno:{2} - esercizio:{3} - spesa:{4}", ex, Utility.GetMethodDescription(), movimento?.ID.ToString() ?? "<NULL>", anno.GetValueOrDefault(), esercizio?.ID.ToString() ?? "<NULL>", spesa?.ID.ToString() ?? "<NULL>");
throw;
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel calcolo del riparto - SINGOLO CONTO - {0} - movimento:{1} - anno:{2} - esercizio:{3} - conto:{4}", ex, Utility.GetMethodDescription(), movimento?.ID.ToString() ?? "<NULL>", anno.GetValueOrDefault(), esercizio?.ID.ToString() ?? "<NULL>", millesimoConto.Key);
throw;
}
}
IList<SpeseUnitaRipartoDTO> lista = new List<SpeseUnitaRipartoDTO>();
if (millesimiAttivi.Count > 0)
{
var totaleMillesimi = millesimiAttivi.Sum(item => item.Valore);
if (totaleMillesimi > 0)
{
foreach (var millesimo in millesimiAttivi)
{
// Se è definita devo usare la ripartizione specifica per conto
// ---------------------------------------------------------------------------------
var importoProprietario = (importoProprieta * millesimo.Valore) / totaleMillesimi;
var importoConduttore = (importoConduzione * millesimo.Valore) / totaleMillesimi;
var importi = getImportoProprietaConduzioneByUnita(movimento.ContoRiferimento, importoProprietario, importoConduttore, millesimo.UnitaRiferimento.ID);
var riparto = new SpeseUnitaRipartoDTO
{
IdConto = movimento.ContoRiferimento.ID,
IdUnita = millesimo.UnitaRiferimento.ID,
ValoreMillesimo = millesimo.Valore,
UnitaMisuraMillesimo = "PC",
ImportoProprietario = importi[0],
ImportoConduttore = importi[1]
};
if (dettaglioSottoConto)
{
if (movimento.SottoContoRiferimento != null)
riparto.IdSottoConto = movimento.SottoContoRiferimento.ID;
else
riparto.IdSottoConto = movimento.ID*-1;
}
lista.Add(riparto);
}
}
else
{
_log.WarnFormat("Totale millesimi a 0 - {0} - movimento:{1} - esercizio:{2} - anno:{3} - azienda:{4}", Utility.GetMethodDescription(), movimento.ID.ToString(), esercizio?.ID.ToString(CultureInfo.InvariantCulture) ?? "<NULL>", anno, esercizio?.CondominioRiferimento.Azienda.ID.ToString(CultureInfo.InvariantCulture) ?? "<NULL>");
}
}
else
{
var millesimiAttiviDto = _millesimiService.GetByConto(movimento.ContoRiferimento, null, null, esercizio);
var totaleMillesimi = millesimiAttiviDto.Sum(item => item.Valore.GetValueOrDefault());
if (totaleMillesimi > 0)
{
foreach (var millesimo in millesimiAttiviDto)
{
// Se è definita devo usare la ripartizione specifica per conto
// ---------------------------------------------------------------------------------
var importoProprietario = (importoProprieta * millesimo.Valore) / totaleMillesimi;
var importoConduttore = (importoConduzione * millesimo.Valore) / totaleMillesimi;
var importi = getImportoProprietaConduzioneByUnita(movimento.ContoRiferimento, importoProprietario, importoConduttore, millesimo.IdUnitaRiferimento);
var riparto = new SpeseUnitaRipartoDTO
{
IdConto = movimento.ContoRiferimento.ID,
IdUnita = millesimo.IdUnitaRiferimento,
ValoreMillesimo = millesimo.Valore,
UnitaMisuraMillesimo = "PC",
ImportoProprietario = importi[0],
ImportoConduttore = importi[1]
};
if (dettaglioSottoConto)
{
if (movimento.SottoContoRiferimento != null)
riparto.IdSottoConto = movimento.SottoContoRiferimento.ID;
else
riparto.IdSottoConto = movimento.ID * -1;
}
lista.Add(riparto);
}
}
else
{
_log.WarnFormat("Totale millesimi a 0 - {0} - movimento:{1} - esercizio:{2} - anno:{3} - azienda:{4}", Utility.GetMethodDescription(), movimento.ID.ToString(), esercizio?.ID.ToString(CultureInfo.InvariantCulture) ?? "<NULL>", anno, esercizio?.CondominioRiferimento.Azienda.ID.ToString(CultureInfo.InvariantCulture) ?? "<NULL>");
}
}
return lista;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel calcolo del riparto - {0} - movimento:{1} - anno:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), movimento?.ID.ToString() ?? "<NULL>", anno.GetValueOrDefault(), esercizio?.ID.ToString() ?? "<NULL>");
throw;
}
}
protected bool isAddebitatoScala(IRipartizioneSpesa movimento, int idScala)
{
if (!string.IsNullOrEmpty(movimento.GruppiAddebito))
{
var scale = movimento.GruppiAddebito.Split('&');
if (scale.Contains(idScala.ToString()))
return true;
}
return false;
}
private decimal getImporto(IRipartizioneSpesa movimento, int? idStabile, int? idScala, Dictionary<string, IList<MillesimoDTO>> millesimiConto, Esercizio esercizio, int? detrazione)
{
if (movimento.DettaglioRipartizione.Count == 0 || !string.IsNullOrEmpty(movimento.GruppiAddebito) || !string.IsNullOrEmpty(movimento.StabiliAddebito))
{
var key = movimento.ContoRiferimento.ID.ToString(CultureInfo.InvariantCulture);
List<int> stabili = null;
List<int> scale = null;
if (!string.IsNullOrEmpty(movimento.StabiliAddebito))
{
stabili = new List<int>();
key += "|" + movimento.StabiliAddebito;
stabili.AddRange(movimento.StabiliAddebito.Split('&').Select(int.Parse));
}
if (!string.IsNullOrEmpty(movimento.GruppiAddebito))
{
scale = new List<int>();
key += "|" + movimento.GruppiAddebito;
scale.AddRange(movimento.GruppiAddebito.Split('&').Select(int.Parse));
}
IList<MillesimoDTO> millesimiTotali = null;
if (millesimiConto.ContainsKey(key))
millesimiTotali = millesimiConto[key];
if (millesimiTotali == null)
millesimiTotali = _millesimiService.GetByConto(movimento.ContoRiferimento, stabili, scale, esercizio);
// ---------------------------------------------------------------------------------------------------------------------------------------------
// se la scala o lo stabile a cui è stato addebitato il movimento non comprende lo stabile o la scala di riferimento devo scartare il movimento
if ((idStabile != null || idScala != null) && (stabili != null || scale != null))
{
if (idStabile != null && stabili != null && !stabili.Contains(idStabile.Value))
return 0;
else if (idStabile != null && scale != null)
{
var stabiliCheck = new List<int>();
foreach (var i in scale)
{
var scala = _daoFactory.GetGruppoStabileDao().Find(i, false);
if (scala != null)
stabiliCheck.Add(scala.PalazzinaRiferimento.ID);
}
if (!stabiliCheck.Contains(idStabile.Value))
return 0;
}
else if (idScala != null && stabili != null)
{
var scaleToCheck = new List<int>();
foreach (var i in stabili)
{
var stabile = _daoFactory.GetPalazzinaDao().Find(i, false);
if (stabile != null)
scaleToCheck.AddRange(stabile.GruppiStabile.Select(gruppoStabile => gruppoStabile.ID));
if (!scaleToCheck.Contains(idScala.Value))
return 0;
}
}
else if (idScala != null && !scale.Contains(idScala.Value))
return 0;
}
// ---------------------------------------------------------------------------------------------------------------------------------------------
IList<MillesimoDTO> millesimiMovimento = null;
if (idStabile != null)
{
key = $"{movimento.ContoRiferimento.ID}|{idStabile}";
if (millesimiConto.ContainsKey(key))
millesimiMovimento = millesimiConto[key];
if (millesimiMovimento == null)
{
// bugid#7195
// Se il movimento haun addebito diretto su alcune scale, per calcolare i millesimi di riferimento per lo stabile selezionato devo utilizzare
// SOLO le scale con addebito del movimento presenti nello stabile selezionato.
// Usando l'intero stabile i calcoli non sono corretti perchè sono considerate anche scale a cui NON è stato addebitato il movimento
if(!string.IsNullOrEmpty(movimento.StabiliAddebito) || scale == null)
millesimiMovimento = _millesimiService.GetByConto(movimento.ContoRiferimento, new List<int> { idStabile.Value }, null, esercizio);
else
{
var scaleMovimento = new List<int>();
foreach (var i in scale)
{
var scala = _daoFactory.GetGruppoStabileDao().Find(i, false);
if(scala != null && scala.PalazzinaRiferimento.ID == idStabile.Value)
scaleMovimento.Add(i);
millesimiMovimento = _millesimiService.GetByConto(movimento.ContoRiferimento, null, scaleMovimento, esercizio);
}
}
}
}
if (idScala != null)
{
key = $"{movimento.ContoRiferimento.ID}|{idScala}";
if (millesimiConto.ContainsKey(key))
millesimiMovimento = millesimiConto[key];
if (millesimiMovimento == null)
millesimiMovimento = _millesimiService.GetByConto(movimento.ContoRiferimento, null, new List<int> { idScala.Value }, esercizio);
}
if (millesimiMovimento != null)
{
var denominatore = millesimiTotali.Sum(item => item.Valore.GetValueOrDefault());
var numeratore = millesimiMovimento.Sum(item => item.Valore.GetValueOrDefault());
if (denominatore != 0)
return (movimento.GetImportoConSegno(detrazione != null).GetValueOrDefault() * numeratore) / denominatore;
else if (millesimiMovimento.Sum(item => item.Valore.GetValueOrDefault()) == 0)
return movimento.GetImportoConSegno(detrazione != null).GetValueOrDefault();
else
{
throw new InvalidDataException($"La somma totale dei millesimi è 0 mentre la somma dei millesimi conti è <> 0 - {Utility.GetMethodDescription()} - esercizio:{esercizio?.ID.ToString() ?? "<NULL>"}");
}
}
}
else if (movimento.DettaglioRipartizione.Count > 0 && (idStabile != null || idScala != null))
{
var importo = 0m;
foreach (var spesaUnita in movimento.DettaglioRipartizione)
{
UnitaImmobiliare unita = null;
if (spesaUnita.UnitaRiferimento != null)
unita = spesaUnita.UnitaRiferimento;
else if (spesaUnita.SoggettoCondominio != null)
unita = spesaUnita.SoggettoCondominio.UnitaImmobiliare;
if(unita != null)
{
if (idStabile != null && unita.GruppoStabileRiferimento.PalazzinaRiferimento.ID == idStabile.Value)
importo += spesaUnita.GetImporto();
else if (idScala != null && unita.GruppoStabileRiferimento.ID == idScala.Value)
importo += spesaUnita.GetImporto();
}
}
return importo;
}
return movimento.GetImportoConSegno(detrazione != null).GetValueOrDefault();
}
protected bool isAddebitatoStabile(IRipartizioneSpesa movimento, int idStabile)
{
if(!string.IsNullOrEmpty(movimento.StabiliAddebito))
{
var stabili = movimento.StabiliAddebito.Split('&');
if (stabili.Contains(idStabile.ToString()))
return true;
}
return false;
}
public DataTable GetUnitaDataSourceByMovimento(string key, IRipartizioneSpesa movimento, Conto contoDetrazione)
{
try
{
DataTable table;
DateTime dataRiferimento = DateTime.Today;
var movimentoContabile = movimento as MovimentoContabile;
if (movimentoContabile != null)
dataRiferimento = movimentoContabile.Testata.DataRegistrazione.GetValueOrDefault();
if (key != null && _unitaSelezionate.ContainsKey(key))
table = _unitaSelezionate[key];
else
{
table = GetEmptyUnitaDataSource();
var conto = movimento.ContoRiferimento;
if (contoDetrazione != null)
conto = contoDetrazione;
if (conto.Ripartizione)
{
if (!conto.IsSpesePersonali)
{
var listaUnita = _daoFactory.GetUnitaImmobiliareDao().GetByCondominio(conto.CondominioRiferimento.ID);
foreach (var unita in listaUnita)
{
var row = table.NewRow();
row["IdUnitaImmobiliare"] = unita.ID;
row["Nominativo"] = unita.Descrizione;
if(unita.Ordine != null)
row["Ordine"] = unita.Ordine;
row["Interno"] = unita.InternoCompleto;
row["TipoUnita"] = unita.TipoUnitaImmobiliare.Descrizione;
row["ParentId"] = unita.GruppoStabileRiferimento.ID;
row["ParentName"] = unita.GruppoStabileRiferimento.Descrizione;
row["Selezionato"] = !movimento.IsRipartoPersonalizzato && !conto.IsSpesePersonali && contoDetrazione == null;
var spesa = (from s in movimento.DettaglioRipartizione
where s.UnitaRiferimento != null && s.UnitaRiferimento.ID == unita.ID
select s).SingleOrDefault();
if (spesa != null)
{
if (conto.IsSpesePersonali && spesa.Importo != null)
row["Importo"] = spesa.Importo;
if (spesa.Importo != null || movimento.IsRipartoPersonalizzato || contoDetrazione != null)
row["Selezionato"] = true;
}
table.Rows.Add(row);
}
}
else
{
// Se conto è di spese personali il dettaglio della ripartizione deve sempre essere per soggetto mai per unità immobiliare
// La correzzione è necessaria per ragioni di compatibilità dopo il bugid#2926
foreach (var speseUnita in movimento.DettaglioRipartizione)
{
if (speseUnita.SoggettoCondominio == null && speseUnita.UnitaRiferimento != null)
{
if (conto.PercentualeProprieta > 0)
speseUnita.SoggettoCondominio = speseUnita.UnitaRiferimento.GetProprietarioPrincipale(dataRiferimento);
else
{
var conduttore = speseUnita.UnitaRiferimento.GetConduttorePrincipale(dataRiferimento) ??
speseUnita.UnitaRiferimento.GetProprietarioPrincipale(dataRiferimento);
speseUnita.SoggettoCondominio = conduttore;
}
speseUnita.UnitaRiferimento = null;
}
}
var soggetti = _daoFactory.GetSoggettoCondominioDao().GetAttiviByCondominioData(movimento.GetEsercizio().CondominioRiferimento.ID, null, null, movimento.GetEsercizio().DataApertura.GetValueOrDefault());
foreach (var soggetto in soggetti)
{
try
{
var row = table.NewRow();
row["IdSoggettoCondominio"] = soggetto.ID;
row["Nominativo"] = soggetto.DisplayName;
row["Interno"] = soggetto.UnitaImmobiliare.InternoCompleto;
if (soggetto.UnitaImmobiliare.Ordine != null)
row["Ordine"] = soggetto.UnitaImmobiliare.Ordine;
row["TipoUnita"] = soggetto.UnitaImmobiliare.TipoUnitaImmobiliare.Descrizione;
row["TipoCondomino"] = soggetto.Tipo.ToString();
row["DirittiReali"] = soggetto.DirittoReale.GetValueOrDefault().Description();
if(soggetto.PercentualeRiferimento != null)
row["PercentualeSpese"] = soggetto.PercentualeRiferimento.GetValueOrDefault();
row["Selezionato"] = false;
row["ParentId"] = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.ID;
row["ParentName"] = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.Descrizione;
var spesa = (from s in movimento.DettaglioRipartizione
where s.SoggettoCondominio != null && s.SoggettoCondominio.ID == soggetto.ID
select s).SingleOrDefault();
if (spesa != null)
{
if (conto.IsSpesePersonali && spesa.Importo != null)
row["Importo"] = spesa.Importo;
if (spesa.Importo != null || movimento.IsRipartoPersonalizzato || contoDetrazione != null)
row["Selezionato"] = true;
}
table.Rows.Add(row);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel calcolo del datasource delle ripartizioni spese (SINGOLO SOGGETTO) - {0} - soggetto:{1} - key:{2} - idMovimento:{3} ", ex, Utility.GetMethodDescription(), soggetto.ID, key, movimento.ID);
throw;
}
}
}
table.AcceptChanges();
}
}
return table;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la creazione del datasource per la ripartizione - {0} - key:{1} - movimento:{2}", ex, Utility.GetMethodDescription(), key, + movimento.ID);
throw;
}
}
public decimal GetImportoCompetenza(decimal importo, IRipartizioneSpesa movimento, TipoSoggetto tipoSoggetto, int? anno, int? detrazione)
{
decimal importoCompetenza;
var contoRiferimento = movimento.ContoRiferimento;
var sottoContoRiferimento = movimento.SottoContoRiferimento;
if (anno != null)
importo = importo*movimento.GetPercentualePagata(anno, detrazione);
var percentualeProprieta = contoRiferimento.PercentualeProprieta;
if (sottoContoRiferimento?.PercentualeProprieta != null)
percentualeProprieta = sottoContoRiferimento.PercentualeProprieta.Value;
if (movimento.PercentualeProprieta != null)
percentualeProprieta = movimento.PercentualeProprieta.Value;
var importoCompetenzaProprietario = importo * percentualeProprieta;
if (tipoSoggetto == TipoSoggetto.Proprietario)
importoCompetenza = importoCompetenzaProprietario;
else
importoCompetenza = importo - importoCompetenzaProprietario;
return importoCompetenza;
}
public decimal GetImportoCompetenza(decimal importo, IRipartizioneSpesa movimento, TipoSoggetto tipoSoggetto)
{
return GetImportoCompetenza(importo, movimento, tipoSoggetto, null, null);
}
public decimal GetImportoCompetenza(decimal? importo, GruppoStabile gruppo, IRipartizioneSpesa movimento, List<int> stabili, List<int> gruppi, TipoSoggetto tipoSoggetto, int? anno, int? detrazione)
{
if (importo == null)
importo = movimento.GetImportoConSegno(detrazione != null).GetValueOrDefault();
if (gruppo == null)
return GetImportoCompetenza(importo.GetValueOrDefault() * movimento.GetPercentualePagata(anno, detrazione), movimento, tipoSoggetto);
var contoRiferimento = movimento.ContoRiferimento;
if (gruppi == null && !string.IsNullOrEmpty(movimento.GruppiAddebito))
gruppi = movimento.GruppiAddebito.Split('&').Select(int.Parse).ToList();
var millesimiTotali = _millesimiService.GetByConto(contoRiferimento, null, gruppi, movimento.GetEsercizio());
if (millesimiTotali.Count > 0)
{
var millesimi = _millesimiService.GetByConto(contoRiferimento, null, new List<int> { gruppo.ID }, movimento.GetEsercizio());
var denominatore = millesimiTotali.Sum(item => item.Valore.GetValueOrDefault());
if(denominatore != 0)
importo = importo.GetValueOrDefault() * millesimi.Sum(item => item.Valore.GetValueOrDefault()) / denominatore;
}
else
importo = movimento.GetImportoConSegno(detrazione != null).GetValueOrDefault();
return GetImportoCompetenza(importo.GetValueOrDefault(), movimento, tipoSoggetto, anno, detrazione);
}
