/// <summary>
/// Crea un Versamento Condomino valido.
/// </summary>
public VersamentoSoggetto(Esercizio esercizio, SoggettoCondominio soggetto, Conto conto, DateTime data, decimal importo, int numeroProtocollo, TipoVersamentoSoggettoEnum tipo, LogTransazione logTransazione, TipoVersamentoDopoChiusuraEnum? tipoVersamentoDopoChiusura = null, TipoVersamentoPrimaAperturaEnum? tipoVersamentoPrimaApertura = null)
{
Esercizio = esercizio;
Soggetto = soggetto;
ContoPatrimoniale = conto;
Data = data;
Importo = importo;
Tipo = tipo;
NumeroProtocollo = numeroProtocollo;
TipoVersamentoDopoChiusura = tipoVersamentoDopoChiusura;
TipoVersamentoPrimaApertura = tipoVersamentoPrimaApertura;
if (Esercizio != null && Esercizio.Gestione == GestioneEsercizioEnum.Straordinario)
{
TipoVersamentoDopoChiusura = null;
TipoVersamentoPrimaApertura = null;
}
if (Soggetto != null)
Soggetto.Versamenti.Add(this);
LogTransazione = logTransazione;
if (LogTransazione != null)
LogTransazione.Versamenti.Add(this);
}
/// <summary>
/// Crea un Dettaglio di spesa valido
/// </summary>
public RipartoConsuntivoSoggettoCondominio(SoggettoCondominio soggetto, Esercizio esercizio, Conto conto, decimal? importo)
{
Importo = importo;
Soggetto = soggetto;
Esercizio = esercizio;
Conto = conto;
}
/// <summary>
/// Crea uno Stabile valido
/// </summary>
public ConvocazioneAssemblea(Assemblea assemblea, SoggettoCondominio convocato)
{
Assemblea = assemblea;
Convocato = convocato;
if (Assemblea != null)
Assemblea.Convocati.Add(this);
}
/// <summary>
/// Crea un Dettaglio di spesa valido
/// </summary>
public SaldoSoggetto(SoggettoCondominio soggetto, Esercizio esercizio, decimal? importo)
{
Importo = importo;
Soggetto = soggetto;
Esercizio = esercizio;
if (Esercizio != null)
Esercizio.Saldi.Add(this);
}
/// <summary>
/// Crea un Versamento Condomino valido.
/// </summary>
public VersamentoSoggetto(Esercizio esercizio, SoggettoCondominio soggetto, Conto conto, DateTime data, decimal importo, FileCBI file, DatiBancariCondomini contoBancario, LogTransazione logTransazione, TipoVersamentoDopoChiusuraEnum? tipoVersamentoDopoChiusura = null, TipoVersamentoPrimaAperturaEnum? tipoVersamentoPrimaApertura = null)
: this(esercizio, soggetto, conto, data, importo, 0, TipoVersamentoSoggettoEnum.CBI, logTransazione, tipoVersamentoDopoChiusura, tipoVersamentoPrimaApertura)
{
ContoBancario = contoBancario;
File = file;
if (File != null)
File.Versamenti.Add(this);
}
/// <summary>
/// Crea un Subentro valido
/// </summary>
public SubentroUnitaImmobiliare(Subentro subentro, UnitaImmobiliare unita, SoggettoCondominio soggettoEntrante, SoggettoCondominio soggettoUscente)
{
Subentro = subentro;
Unita = unita;
SoggettoEntrante = soggettoEntrante;
SoggettoUscente = soggettoUscente;
if (Subentro != null)
Subentro.UnitaImmobiliari.Add(this);
}
/// <summary>
/// Crea una Spesa Unità valida
/// </summary>
public SpeseUnita(decimal? importo, UnitaImmobiliare unita, SoggettoCondominio soggettoCondominio, RipartizioneSpesa ripartizioneSpesa)
{
_importo = importo;
_unitaRiferimento = unita;
_soggettoCondominio = soggettoCondominio;
if (ripartizioneSpesa != null)
{
_ripartizioneSpesa = ripartizioneSpesa;
_ripartizioneSpesa.DettaglioRipartizione.Add(this);
}
}
/// <summary>
/// Crea una Spesa Unità valida
/// </summary>
public SpeseUnita(decimal? importo, UnitaImmobiliare unita, SoggettoCondominio soggettoCondominio, MovimentoContabile movimento)
{
_importo = importo;
_unitaRiferimento = unita;
_soggettoCondominio = soggettoCondominio;
if (movimento != null)
{
_movimentoRiferimento = movimento;
_movimentoRiferimento.DettaglioRipartizione.Add(this);
}
}
public ProprietarioDTO GetByDomainEntity(SoggettoCondominio proprietario)
{
try
{
return setDto(proprietario);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel caricamento dei proprietari - {0} - id:{1}", ex, Utility.GetMethodDescription(), proprietario != null ? proprietario.ID.ToString(CultureInfo.InvariantCulture) : "<NULL>");
throw;
}
}
public DettaglioSubentro(Subentro subentro, Conto conto, SoggettoCondominio soggetto, decimal? importo, int giorni, TipoDettaglioSubentro tipo)
{
Subentro = subentro;
Conto = conto;
Soggetto = soggetto;
Importo = importo;
Giorni = giorni;
Tipo = tipo;
if (Subentro != null)
Subentro.Dettagli.Add(this);
}
/// <summary>
/// Crea una rata di pagamento condomino valida.
/// </summary>
public RataSoggetto(Esercizio esercizio, SoggettoCondominio soggetto, DateTime dataScadenza, decimal importo, LogTransazione logTransazione)
{
Esercizio = esercizio;
Soggetto = soggetto;
DataScadenza = dataScadenza;
Importo = importo;
_stato = StatoRataEnum.Inserita;
if (Soggetto != null)
Soggetto.Rate.Add(this);
LogTransazione = logTransazione;
if (LogTransazione != null)
LogTransazione.Rate.Add(this);
}
/// <summary>
/// Crea un sollecito valido.
/// </summary>
public Sollecito(Esercizio esercizio, SoggettoCondominio soggetto, DateTime data, DateTime dataLimiteRate, decimal importoLimite, decimal importoDaVersare, DatiBancariCondomini banca, string oggettoLettera, string testoLettera)
{
Esercizio = esercizio;
Soggetto = soggetto;
Data = data;
DataLimiteRate = dataLimiteRate;
ImportoLimite = importoLimite;
ImportoDaVersare = importoDaVersare;
OggettoLettera = oggettoLettera;
TestoLettera = testoLettera;
Banca = banca;
if (Soggetto != null)
Soggetto.Solleciti.Add(this);
}
public ConvocazioneAssembleaDTO GetBySoggettoCondominio(SoggettoCondominio soggetto)
{
try
{
return setDtoSoggetto(soggetto);
}
catch (Exception ex)
{
if (soggetto != null)
_log.Error("Errore nel caricamento dei convocati dell'assemblea per soggetto: Gipasoft.Business.Sfera.Repository.AssembleaConvocazioneRepository.GetBySoggettoCondominio() - id:" + soggetto.ID.ToString(), ex);
else
_log.Error("Errore nel caricamento dei convocati dell'assemblea per soggetto: Gipasoft.Business.Sfera.Repository.AssembleaConvocazioneRepository.GetBySoggettoCondominio() - Soggetto --> null", ex);
throw;
}
}
/// <summary>
/// Crea una rata di pagamento condomino valida.
/// </summary>
public RataSoggetto(PianoRatealeDettaglio pianoRatealeDettaglio, SoggettoCondominio soggetto, DateTime dataScadenza, decimal importo, LogTransazione logTransazione)
{
PianoRatealeDettaglio = pianoRatealeDettaglio;
Esercizio = PianoRatealeDettaglio.PianoRatealeRiferimento.Esercizio;
Soggetto = soggetto;
DataScadenza = dataScadenza;
Importo = importo;
_stato = StatoRataEnum.Inserita;
if (Soggetto != null)
Soggetto.Rate.Add(this);
if (PianoRatealeDettaglio != null)
PianoRatealeDettaglio.RateSoggetti.Add(this);
LogTransazione = logTransazione;
if (LogTransazione != null)
LogTransazione.Rate.Add(this);
}
public SoggettoCondominio GetSoggettoAttuale(SoggettoCondominio soggetto, Esercizio esercizio, DateTime dataRiferimento)
{
try
{
if (!soggetto.SubentriUscita.Any())
{
var soggettiAttivi = _daoFactory.GetSoggettoCondominioDao().GetAttiviByEsercizioUnita(soggetto.UnitaImmobiliare.ID, esercizio);
if (soggettiAttivi.Any(item => item.ID == soggetto.ID))
return soggetto;
var proprietariPrincipali = soggettiAttivi.Where(item => item.Tipo == TipoSoggetto.Proprietario && item.Principale.GetValueOrDefault()).ToList();
if (soggetto.Tipo == TipoSoggetto.Proprietario && proprietariPrincipali.Any())
return proprietariPrincipali.FirstOrDefault();
if (soggetto.Tipo == TipoSoggetto.Proprietario && !proprietariPrincipali.Any())
return soggetto;
if (soggetto.Tipo == TipoSoggetto.Conduttore)
{
var conduttoriPrincipali = soggettiAttivi.Where(item => item.Tipo == TipoSoggetto.Conduttore && item.Principale.GetValueOrDefault()).ToList();
if (conduttoriPrincipali.Any())
return conduttoriPrincipali.FirstOrDefault();
if (proprietariPrincipali.Any())
return proprietariPrincipali.FirstOrDefault();
return soggetto;
}
return soggetto;
}
var subentro = soggetto.SubentriUscita.Where(item => item.Subentro.Data > dataRiferimento).OrderByDescending(item => item.Subentro.Data).FirstOrDefault();
if (subentro != null && subentro.SoggettoEntrante != null)
return GetSoggettoAttuale(subentro.SoggettoEntrante, esercizio, subentro.Subentro.Data);
return soggetto;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore durante la lettura del soggetto attuale - {0} - soggetto:{1} - esercizio:{2}", ex, Library.Utility.GetMethodDescription(), soggetto.ID, esercizio != null ? esercizio.ID.ToString() : "<NULL>");
throw;
}
}
private ConduttoreDTO setDto(SoggettoCondominio item)
{
try
{
var dto = new ConduttoreDTO
{
Consigliere = item.Consigliere,
DataFine = item.DataFine,
DataInizio = item.DataInizio,
ID = item.ID,
PercentualeRiferimento = item.PercentualeRiferimento,
IdPersona = item.Persona.ID,
IsResidente = item.IsResidente,
DirittoPersonaleGodimento = item.DirittoPersonaleGodimento,
DisplayNominativo = item.DisplayName,
Descrizione = item.Descrizione,
DescrizioneAggiuntiva = item.DescrizioneAggiuntiva
};
if (item.UnitaImmobiliare.GruppoStabileRiferimento != null)
dto.IdCondominio = item.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.CondominioRiferimento.ID;
dto.Tipo = TipoSoggetto.Conduttore;
if (item.ModalitaConvocazione != null)
dto.ModalitaConvocazione = item.ModalitaConvocazione.ToString();
if (item.DirittoReale != null)
dto.DirittoReale = item.DirittoReale.ToString();
if (item.UnitaImmobiliare.Ordine != null)
dto.OrdineUnitaImmobiliare = item.UnitaImmobiliare.Ordine.Value;
if (item.FrazionePossesso != null)
{
dto.NumeratorePossesso = item.FrazionePossesso.Numerator;
dto.DenominatorePossesso = item.FrazionePossesso.Denominator;
dto.Possesso = item.FrazionePossesso.ToString();
}
// Unita immobiliare
dto.IdUnitaImmobiliare = item.UnitaImmobiliare.ID;
dto.DescrizioneUnitaImmobiliare = item.UnitaImmobiliare.Descrizione;
dto.Principale = item.Principale;
dto.VersamentoMav = item.VersamentoMav;
// Soggetto Principale
if (item.SoggettoPrincipale != null)
{
dto.IdSoggettoPrincipale = item.SoggettoPrincipale.ID;
dto.DescrizioneSoggettoPrincipale = item.GetDescrizioneAccorpamento();
}
if (item.SubentriEntrata.Count > 0)
dto.IdSubentroEntrata = Library.IesiGenericCollections<SubentroUnitaImmobiliare>.GetByIndex(item.SubentriEntrata, 0).Subentro.ID;
return dto;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nell'inserimento del conduttore - {0} - id:{1}", ex, Library.Utility.GetMethodDescription(), item.ID);
throw;
}
}
private void addListaSoggettiAccorpati(Dictionary<SoggettoCondominio, IList<SoggettoCondominio>> listaSoggettiAccorpati, ReportRipartizioneBilancioDTO reportRipartizioneBilancioDTO, SoggettoCondominio soggetto, IList<SoggettoCondominio> soggettiAttivi)
{
var soggettoKey = listaSoggettiAccorpati.Keys.FirstOrDefault(item => item.ID == reportRipartizioneBilancioDTO.IdPartecipante);
if (soggettoKey != null)
{
var soggettoValue = listaSoggettiAccorpati[soggettoKey].FirstOrDefault(item => item.ID == soggetto.ID);
if (soggettoValue == null)
listaSoggettiAccorpati[soggettoKey].Add(soggetto);
}
else
{
soggettoKey = soggettiAttivi.FirstOrDefault(item => item.ID == reportRipartizioneBilancioDTO.IdPartecipante) ??
_daoFactory.GetSoggettoCondominioDao().Find(reportRipartizioneBilancioDTO.IdPartecipante, false);
listaSoggettiAccorpati.Add(soggettoKey, new List<SoggettoCondominio> { soggetto });
}
}
private string getNominativoPresso(Persona persona, SoggettoCondominio soggetto, Address indirizzo)
{
try
{
var nominativo = persona.DisplayName;
try
{
if (!string.IsNullOrEmpty(soggetto?.Descrizione))
nominativo = soggetto.Descrizione;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nell'individuazione del nominativo completo di presso - DESCRIZIONE - {0} - persona:{1} - soggetto:{2}", ex, Utility.GetMethodDescription(), persona.ID.ToString(), soggetto?.ID.ToString() ?? "<NULL>");
}
if (!string.IsNullOrEmpty(indirizzo?.Presso))
nominativo += $"{Environment.NewLine}c/o {indirizzo.Presso}";
return nominativo;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nell'individuazione del nominativo completo di presso - {0} - persona:{1} - soggetto:{2}", ex, Utility.GetMethodDescription(), persona?.ID.ToString() ?? "<NULL>", soggetto?.ID.ToString() ?? "<NULL>");
return string.Empty;
}
}
public TestataMovimentoContabile SetMovimentoSpesaPersonale(Esercizio esercizio, TestataMovimentoContabile testata, SoggettoCondominio soggetto, Conto conto, string descrizione, decimal importo, DateTime dataRegistrazione)
{
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("IA");
if (testata == null)
{
testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null) {Descrizione = "Calcolo interessi di mora", IsAllowUpdate = true};
}
// controllo data registrazione
var message = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, testata.DataRegistrazione.GetValueOrDefault());
if (message.Count > 0)
{
var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", testata.DataRegistrazione.GetValueOrDefault()));
_log.FatalFormat("Data di registrazione non valida - {0} - data:{1} - soggetto:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), testata.DataRegistrazione.GetValueOrDefault(), soggetto.ID, esercizio.ID);
throw ex;
}
var movimento = new MovimentoContabile(testata, causale, testata.Movimenti.Count() + 1, conto, importo, "D") {Descrizione = descrizione};
switch (soggetto.Tipo)
{
case TipoSoggetto.Proprietario:
movimento.PercentualeProprieta = 1;
break;
case TipoSoggetto.Conduttore:
movimento.PercentualeProprieta = 0;
break;
}
movimento.IsRipartoPersonalizzato = true;
new SpeseUnita(importo, null, soggetto, movimento);
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
return testata;
}
public TestataMovimentoContabile SetMovimentiSingolaRata(RataSoggetto rata, decimal importo, SoggettoCondominio soggetto, Esercizio esercizio, TestataMovimentoContabile testata, DateTime dataRegistrazione)
{
return null;
var numeroRiga = 0;
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("ER");
var message = IsAllowDataRegistrazione(new List<int> {esercizio.CondominioRiferimento.ID}, esercizio, dataRegistrazione);
if (message.Count > 0)
{
_log.ErrorFormat("Tentativo di registrazione con data esterno all'intervallo consentito - {0} - rata:{1} - importo:{2} - soggetto:{3} - esercizio:{4}", Utility.GetMethodDescription(), rata.ID, importo, soggetto.ID, esercizio.ID);
throw new InvalidDataException(string.Format("Tentativo di registrazione con data esterno all'intervallo consentito - data:{0}", dataRegistrazione.ToShortDateString()));
}
// ------------------------------------------------
// Testata
// ------------------------------------------------
if (testata == null)
{
testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null);
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
}
else
numeroRiga = testata.Movimenti.Max(mov => mov.NumeroRiga.GetValueOrDefault());
// ------------------------------------------------
// Rata
// ------------------------------------------------
numeroRiga++;
var movimentoPatrimoniale = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoRateCondomini()), importo, "A") {CondominoRiferimento = soggetto};
string descrizioneRata;
if (rata != null)
descrizioneRata = "Rata n." + rata.PianoRatealeDettaglio.Progressivo;
else
descrizioneRata = "Rata";
movimentoPatrimoniale.Descrizione = descrizioneRata + " - " + movimentoPatrimoniale.CondominoRiferimento.DisplayName;
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);
// ------------------------------------------------
// Crediti V/S Condomini
// ------------------------------------------------
numeroRiga++;
var movimentoPatrimonialeCrediti = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoVersamentiCondomini()), importo, "D")
{
CondominoRiferimento = soggetto,
Descrizione = movimentoPatrimoniale.Descrizione
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimonialeCrediti);
return testata;
}
/// <summary>
/// Crea una ripartizione tra i diversi soggetti valida
/// </summary>
public SoggettoCondominioRipartizione(Conto conto, SoggettoCondominio soggetto, decimal percentualeRipartizione)
{
Conto = conto;
Soggetto = soggetto;
PercentualeRipartizione = percentualeRipartizione;
}
private bool isAllowDeleteSoggettoSubentro(SoggettoCondominio soggetto, GestioneCondomini.Domain.Subentro subentro)
{
// Se il tipo di subentro non corrisponde col tipo soggetto vuol dire che siamo nel caso di un subentro con unità rimasta sfitta
// in questo caso il soggetto entrante (Proprietario) nelle spese di conduzione non dovrà ovviamente essere eliminato
return subentro.TipoSubentro == soggetto.Tipo &&
soggetto.SubentriEntrata.All(item => item.Subentro.ID == subentro.ID) &&
soggetto.SubentriUscita.All(item => item.Subentro.ID == subentro.ID) &&
soggetto.Versamenti.Count == 0;
}
/// <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;
}
}
private void addRataDaEmettere(SoggettoCondominio soggetto, Esercizio esercizio, RataSoggetto rata, Dictionary<int, RataSoggettoDTO> listaRate, decimal importo)
{
RataSoggettoDTO rataDto;
if (listaRate.ContainsKey(soggetto.ID))
rataDto = listaRate[soggetto.ID];
else
{
rataDto = new RataSoggettoDTO
{
IdSoggettoCondominio = soggetto.ID,
DataScadenza = rata.DataScadenza,
IdEsercizio = esercizio.ID,
DescrizioneEsercizio = esercizio.DisplayName,
IdUnitaImmobiliare = soggetto.UnitaImmobiliare.ID,
IdPersona = soggetto.Persona.ID,
Subalterno = soggetto.UnitaImmobiliare.Subalterno,
Importo = 0
};
listaRate.Add(soggetto.ID, rataDto);
}
rataDto.Importo += importo;
}
private decimal getMillesimoBySoggettoConto(SoggettoCondominio soggetto, int idConto, IList<string> millesimiElaborati, IList<MillesimoDTO> millesimiAttivi)
{
// Se il soggetto è proprietario, il conto è di conduzione, ed è presente per la stessa unità e lo stesso conto un conduttore nel riparto i millesimi NON
// devono essere sommati al proprietario perchè già considerati nella riga del conduttore - Utilizzata lista per memorizzare i millesimi già elaborati bugid#9140
//var millesimo = soggetto.UnitaImmobiliare.Millesimi.FirstOrDefault(item => item.ContoRiferimento.ID == idConto);
if (millesimiAttivi != null)
{
var millesimo = millesimiAttivi.FirstOrDefault(item => item.IdUnitaRiferimento == soggetto.UnitaImmobiliare.ID);
if (millesimo != null && !millesimiElaborati.Contains($"{millesimo.IdUnitaRiferimento}&{millesimo.IdContoRiferimento}"))
{
millesimiElaborati.Add($"{millesimo.IdUnitaRiferimento}&{millesimo.IdContoRiferimento}");
return millesimo.Valore.GetValueOrDefault();
}
}
else
{
var millesimo = soggetto.UnitaImmobiliare.Millesimi.FirstOrDefault(item => item.ContoRiferimento.ID == idConto);
if (millesimo != null && !millesimiElaborati.Contains($"{millesimo.UnitaRiferimento.ID}&{millesimo.ContoRiferimento.ID}"))
{
millesimiElaborati.Add($"{millesimo.UnitaRiferimento.ID}&{millesimo.ContoRiferimento.ID}");
return millesimo.Valore.GetValueOrDefault();
}
}
return 0;
}
private DateTime getDataUscita(SoggettoCondominio soggetto)
{
var data = DateTime.MaxValue;
if (soggetto.DataFine != null)
data = soggetto.DataFine.GetValueOrDefault();
return data;
}
public ConduttoreDTO GetByDomainEntity(SoggettoCondominio conduttore)
{
try
{
return setDto(conduttore);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel caricamento dei conduttori - {0} - id:{1}", ex, Library.Utility.GetMethodDescription(), conduttore != null ? conduttore.ID.ToString(CultureInfo.InvariantCulture) : "<NULL>");
throw;
}
}
/// <summary>
/// Consente di individuare se il condomino è residente confrontando l'indirizzo della persona con quello del condominio
/// </summary>
/// <remarks>Per stabilire se gli indirizzi corrispondono viene usato un componente di terze parti <see cref="http://www.shuffletext.com/Default.aspx"/></remarks>
/// <param name="soggetto">Condomino</param>
/// <returns>Ritorna true se è residente altrimenti false</returns>
public bool IsResidente(SoggettoCondominio soggetto)
{
if (soggetto != null && soggetto.IsResidente == null && soggetto.UnitaImmobiliare != null && soggetto.UnitaImmobiliare.GruppoStabileRiferimento != null && soggetto.Persona != null && soggetto.Persona.IndirizzoResidenza != null && !string.IsNullOrEmpty(soggetto.Persona.IndirizzoResidenza.Indirizzo))
{
try
{
var condominio = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.CondominioRiferimento;
if (condominio.Indirizzo != null)
{
var person = new SearchableDictionary<int>();
var fuzzy = new FuzzySearch<int>();
var query = new Query(QuerySearchOption.And, new NameSynonymThesaurusReader(), 0.75);
var scope = new IntellisenseScope<int>();
var persona = soggetto.Persona;
var indirizzoSoggetto = persona.IndirizzoResidenza.GetIndirizzoCompleto();
var indirizzoCondominio = condominio.Indirizzo.GetIndirizzoCompleto();
if (!string.IsNullOrEmpty(indirizzoSoggetto) && !string.IsNullOrEmpty(indirizzoCondominio))
{
person.Add(persona.ID, string.Format("{0}", indirizzoSoggetto));
fuzzy.Add(persona.ID, "Indirizzo", indirizzoSoggetto);
query.Clear();
query.CreateSearchTerm("Indirizzo", indirizzoCondominio, 0.20, true);
var fuzzyResult = fuzzy.Search(query, scope, 1);
return fuzzyResult.Count > 0 && fuzzyResult[0].Rank > 1;
}
return true;
}
}
catch (Exception ex)
{
_log.Warn("Errore inaspettato durante il set di residente - " + Library.Utility.GetMethodDescription(), ex);
return false;
}
}
return false;
}
private SoggettoCondominio getSoggettoFromRate(IList<RataSoggetto> rate, SoggettoCondominio soggetto)
{
var rataSoggetto = rate.FirstOrDefault(item => item.Soggetto.Persona.ID == soggetto.Persona.ID);
if (rataSoggetto != null)
soggetto = rataSoggetto.Soggetto;
return soggetto;
}
private List<ReportRipartizioneBilancioDTO> elaboraSoggetto(SoggettoCondominio soggetto, IEnumerable<SoggettoCondominio> soggettiAttivi, IList<ReportRipartizioneBilancioDTO> totali, Esercizio esercizio, bool accorpamentoUnita)
{
try
{
if (totali.All(item => item.IdPartecipante != soggetto.ID))
{
var fakeItem = new ReportRipartizioneBilancioDTO
{
IdPartecipante = soggetto.ID,
IdPersona = soggetto.Persona.ID,
IdUnitaImmobiliare = soggetto.UnitaImmobiliare.ID,
TipoUnitaImmobiliare = soggetto.UnitaImmobiliare.TipoUnitaImmobiliare.Descrizione,
Nominativo = soggetto.DisplayName,
OrdineUnitaImmobiliare = soggetto.UnitaImmobiliare.Ordine.GetValueOrDefault(),
SubalternoUnitaImmobiliare = soggetto.UnitaImmobiliare.Subalterno,
PianoUnitaImmobiliare = soggetto.UnitaImmobiliare.Piano,
InternoUnitaImmobiliare = getInternoUnitaImmobiliare(soggetto.UnitaImmobiliare),
OrdineStabile = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.Ordine,
OrdineGruppoStabile = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.Ordine,
DescrizioneStabile = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.Descrizione,
DescrizioneGruppoStabile = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.Descrizione,
IdStabile = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.ID,
IdGruppoStabile = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.ID,
TipoNominativo = (soggetto.Tipo == TipoSoggetto.Proprietario) ? "PROP" : "COND",
TipoNominativoEffettivo = soggetto.Tipo.ToString().Substring(0, 1),
CodiceConto = "666",
DisabilitaStampaMillesimi = true,
Importo = 0,
DataUscitaPartecipante = getDataUscita(soggetto),
OrdinePartecipante = soggetto.Tipo == TipoSoggetto.Proprietario ? 10 : 20
};
if (accorpamentoUnita)
{
var propPrincipale = (from item in soggettiAttivi
where item.Tipo == TipoSoggetto.Proprietario && item.Principale.GetValueOrDefault() && item.UnitaImmobiliare.ID == soggetto.UnitaImmobiliare.ID
select item).SingleOrDefault();
// Se il proprietario non è presente lo cerco tra tutti i proprietari
if (propPrincipale == null)
{
propPrincipale = (from item in soggetto.UnitaImmobiliare.Proprietari
where item.DataInizio == null || item.DataInizio.Value < esercizio.DataChiusura
orderby item.DataInizio.GetValueOrDefault() descending
select item).FirstOrDefault();
_log.DebugFormat("Non trovato proprietario principale - {0} - unità:{1} - esercizio:{2}", Utility.GetMethodDescription(), soggetto.UnitaImmobiliare.ID, esercizio.ID);
}
if (propPrincipale != null)
{
fakeItem.IdPartecipante = propPrincipale.ID;
fakeItem.IdPersona = propPrincipale.Persona.ID;
}
fakeItem.Nominativo = soggetto.UnitaImmobiliare.Descrizione;
}
totali.Add(fakeItem);
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la lettura del datasource per il riparto del consuntivo - FAKE - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), esercizio.ID);
throw;
}
return totali.ToList();
}