public List<CalcoloSubentroDTO> GetCalcoloSubentro(int idCondominio, DateTime data, PersonaDTO personaEntrante, int idPersonaUscente, int idUnitaImmobiliarePrincipale, List<UnitaImmobiliareListaDTO> unitaImmobiliari, TipoSoggetto tipoSubentro, TipoRendiconto tipoRendiconto)
{
var idUnitaImmobiliari = unitaImmobiliari.Select(unita => unita.Id).ToList();
var result = GetServiceClient().GetCalcoloSubentro(idCondominio, data, personaEntrante, idPersonaUscente, idUnitaImmobiliarePrincipale, idUnitaImmobiliari, tipoSubentro, tipoRendiconto, GetUserInfo());
CloseService();
return new List<CalcoloSubentroDTO>(result.OrderBy(item => item.OrdineConto).ToList());
}
/// <summary>
/// Crea un Subentro valido
/// </summary>
public Subentro(Condominio condominio, DateTime data, TipoSoggetto tipoSubentro, string oggettoLettera, string testoLettera, decimal competenzeUscente, decimal competenzeEntrante, bool trasferimentoSaldi, LogTransazione logTransazione)
{
Condominio = condominio;
Data = data;
TipoSubentro = tipoSubentro;
TrasferimentoSaldi = trasferimentoSaldi;
OggettoLettera = oggettoLettera;
TestoLettera = testoLettera;
CompetenzeEntrante = competenzeEntrante;
CompetenzeUscente = competenzeUscente;
LogTransazione = logTransazione;
if (LogTransazione != null)
LogTransazione.Subentri.Add(this);
}
public List<UnitaImmobiliareListaDTO> GetByPersonaCondominio(int idPersona, int idCondominio, TipoSoggetto tipoSoggetto, DateTime dataRiferimento)
{
try
{
var result = new List<UnitaImmobiliareListaDTO>();
switch (tipoSoggetto)
{
case TipoSoggetto.Proprietario:
result = GetServiceClient().GetUnitaImmobiliariByProprietarioCondominio(idPersona, idCondominio, dataRiferimento, GetUserInfo());
break;
case TipoSoggetto.Conduttore:
result = GetServiceClient().GetUnitaImmobiliariByConduttoreCondominio(idPersona, idCondominio, dataRiferimento, GetUserInfo());
break;
}
CloseService();
return result;
}
catch (CommunicationObjectAbortedException ex)
{
_log.DebugFormat("Errore nella chiamata al servizio - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), Login.Instance.CurrentLogin().Azienda);
}
catch (CommunicationObjectFaultedException ex)
{
_log.DebugFormat("Errore nella chiamata al servizio - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), Login.Instance.CurrentLogin().Azienda);
}
catch (CommunicationException ex)
{
_log.DebugFormat("Errore nella chiamata al servizio - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), Login.Instance.CurrentLogin().Azienda);
}
catch (IOException ex)
{
_log.DebugFormat("Errore nella chiamata al servizio - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), Login.Instance.CurrentLogin().Azienda);
}
catch (ObjectDisposedException ex)
{
_log.DebugFormat("Errore nella chiamata al servizio - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), Login.Instance.CurrentLogin().Azienda);
return new List<UnitaImmobiliareListaDTO>();
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella chiamata al servizio - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), Login.Instance.CurrentLogin().Azienda);
throw;
}
return new List<UnitaImmobiliareListaDTO>();
}
public void LoadProprietari(UnitaImmobiliareDTO unitaImmobiliare, IReloadControl parentForm, bool loadSoggetti = true)
{
try
{
if (loadSoggetti && !backgroundWorkerLoadSoggetti.IsBusy)
backgroundWorkerLoadSoggetti.RunWorkerAsync(new LoadDatiAsyncArguments(unitaImmobiliare.IdCondominio, getPersonaService(), getSoggettoService()));
}
catch (Exception ex)
{
_log.ErrorFormat("Errore durante il caricamento asincrono - {0} - condominio:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), unitaImmobiliare.IdCondominio, Security.Login.Instance.CurrentLogin().Azienda);
}
_parentForm = parentForm;
_unitaImmobiliare = unitaImmobiliare;
_tipoSoggetto = TipoSoggetto.Proprietario;
soggettoCondominioDTOBindingSource.DataSource = _unitaImmobiliare.Proprietari;
lista.DataBind();
if (_unitaImmobiliare.Proprietari != null)
loadValueLists();
if (lista.DisplayLayout != null)
{
lista.DisplayLayout.Bands[0].Columns["DataInizio"].SortIndicator = SortIndicator.Descending;
if (lista.Rows.Count > 0)
lista.ActiveRow = lista.Rows[0];
if (lista.DisplayLayout.Bands[0].Columns.Exists("DeleteSelectColumn"))
{
lista.DisplayLayout.Bands[0].Columns["DeleteSelectColumn"].Hidden = true;
lista.DisplayLayout.Bands[0].Columns["DeleteSelectColumn"].ExcludeFromColumnChooser = ExcludeFromColumnChooser.True;
}
}
else
{
if(ParentForm != null)
ParentForm.Close();
}
btnNuovo.Text = "Nuovo Proprietario";
}
public bool LoadData(CondominioDTO condominio, EsercizioDTO esercizio, DateTime dataSubentro, PersonaDTO personaUscente, PersonaDTO personaEntrante, int idUnitaImmobiliarePrincipale, List<UnitaImmobiliareListaDTO> unitaImmobiliari, TipoSoggetto tipoSubentro)
{
_condominio = condominio;
_esercizio = esercizio;
_dataSubentro = dataSubentro;
_personaUscente = personaUscente;
_personaEntrante = personaEntrante;
_idUnitaImmobiliarePrincipale = idUnitaImmobiliarePrincipale;
_unitaImmobiliari = unitaImmobiliari;
_tipoSubentro = tipoSubentro;
calcoloSubentro();
rataSoggettoDTOBindingSource.DataSource = getSubentroService().GetRate(_esercizio, _personaUscente, _unitaImmobiliari);
calcoloRiepilogoSpeseSubentro();
setRiepilogoImporti();
if(listaSpese.DisplayLayout != null)
{
if (listaSpese.DisplayLayout.Bands[0].Summaries.Count == 0)
{
DataGridHelper.AddSummary(listaSpese.DisplayLayout.Bands[0], "ImportoSoggettoEntrante", "c");
DataGridHelper.AddSummary(listaSpese.DisplayLayout.Bands[0], "ImportoSoggettoUscente", "c");
DataGridHelper.AddSummary(listaSpese.DisplayLayout.Bands[0], "ImportoTotale", "c");
}
if (listaRate.DisplayLayout.Bands[0].Summaries.Count == 0)
{
DataGridHelper.AddSummary(listaRate.DisplayLayout.Bands[0], "Importo", "c");
DataGridHelper.AddSummary(listaRate.DisplayLayout.Bands[0], "ImportoPagato", "c");
}
return true;
}
return false;
}
/// <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 LoadConduttori(UnitaImmobiliareDTO unitaImmobiliare, IReloadControl parentForm, bool loadSoggetti = true)
{
if(backgroundWorkerLoadSoggetti.IsBusy)
return;
if(loadSoggetti)
backgroundWorkerLoadSoggetti.RunWorkerAsync(new LoadDatiAsyncArguments(unitaImmobiliare.IdCondominio, getPersonaService(), getSoggettoService()));
_parentForm = parentForm;
_unitaImmobiliare = unitaImmobiliare;
_tipoSoggetto = TipoSoggetto.Conduttore;
soggettoCondominioDTOBindingSource.DataSource = _unitaImmobiliare.Conduttori;
lista.DataBind();
if (_unitaImmobiliare.Conduttori != null)
loadValueLists();
lista.DisplayLayout.Bands[0].Columns["DataInizio"].SortIndicator = SortIndicator.Descending;
if (lista.Rows.Count > 0)
lista.ActiveRow = lista.Rows[0];
if (lista.DisplayLayout.Bands[0].Columns.Exists("DeleteSelectColumn"))
{
lista.DisplayLayout.Bands[0].Columns["DeleteSelectColumn"].Hidden = true;
lista.DisplayLayout.Bands[0].Columns["DeleteSelectColumn"].ExcludeFromColumnChooser = ExcludeFromColumnChooser.True;
}
btnNuovo.Text = "Nuovo Conduttore";
}
private string getKey(int idConto, int? idSottoConto, int idUnita, int idSoggetto, bool accorpamentoUnita, TipoSoggetto tipoSoggetto, bool dettaglioSottoConto)
{
var key = string.Empty;
if (idConto > 0)
{
key = idConto + "_";
if(dettaglioSottoConto)
key = key + idSottoConto.GetValueOrDefault() + "_";
}
key += idUnita;
if (!accorpamentoUnita)
key += "_" + idSoggetto;
switch (tipoSoggetto)
{
case TipoSoggetto.Proprietario:
key += "_PROP";
break;
case TipoSoggetto.Conduttore:
key += "_COND";
break;
}
return key;
}
public EsitoSubentro Conferma(CondominioDTO condominio, PersonaDTO uscente, PersonaDTO entrante, UnitaImmobiliareListaDTO unitaImmobiliarePrincipale, IList<UnitaImmobiliareListaDTO> unitaImmobiliari, DateTime data, IList<CalcoloSubentroDTO> spese, IList<RataSoggettoSubentroDTO> rate, string oggettoLettera, string testoLettera, decimal speseUscente, decimal speseEntrante, TipoSoggetto tipoSubentro, TipoRendiconto tipoRendiconto, bool trasferimentoSaldi)
{
var idUnitaImmobiliari = unitaImmobiliari.Select(unitaImmobiliare => unitaImmobiliare.Id).ToList();
var esito = GetServiceClient().ConfermaSubentro(condominio.ID, uscente.ID, entrante, unitaImmobiliarePrincipale.Id, idUnitaImmobiliari, data, new List<CalcoloSubentroDTO>(spese), new List<RataSoggettoSubentroDTO>(rate), oggettoLettera, testoLettera, speseUscente, speseEntrante, tipoSubentro, tipoRendiconto, trasferimentoSaldi, GetUserInfo());
if(esito.IdPersona != null)
_personaService.AddCacheItem(esito.IdPersona.Value, entrante);
// Aggiorno in una thread separato la lista delle unità immobiliari
_backgroundWorker = new BackgroundWorker();
_backgroundWorker.DoWork += _backgroundWorker_DoWork;
_backgroundWorker.RunWorkerAsync(_cacheService);
CloseService();
return esito;
}
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);
}
public EsitoSubentro ConfermaSubentro(int idCondominio, int idUscente, PersonaDTO entrante, int idUnitaImmobiliarePrincipale, BindingList<int> idUnitaImmobiliari, DateTime data, BindingList<CalcoloSubentroDTO> spese, BindingList<RataSoggettoSubentroDTO> rate, string oggettoLettera, string testoLettera, decimal speseUscente, decimal speseEntrante, TipoSoggetto tipoSubentro, TipoRendiconto tipoRendiconto, bool spostamentoSaldi, UserInfo userinfo)
{
var retryCount = 5;
var success = false;
var windsorRep = new WindsorConfigRepository();
var item = new EsitoSubentro();
while (retryCount >= 0 && !success)
{
try
{
var logTransazione = windsorRep.BeginTransaction(userinfo, true, true);
var subentroService = windsorRep.GetContainer(userinfo.Azienda).Resolve<ISubentroService>();
var esito = subentroService.Conferma(idCondominio, idUscente, entrante, idUnitaImmobiliarePrincipale, idUnitaImmobiliari, data, spese, rate, oggettoLettera, testoLettera, speseUscente, speseEntrante, tipoSubentro, tipoRendiconto, spostamentoSaldi, logTransazione);
windsorRep.Commit(logTransazione);
if (esito.Subentro != null)
esito.EsitoSubentro.IdSubentro = esito.Subentro.ID;
item = esito.EsitoSubentro;
success = true;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella conferma del subentro - TENTATIVO:{0} - {1} - condominio:{2} - azienda:{3} - number:{4}", ex, (6 - retryCount), Utility.GetMethodDescription(), +idCondominio, userinfo.Azienda, getExceptionId(ex));
windsorRep.Rollback();
if (!isRetryException(ex))
throw;
// Add delay here if you wish.
System.Threading.Thread.Sleep(1000 * (6 - retryCount));
retryCount--;
_log.InfoFormat("Conferma del Subentro - INIZIO TENTATIVO:{0} - {1} - condominio:{2} - azienda:{3}", (6 - retryCount), Utility.GetMethodDescription(), idCondominio, userinfo.Azienda);
}
}
// Tutte le modifiche devono subire un rollback perchè è stato creato un subentro temporaneo per semplificare i calcoli
windsorRep.Rollback();
return item;
}
public void LoadSoggetti(CondominioDTO condominio, IReloadControl parentForm, bool loadAsync)
{
_condominio = condominio;
_parentForm = parentForm;
_tipoSoggetto = TipoSoggetto.Soggetto;
if (_condominio.ID != 0)
{
if (!_dataAsyncLoaded || !loadAsync)
_dataSourceSoggetti = getSoggettoService().GetByCondominio(condominio.ID);
soggettoCondominioDTOBindingSource.DataSource = _dataSourceSoggetti;
lista.DataBind();
if (_dataSourceSoggetti != null)
loadValueLists();
}
CustomControlProperties customProp;
if (lista.Tag == null)
{
customProp = new CustomControlProperties();
lista.Tag = customProp;
}
else
customProp = (CustomControlProperties)lista.Tag;
customProp.AllowAddNew = AllowAddNew.No;
customProp.AllowUpdate = Infragistics.Win.DefaultableBoolean.True;
customProp.AllowDelete = Infragistics.Win.DefaultableBoolean.False;
}
/// <summary>
/// Conferma del subentro.
/// Se la persona entrante è null si tratta di un subentro di conduzione in cui l'appartamento rimane sfitto
/// </summary>
/// <param name="idCondominio">Condominio in cui è avvenuto il subentro</param>
/// <param name="idUscente">Soggetto Uscente</param>
/// <param name="entrante">Soggetto Entrante</param>
/// <param name="idUnitaImmobiliarePrincipale">Unità immobiliare principale</param>
/// <param name="idUnitaImmobiliari">Unità immobiliari per le quali è avvenuto il subentro</param>
/// <param name="data">Data del subentro</param>
/// <param name="spese">Spese di competenza tra uscente e entrante</param>
/// <param name="rate">Rate eventualmente modficare</param>
/// <param name="testoLettera"></param>
/// <param name="speseUscente"></param>
/// <param name="speseEntrante"></param>
/// <param name="tipoSubentro">Tipo di subentro</param>
/// <param name="tipoRendiconto">Rendiconto sul quale di basano i calcoli del subentro</param>
/// <param name="oggettoLettera">Oggetto della lettera di subentro</param>
/// <param name="spostamentoSaldi">Identifica se deve essere eseguito il trasferimento automatico dei saldi e delle rate</param>
/// <param name="logTransazione">Log della transazione per permettere il salvataggio tramite cascade</param>
/// <returns>Esito del subentro</returns>
public EsitoSubentroDomain Conferma(int idCondominio, int idUscente, PersonaDTO entrante, int idUnitaImmobiliarePrincipale, IList<int> idUnitaImmobiliari, DateTime data, IList<CalcoloSubentroDTO> spese, IList<RataSoggettoSubentroDTO> rate, string oggettoLettera, string testoLettera, decimal speseUscente, decimal speseEntrante, TipoSoggetto tipoSubentro, TipoRendiconto tipoRendiconto, bool spostamentoSaldi, LogTransazione logTransazione)
{
try
{
var fatalMessage = string.Empty;
var warnMessage = string.Empty;
var condominio = _daoFactory.GetCondominioDao().GetById(idCondominio, false);
var esercizio = _daoFactory.GetEsercizioDao().GetEsercizioCompetenza(condominio, data);
if(esercizio == null)
return new EsitoSubentroDomain(new EsitoSubentro(null, null, "La data del subentro non è corretta, verificare che sia aperto l'esercizio di competenza", null,null), null);
// ==========================================================================
// Persone
// ==========================================================================
Persona personaEntrante = null;
if (entrante != null)
{
// se l'ID è correttamente valorizzato è stata scelta una persona già presente in anagrafica
personaEntrante = entrante.ID > 0 ? _daoFactory.GetPersonaDao().GetById(entrante.ID, false) : _personaService.SetNew(entrante);
}
// ==========================================================================
// Subentro
// ==========================================================================
var subentro = new GestioneCondomini.Domain.Subentro(
condominio,
data,
tipoSubentro,
oggettoLettera,
testoLettera,
speseUscente,
speseEntrante,
spostamentoSaldi,
logTransazione
)
{
SaldoUscente = _saldiCondominiService.GetSaldoByPersonaUnitaImmobiliari(esercizio.ID, new List<int> { idUscente }, idUnitaImmobiliari, true)
};
// ==========================================================================
// Registro i nuovi condomini
// ==========================================================================
SoggettoCondominio soggettoEntrantePrincipale = null;
SoggettoCondominio soggettoUscentePrincipale = null;
SoggettoCondominio proprietarioPrincipale = null;
foreach (var idUnitaImmobiliare in idUnitaImmobiliari)
{
// -----------------------------
// Soggetto Entrante
// -----------------------------
var unita = _daoFactory.GetUnitaImmobiliareDao().GetById(idUnitaImmobiliare, false);
var proprietario = unita.GetProprietarioPrincipale(esercizio.DataChiusura);
SoggettoCondominio soggettoEntrante = null;
ISet<SoggettoCondominio> soggetti = null;
switch (tipoSubentro)
{
case TipoSoggetto.Conduttore:
if (personaEntrante != null)
soggettoEntrante = new Conduttore(unita, personaEntrante);
soggetti = unita.Conduttori;
break;
case TipoSoggetto.Proprietario:
if (personaEntrante != null)
soggettoEntrante = new Proprietario(unita, personaEntrante);
soggetti = unita.Proprietari;
break;
case TipoSoggetto.Soggetto:
if (personaEntrante != null)
soggettoEntrante = new SoggettoCondominio(unita, personaEntrante);
soggetti = unita.Soggetti;
break;
}
if (soggettoEntrante != null)
soggettoEntrante.IsResidente = _soggettoService.IsResidente(soggettoEntrante);
// -----------------------------
// Soggetto Uscente
// -----------------------------
// Nel caso di subentro di conduzione se il conduttore non è presente il soggetto
// uscente è il proprietario.
// -----------------------------
SoggettoCondominio soggettoUscente = null;
var soggettiUscenti = soggetti.Where(item => item.Persona.ID == idUscente).ToList();
if (soggettiUscenti.Count > 0)
{
if (soggettiUscenti.Count > 1)
{
_log.WarnFormat("Trovati più di un soggetto con la stessa persona anagrafica - PROPRIETARIO - {0} - unità immobiliare:{1} - condominio:{2} - uscente:{3} - entrante:{4}", Utility.GetMethodDescription(), unita?.ID.ToString(CultureInfo.InvariantCulture) ?? "<NULL>", idCondominio, idUscente, entrante != null ? entrante.DisplayName : "<NULL>");
}
soggettoUscente = soggettiUscenti.FirstOrDefault();
}
if (soggettoUscente != null)
soggettoUscente.DataFine = data;
else if (tipoSubentro == TipoSoggetto.Conduttore)
{
soggettiUscenti = unita.Proprietari.Where(item => item.Persona.ID == idUscente).ToList();
if (soggettiUscenti.Count > 0)
{
if (soggettiUscenti.Count > 1)
{
_log.WarnFormat("Trovati più di un soggetto con la stessa persona anagrafica - CONDUTTORE - {0} - unità immobiliare:{1} - condominio:{2} - uscente:{3} - entrante:{4}", Utility.GetMethodDescription(), unita?.ID.ToString(CultureInfo.InvariantCulture) ?? "<NULL>", idCondominio, idUscente, entrante != null ? entrante.DisplayName : "<NULL>");
}
soggettoUscente = soggettiUscenti.FirstOrDefault();
}
}
// soggettoEntrante = null l'unità immobiliare è rimasta sfitta
if (soggettoEntrante != null)
{
soggettoEntrante.DataInizio = data;
if (soggettoUscente != null)
{
soggettoEntrante.PercentualeRiferimento = soggettoUscente.PercentualeRiferimento;
soggettoEntrante.Principale = soggettoUscente.Principale;
}
else
{
soggettoEntrante.PercentualeRiferimento = 1m;
soggettoEntrante.Principale = true;
}
_daoFactory.GetSoggettoCondominioDao().SaveOrUpdate(soggettoEntrante);
}
else
soggettoEntrante = proprietario;
// -----------------------------
// Unità Immobiliare
// -----------------------------
var subentroUnita = new SubentroUnitaImmobiliare(subentro, unita, soggettoEntrante, soggettoUscente);
if (unita.ID == idUnitaImmobiliarePrincipale)
{
subentroUnita.Principale = true;
soggettoUscentePrincipale = soggettoUscente;
soggettoEntrantePrincipale = soggettoEntrante;
proprietarioPrincipale = proprietario;
}
//-------------------------------------
// Se presenti accorpamenti li annullo
//-------------------------------------
if (soggettoUscente != null && soggettoUscente.SoggettiCollegati.Count > 0)
{
warnMessage = string.Format("Il soggetto uscente aveva degli accorpamenti di rate configurati.{0}Gli accorpamenti sono stati eliminati.{0}", Environment.NewLine);
foreach (var soggettoCondominio in soggettoUscente.SoggettiCollegati)
soggettoCondominio.SoggettoPrincipale = null;
soggettoUscente.SoggettiCollegati.Clear();
}
unita.Descrizione = _daoFactory.GetUnitaImmobiliareDao().GetUnitaImmobiliareDescrizione(unita);
}
//--------------------------------
// Dettagli
//--------------------------------
foreach(var calcoloSubentro in spese)
{
// Uscente
// -------------
var dettaglioSubentroUscente = new DettaglioSubentro(subentro, _daoFactory.GetContoDao().GetById(calcoloSubentro.IdConto, false), soggettoUscentePrincipale, calcoloSubentro.ImportoSoggettoUscente, calcoloSubentro.GiorniUscente.Value, TipoDettaglioSubentro.Uscente);
// Entrante
// -------------
var dettaglioSubentroEntrante = new DettaglioSubentro(subentro, _daoFactory.GetContoDao().GetById(calcoloSubentro.IdConto, false), soggettoEntrantePrincipale, calcoloSubentro.ImportoSoggettoEntrante, calcoloSubentro.GiorniEntrante.Value, TipoDettaglioSubentro.Entrante);
}
// ==========================================================================
// Rate
// ==========================================================================
string descrizione;
if(soggettoUscentePrincipale != null)
descrizione = "Subentro: " + soggettoUscentePrincipale.DisplayName + " - " + soggettoEntrantePrincipale.DisplayName;
else
descrizione = "Subentro: " + proprietarioPrincipale.DisplayName + " - " + soggettoEntrantePrincipale.DisplayName;
var listaRateDaEmettere = new Dictionary<DateTime, Dictionary<int, RataSoggettoDTO>>();
foreach (var rataSubentro in rate)
{
var rata = _daoFactory.GetRataSoggettoDao().GetById(rataSubentro.ID, false);
// ----------------------------------------------------------
// Cancellazione o richiamo rata originale
// ----------------------------------------------------------
if (rataSubentro.Eliminare || rataSubentro.AssegnareAEntrante)
fatalMessage += _rateService.EliminazioneRataSoggetto(rata, descrizione);
// ----------------------------------------------------------
// Modifica importo rata
// ----------------------------------------------------------
else if (rataSubentro.Importo != rata.Importo)
{
var rataAggiornamento = new RataSoggettoAggiornamentoDTO
{
DataScadenza = rata.DataScadenza,
Id = rata.ID,
IdEsercizio = rata.Esercizio.ID,
IdSoggettoCondominio = rata.Soggetto.ID,
Importo = rataSubentro.Importo
};
IList<RataSoggettoAggiornamentoDTO> rateAggiornamento = new List<RataSoggettoAggiornamentoDTO>(1);
rateAggiornamento.Add(rataAggiornamento);
_rateService.AggiornaImporti(rateAggiornamento, false, TipoAccorpamentoRateEnum.Nessuno, logTransazione);
}
// ----------------------------------------------------------
// Creazione nuova rata da emettere
// ----------------------------------------------------------
if (rataSubentro.AssegnareAEntrante)
{
Dictionary<int, RataSoggettoDTO> listaRate;
if (listaRateDaEmettere.ContainsKey(rata.DataScadenza))
listaRate = listaRateDaEmettere[rata.DataScadenza];
else
{
listaRate = new Dictionary<int, RataSoggettoDTO>();
listaRateDaEmettere.Add(rata.DataScadenza, listaRate);
}
if (rataSubentro.AssegnareAEntrante)
addRataDaEmettere(soggettoEntrantePrincipale, esercizio, rata, listaRate, rataSubentro.Importo);
}
}
fatalMessage += _rateService.CreazioneRateFuoriPreventivo(esercizio, listaRateDaEmettere, true, descrizione, logTransazione);
// ==========================================================================
// Spostamento saldi
// - Solo se il tipo di subentro corrisponde con con il tipo di soggetto uscente
// ==========================================================================
if (spostamentoSaldi && soggettoUscentePrincipale.Tipo == tipoSubentro)
{
var messageSpostamento = SpostamentoSaldi(subentro);
if (!string.IsNullOrEmpty(messageSpostamento.FatalMessage))
fatalMessage += messageSpostamento.FatalMessage;
if (!string.IsNullOrEmpty(messageSpostamento.WarnMessage))
warnMessage += messageSpostamento.WarnMessage;
}
int? idPersonaEntrante = null;
if (personaEntrante != null)
idPersonaEntrante = personaEntrante.ID;
// ==========================================================================
// Leggo le eventuali ripartizioni personalizzate
// ==========================================================================
var soggettiRipartizione = _daoFactory.GetSoggettoCondominioRipartizioneDao().GetBySoggetto(soggettoUscentePrincipale.ID);
var soggettiRipartizioneDto = new List<SoggettoCondominioRipartizioneDTO>(soggettiRipartizione.Count);
soggettiRipartizioneDto.AddRange(soggettiRipartizione.Select(item => new SoggettoCondominioRipartizioneDTO
{
ID = item.ID,
DescrizioneConto = item.Conto.Descrizione,
IdConto = item.Conto.ID,
DescrizioneSoggetto =
item.Soggetto.DisplayName,
IdSoggetto = item.Soggetto.ID,
IdUnitaImmobiliare = item.Soggetto.UnitaImmobiliare.ID,
PercentualeRipartizione = item.PercentualeRipartizione,
DirittoReale = (item.Soggetto.DirittoReale != null) ? item.Soggetto.DirittoReale.GetValueOrDefault().ToString() : string.Empty,
Tipo = item.Soggetto.Tipo
}));
var esitoSubentro = new EsitoSubentro(idPersonaEntrante, subentro.ID, fatalMessage, warnMessage, soggettiRipartizioneDto);
return new EsitoSubentroDomain(esitoSubentro, subentro);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore durante la conferma del subentro - {0} - idCondominio:{1} - idUscente:{2} - entrante:{3}", ex, Utility.GetMethodDescription(), idCondominio, idUscente, entrante != null ? entrante.DisplayName : "<NULL>");
throw;
}
}
public IList<PersonaCondominioDTO> GetPersoneByEsercizio(EsercizioDTO esercizio, DateTime? data, TipoSoggetto tipoSoggetto)
{
var result = tipoSoggetto == TipoSoggetto.Proprietario ? GetServiceClient().GetPersoneProprietariByEsercizio(esercizio.ID, data, GetUserInfo()) : GetServiceClient().GetPersoneConduttoriByEsercizio(esercizio.ID, data, GetUserInfo());
CloseService();
return result.OrderBy(item => item.OrdineUnitaImmobiliare).ToList();
}
public IList<SoggettoPeriodo> GetSoggettoPeriodoBySubentriUnitaImmobiliare(int idUnitaImmobiliare, int idEsercizio, TipoSoggetto tipo, IList<SubentroUnitaImmobiliare> subentri, IDictionary<int, IList<SoggettoCondominio>> soggetti, SoggettoCondominio soggettoItem)
{
try
{
var result = new List<SoggettoPeriodo>();
var esercizio = _daoFactory.GetEsercizioDao().Find(idEsercizio, false);
if (esercizio != null)
{
var unitaImmobiliare = _daoFactory.GetUnitaImmobiliareDao().Find(idUnitaImmobiliare, false);
if (unitaImmobiliare != null)
{
var presenteConduttore = soggetti[idUnitaImmobiliare].Any(item => item.Tipo == TipoSoggetto.Conduttore);
// ===============================================================================================================================================================
// Se è una spesa di proprietà devo considerare solo i subentri di proprietà, altrimenti occorre considerare tutti i subentri indipendentemente dal tipo
// ------------------------------------------------------------------------------------------------------------------------------------------------------------
// UPDATE: Per le spese di conduzione considero: i subentri di conduzione ma anche quelli in cui l'appartamento è rimasto sfitto - bugid#4624 / bugid#4716
// ===============================================================================================================================================================
IList<SubentroUnitaImmobiliare> subentriOrdinati;
if(tipo == TipoSoggetto.Proprietario)
subentriOrdinati = subentri.Where(item => item.Unita.ID == idUnitaImmobiliare).Where(item => item.Subentro.TipoSubentro == tipo).OrderBy(item => item.Subentro.Data).ToList();
else
subentriOrdinati = subentri.Where(item => item.Unita.ID == idUnitaImmobiliare).Where(item => !presenteConduttore || item.Subentro.TipoSubentro == tipo || item.Subentro.TipoSubentro != item.SoggettoEntrante.Tipo).OrderBy(item => item.Subentro.Data).ToList();
// ===============================================================================================================================================================
var oldData = esercizio.DataApertura.GetValueOrDefault();
SoggettoCondominio soggettoEntrante = null;
foreach (var subentroUnitaImmobiliare in subentriOrdinati)
{
result.Add(new SoggettoPeriodo(subentroUnitaImmobiliare.SoggettoUscente, oldData, subentroUnitaImmobiliare.Subentro.Data));
oldData = subentroUnitaImmobiliare.Subentro.Data.AddDays(1);
soggettoEntrante = subentroUnitaImmobiliare.SoggettoEntrante;
}
// Aggiungo l'ultimo periodo
if (soggettoEntrante != null)
result.Add(new SoggettoPeriodo(soggettoEntrante, oldData, esercizio.DataChiusura.GetValueOrDefault()));
// Se non ho elaborato subentri per questa unità immobiliare ma esiste almeno un subentro per la stessa devo, per avere un valore corretto dei totali aggiungere il proprietario
// pe rl'intero lasso di tempo
if (subentriOrdinati.Count == 0 && tipo == TipoSoggetto.Proprietario)
{
subentriOrdinati = subentri.Where(item => item.Unita.ID == idUnitaImmobiliare).OrderBy(item => item.Subentro.Data).ToList();
if (subentriOrdinati.Count > 0)
{
if (soggettoItem == null)
soggettoItem = unitaImmobiliare.GetProprietarioPrincipale(esercizio.DataChiusura);
result.Add(new SoggettoPeriodo(soggettoItem, esercizio.DataApertura.GetValueOrDefault(), esercizio.DataChiusura.GetValueOrDefault()));
}
}
}
}
else
{
_log.WarnFormat("Usato esercizio inesistente - {0} - esercizio:{1}", Utility.GetMethodDescription(), idEsercizio);
}
return result;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore durante la elborazione dei subentri per ottenere la lista di permanenza nella unità immobiliare - {0} - unità:{1}", ex, Utility.GetMethodDescription(), idUnitaImmobiliare);
throw;
}
}
public decimal GetImportoCompetenza(decimal importo, Conto conto, SottoConto sottoconto, TipoSoggetto tipoSoggetto)
{
decimal importoCompetenza;
var percentualeProprieta = conto.PercentualeProprieta;
if (sottoconto?.PercentualeProprieta != null)
percentualeProprieta = sottoconto.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, 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 IList<CalcoloSubentroDTO> GetCalcoloSubentro(int idCondominio, DateTime data, PersonaDTO personaEntrante, int idPersonaUscente, int idUnitaImmobiliarePrincipale, IList<int> unitaImmobiliari, TipoSoggetto tipoSubentro, TipoRendiconto tipoRendiconto)
{
var calcolo = new List<CalcoloSubentroDTO>();
try
{
var condominio = _daoFactory.GetCondominioDao().GetById(idCondominio, false);
var esercizioCorrente = _daoFactory.GetEsercizioDao().GetEsercizioCompetenza(condominio, data);
if (esercizioCorrente != null)
{
// Confermo temporaneamente il subentro per poter leggere gli importi corretti dal rendiconto
var esitoSubentroDomain = Conferma(idCondominio, idPersonaUscente, personaEntrante, idUnitaImmobiliarePrincipale, unitaImmobiliari, data, new List<CalcoloSubentroDTO>(), new List<RataSoggettoSubentroDTO>(), string.Empty, string.Empty, 0, 0, tipoSubentro, tipoRendiconto, false, null);
if (esitoSubentroDomain.Subentro != null)
_daoFactory.GetSubentroDao().SaveOrUpdate(esitoSubentroDomain.Subentro);
// -------------------------------------------
// Recupero lista con id dei soggetti
// -------------------------------------------
var soggetti = _daoFactory.GetSoggettoCondominioDao().GetByCondominioPersona(idCondominio, idPersonaUscente).ToList();
var idPersonaEntrante = esitoSubentroDomain.EsitoSubentro.IdPersona.GetValueOrDefault();
soggetti.AddRange(_daoFactory.GetSoggettoCondominioDao().GetByCondominioPersona(idCondominio, idPersonaEntrante));
var idSoggetti = new List<int>(soggetti.Count);
idSoggetti.AddRange(from soggetto in soggetti where unitaImmobiliari.Contains(soggetto.UnitaImmobiliare.ID) select soggetto.ID);
// -------------------------------------------
// Decodifico il rendiconto sul quale devono basarsi i calcoli
// -------------------------------------------
IEnumerable<ReportRipartizioneBilancioDTO> rendicontoRiferimento = null;
switch (tipoRendiconto)
{
case TipoRendiconto.Consuntivo:
rendicontoRiferimento = _bilancioService.GetDataSourceRipartizioneBilancioConsuntivo(esercizioCorrente.ID, null, null, null, null, null, null, true, false, TipoAccorpamentoRateEnum.Nessuno, false, true, false, false, null);
break;
case TipoRendiconto.Preventivo:
rendicontoRiferimento = _bilancioService.GetDataSourceRipartizioneBilancioPreventivo(esercizioCorrente.ID, null, null, true, false, TipoAccorpamentoRateEnum.Nessuno, false, false, false, true, false, null);
break;
}
if (rendicontoRiferimento != null)
{
// -------------------------------------------
// Decodifico il tipo di subentro
// -------------------------------------------
var codiceTipoSubentro = string.Empty;
switch (tipoSubentro)
{
case TipoSoggetto.Proprietario:
codiceTipoSubentro = "PROP";
break;
case TipoSoggetto.Conduttore:
codiceTipoSubentro = "COND";
break;
}
// -------------------------------------------
// Elaboro il rendiconto
// -------------------------------------------
var righeRendiconto = from item in rendicontoRiferimento
where idSoggetti.Contains(item.IdPartecipante) &&
item.Importo != null &&
item.IdConto > 0
select item;
if (tipoSubentro == TipoSoggetto.Conduttore && soggetti.Any(item => item.Tipo == TipoSoggetto.Proprietario))
righeRendiconto = righeRendiconto.Where(item => item.TipoNominativo == codiceTipoSubentro);
var rendicontoPerConto = righeRendiconto.GroupBy(item => item.IdConto);
foreach (var item in rendicontoPerConto)
{
try
{
var conto = _daoFactory.GetContoDao().GetById(item.Key, false);
var rigaUscente = item.FirstOrDefault(riga => riga.IdPersona == idPersonaUscente);
var rigaEntrante = item.FirstOrDefault(riga => riga.IdPersona == idPersonaEntrante);
var giorniCompetenzaUscente = 0;
var giorniCompetenzaEntrante = 0;
if (rigaUscente != null)
giorniCompetenzaUscente = rigaUscente.GiorniCompetenza.GetValueOrDefault();
if (rigaEntrante != null)
giorniCompetenzaEntrante = rigaEntrante.GiorniCompetenza.GetValueOrDefault();
int giorniComplessivi = giorniCompetenzaEntrante + giorniCompetenzaUscente;
if (giorniComplessivi > 0)
{
// calcolo importi
var importoUscente = item.Where(riga => riga.IdPersona == idPersonaUscente).Sum(riga => riga.Importo.GetValueOrDefault());
var importoEntrante = item.Where(riga => riga.IdPersona == idPersonaEntrante).Sum(riga => riga.Importo.GetValueOrDefault());
var dettaglioCalcolo = new CalcoloSubentroDTO
{
Key = "CONTO",
Codice = conto.Codice,
Descrizione = conto.Descrizione,
GiorniEntrante = giorniCompetenzaEntrante,
GiorniUscente = giorniCompetenzaUscente,
IdConto = conto.ID,
OrdineConto = conto.Ordine,
ImportoSoggettoEntrante = importoEntrante,
ImportoSoggettoUscente = importoUscente
};
if (conto.IsSpesePersonali)
{
const string hql = "FROM SpeseUnita SP WHERE SP.MovimentoRiferimento.Testata.EsercizioRiferimento = :esercizio AND SP.MovimentoRiferimento.ContoRiferimento = :conto AND SP.UnitaRiferimento.ID IN (:unitaImmobiliari)";
var spese = _daoFactory.GetSpeseUnitaDao().GetByQuery(hql, new QueryParam("esercizio", esercizioCorrente), new QueryParam("conto", conto), new QueryParam("unitaImmobiliari", unitaImmobiliari));
foreach (var spesa in spese)
{
var importo = _ripartizioneSpeseService.GetImportoCompetenza(spesa, tipoSubentro, null, null);
var importoSpesaUscente = importo;
var dettaglioSpesa = new CalcoloSubentroDettaglioDTO
{
AssegnareAEntrante = false,
AssegnareAUscente = false,
Descrizione = spesa.MovimentoRiferimento.GetDescrizione(),
ImportoSoggettoEntrante = null,
ImportoSoggettoUscente = importoSpesaUscente,
ImportoSpesa = importo,
CodiceTestataMovimento = spesa.MovimentoRiferimento.Testata.ID
};
if (spesa.MovimentoRiferimento.DettaglioRiferimento != null)
{
dettaglioSpesa.CodiceSpesa = spesa.MovimentoRiferimento.DettaglioRiferimento.SpesaRiferimento.ID;
dettaglioSpesa.NumeroFattura = spesa.MovimentoRiferimento.DettaglioRiferimento.SpesaRiferimento.NumeroDocumento;
dettaglioSpesa.DataFattura = spesa.MovimentoRiferimento.DettaglioRiferimento.SpesaRiferimento.DataDocumento;
dettaglioSpesa.Fornitore = spesa.MovimentoRiferimento.DettaglioRiferimento.SpesaRiferimento.FornitoreRiferimento.DisplayName;
}
dettaglioCalcolo.Dettaglio.Add(dettaglioSpesa);
}
}
calcolo.Add(dettaglioCalcolo);
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella elaborazione del rendiconto per il calcolo del subentro - {0} - condominio:{1} - conto:{2}", ex, Utility.GetMethodDescription(), idCondominio, item.Key);
throw;
}
}
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel calcolo del subentro - {0} - condominio:{1}", ex, Utility.GetMethodDescription(), idCondominio);
throw;
}
return calcolo;
}
public IList<CalcoloSubentroDTO> GetCalcoloSubentro(int idCondominio, DateTime data, PersonaDTO personaEntrante, int idPersonaUscente, int idUnitaImmobiliarePrincipale, IList<int> unitaImmobiliari, TipoSoggetto tipoSubentro, TipoRendiconto tipoRendiconto, UserInfo userinfo)
{
var retryCount = 5;
var success = false;
var windsorRep = new WindsorConfigRepository();
IList<CalcoloSubentroDTO> item = null;
while (retryCount >= 0 && !success)
{
try
{
windsorRep.BeginTransaction(userinfo);
var subentroService = windsorRep.GetContainer(userinfo.Azienda).Resolve<ISubentroService>();
item = subentroService.GetCalcoloSubentro(idCondominio, data, personaEntrante, idPersonaUscente, idUnitaImmobiliarePrincipale, unitaImmobiliari, tipoSubentro, tipoRendiconto);
// Tutte le modifiche devono subire un rollback perchè è stato creato un subentro temporaneo per semplificare i calcoli
windsorRep.Rollback();
success = true;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel calcolo del subentro - TENTATIVO:{0} - {1} - condominio:{2} - azienda:{3} - number:{4}", ex, (6 - retryCount), Utility.GetMethodDescription(), + idCondominio, userinfo.Azienda, getExceptionId(ex));
windsorRep.Rollback();
if (!isRetryException(ex))
throw;
// Add delay here if you wish.
System.Threading.Thread.Sleep(1000 * (6 - retryCount));
retryCount--;
_log.InfoFormat("Calcolo Subentro - INIZIO TENTATIVO:{0} - {1} - condominio:{2} - azienda:{3}", (6 - retryCount), Utility.GetMethodDescription(), idCondominio, userinfo.Azienda);
}
}
// Tutte le modifiche devono subire un rollback perchè è stato creato un subentro temporaneo per semplificare i calcoli
windsorRep.Rollback();
return item;
}
