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());
}
public List<RendicontoAnnualeDTO> GetByEsercizio(int idEsercizio, TipoRendiconto? tipo)
{
try
{
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
var lista = daoFactory.GetRendicontoAnnualeDao().GetByEsercizio(idEsercizio);
return (from rendiconto in lista where tipo == null || tipo == rendiconto.Tipo select setDto(rendiconto)).ToList();
}
catch (Exception ex)
{
_log.Error("Errore nel caricamento dei rendiconti annuali - " + Library.Utility.GetMethodDescription() + " - id:" + idEsercizio, ex);
throw;
}
}
public override string StoricizzaRiparto(int idEsercizio, TipoRendiconto tipoRendiconto)
{
try
{
var message = string.Empty;
// ==================================================
// Elimino eventuali storici precedenti
// ==================================================
var listaStorico = _daoFactory.GetStoricoRipartoDao().GetByEsercizioTipo(idEsercizio, tipoRendiconto);
foreach (var storicoRiparto in listaStorico)
_daoFactory.GetStoricoRipartoDao().Delete(storicoRiparto);
IEnumerable<ReportRipartizioneBilancioDTO> riparto = new List<ReportRipartizioneBilancioDTO>();
switch (tipoRendiconto)
{
case TipoRendiconto.Consuntivo:
riparto = GetDataSourceRipartizioneBilancioConsuntivo(idEsercizio, null, null, null, null, null, null, false, false, TipoAccorpamentoRateEnum.Nessuno, true, false, false, false, null, true);
break;
case TipoRendiconto.Preventivo:
riparto = GetDataSourceRipartizioneBilancioPreventivo(idEsercizio, null, null, false, false, TipoAccorpamentoRateEnum.Nessuno, true, true, false, false, false, null, true);
break;
}
if (riparto != null)
{
var esercizio = _daoFactory.GetEsercizioDao().GetById(idEsercizio, false);
foreach (var reportRipartizioneBilancioDTO in riparto)
{
try
{
var storico = new StoricoRiparto(esercizio)
{
Anno = null,
CodiceConto = reportRipartizioneBilancioDTO.CodiceConto.Truncate(3),
DescrizioneConto = reportRipartizioneBilancioDTO.DescrizioneConto.Truncate(255),
CodiceSottoConto = reportRipartizioneBilancioDTO.CodiceSottoConto.Truncate(7),
DescrizioneSottoConto = reportRipartizioneBilancioDTO.DescrizioneSottoConto.Truncate(255),
DescrizioneGruppoStabile = reportRipartizioneBilancioDTO.DescrizioneGruppoStabile.Truncate(256),
DescrizioneStabile = reportRipartizioneBilancioDTO.DescrizioneStabile.Truncate(256),
DisabilitaStampaMillesimi = reportRipartizioneBilancioDTO.DisabilitaStampaMillesimi,
IdConto = reportRipartizioneBilancioDTO.IdConto,
IdSottoConto = reportRipartizioneBilancioDTO.IdSottoConto,
IdGruppoStabile = reportRipartizioneBilancioDTO.IdGruppoStabile,
IdPartecipante = reportRipartizioneBilancioDTO.IdPartecipante > 0 ? (int?)reportRipartizioneBilancioDTO.IdPartecipante : null,
IdPersona = reportRipartizioneBilancioDTO.IdPersona > 0 ? (int?)reportRipartizioneBilancioDTO.IdPersona : null,
IdRendiconto = reportRipartizioneBilancioDTO.IdRendiconto,
IdStabile = reportRipartizioneBilancioDTO.IdStabile,
IdUnitaImmobiliare = reportRipartizioneBilancioDTO.IdUnitaImmobiliare,
Importo = reportRipartizioneBilancioDTO.Importo,
InternoUnitaImmobiliare = reportRipartizioneBilancioDTO.InternoUnitaImmobiliare.Truncate(20),
Millesimi = reportRipartizioneBilancioDTO.Millesimi,
Nominativo = reportRipartizioneBilancioDTO.Nominativo.Truncate(512),
NumeroColonne = reportRipartizioneBilancioDTO.NumeroColonne,
OrdineConto = reportRipartizioneBilancioDTO.OrdineConto,
OrdineGruppoStabile = reportRipartizioneBilancioDTO.OrdineGruppoStabile,
OrdineStabile = reportRipartizioneBilancioDTO.OrdineStabile,
OrdineUnitaImmobiliare = reportRipartizioneBilancioDTO.OrdineUnitaImmobiliare,
SubalternoUnitaImmobiliare = reportRipartizioneBilancioDTO.SubalternoUnitaImmobiliare.Truncate(20),
PianoUnitaImmobiliare = reportRipartizioneBilancioDTO.PianoUnitaImmobiliare.Truncate(10),
Tipo = tipoRendiconto,
TipoNominativo = reportRipartizioneBilancioDTO.TipoNominativo.Truncate(10),
TipoNominativoEffettivo = reportRipartizioneBilancioDTO.TipoNominativoEffettivo.Truncate(10),
TipoUnitaImmobiliare = reportRipartizioneBilancioDTO.TipoUnitaImmobiliare.Truncate(512),
UnitaMisuraMillesimi = reportRipartizioneBilancioDTO.UnitaMisuraMillesimi.Truncate(10),
GiorniCompetenza = reportRipartizioneBilancioDTO.GiorniCompetenza,
IdStabileAddebito = reportRipartizioneBilancioDTO.IdStabileAddebito,
IdGruppoStabileAddebito = reportRipartizioneBilancioDTO.IdGruppoStabileAddebito,
};
_daoFactory.GetStoricoRipartoDao().SaveOrUpdate(storico);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la storicizzazione del riparto - SINGOLO ELEMENTO - {0} - conto:{1} - esercizio:{2} - tipo:{3}", ex, Utility.GetMethodDescription(), reportRipartizioneBilancioDTO.IdConto, idEsercizio, tipoRendiconto);
throw;
}
}
}
return message;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la storicizzazione del riparto - SINGOLO ELEMENTO - {0} - esercizio:{1} - tipo:{2}", ex, Utility.GetMethodDescription(), idEsercizio, tipoRendiconto);
throw;
}
}
private ResultRiparto getRipartoDatasource(int idEsercizio, int? idStabile, int? idScala, bool? proprietarioConduttore, bool accorpamentoUnitaValore, TipoAccorpamentoRateEnum tipoAccorpamento, TipoRendiconto tipoRendiconto)
{
try
{
var dataSource = tipoRendiconto == TipoRendiconto.Consuntivo ? getBilancioService().GetRipartizioneConsuntivo(idEsercizio, idStabile, idScala, proprietarioConduttore, accorpamentoUnitaValore, addebitiCondominio.Checked, addebitiDirettiStabileScala.Checked, tipoAccorpamento, null) : getBilancioService().GetRipartizionePreventivo(idEsercizio, idStabile, idScala, proprietarioConduttore, accorpamentoUnitaValore, getTipoAccorpamento(), stampaSaldi.Checked, addebitiCondominio.Checked, addebitiDirettiStabileScala.Checked, null);
return dataSource;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella lettura del datasource del riparto - {0} - esercizio:{1} - stabile:{2} - scala:{3} - proprietarioConduttore:{4} - accorpamentoUnitaValore:{5} - tipoAccorpamento:{6} - tipoRendiconto:{7} - azienda:{8}", ex, Utility.GetMethodDescription(), idEsercizio, idStabile.GetValueOrDefault(), idScala.GetValueOrDefault(), proprietarioConduttore.GetValueOrDefault(), accorpamentoUnitaValore, tipoAccorpamento, tipoRendiconto, Security.Login.Instance.CurrentLogin().Azienda);
throw;
}
}
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 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 void SalvaBilancio(int idEsercizo, byte[] body, TipoRendiconto tipoRendiconto)
{
GetServiceClient().SalvaBilancio(idEsercizo, body, tipoRendiconto, GetUserInfo());
CloseService();
}
public List<RendicontoAnnualeDTO> GetRendicontiByEsercizio(int idEsercizo, TipoRendiconto? tipo)
{
var result = GetServiceClient().GetRendicontiByEsercizio(idEsercizo, tipo, GetUserInfo());
CloseService();
return result;
}
private BilancioConsuntivoReportParameters getParameters(CondominioDTO condominio, EsercizioDTO esercizio, string noteRtf, TipoRendiconto tipoRendiconto)
{
// ====================================================================
// Descrizione del condominio
// ====================================================================
var righeCondominio = condominio.IndirizzoCompleto.Split('&');
var righeDaPubblicare = new string[4];
if (righeCondominio.Length > 0)
righeDaPubblicare[0] = righeCondominio[0];
for (var i = 1; i < 4; i++)
{
if (righeCondominio.Length > i)
{
if (!string.IsNullOrEmpty(righeDaPubblicare[1]))
righeDaPubblicare[1] += " - ";
righeDaPubblicare[1] += righeCondominio[i];
}
if (i > 1)
righeDaPubblicare[i] = string.Empty;
}
// ====================================================================
// Recupero l'intestazione dello studio
// ====================================================================
var azienda = getAziendaService().GetAzienda();
var intestazioneStudio = azienda.Descrizione;
var viaStudio = string.Empty;
var capStudio = string.Empty;
var localitaStudio = string.Empty;
if (azienda.IndirizzoSede != null)
{
viaStudio = azienda.IndirizzoSede.Indirizzo + " n. " + azienda.IndirizzoSede.Civico;
capStudio = azienda.IndirizzoSede.Cap;
localitaStudio = azienda.IndirizzoSede.DescrizioneComune + " " + azienda.IndirizzoSede.CodiceProvincia;
// Collasso diverse informazioni nel campo viaStudio
viaStudio += " - " + capStudio + " " + localitaStudio;
}
// ====================================================================
// Date Registrazione
// ====================================================================
var dataIniziale = _esercizio.DataApertura.GetValueOrDefault();
var dataFinale = _esercizio.DataChiusura.GetValueOrDefault();
if (dataRegistrazioneIniziale.Value != null)
dataIniziale = dataRegistrazioneIniziale.DateTime;
if (dataRegistrazioneFinale.Value != null)
dataFinale = dataRegistrazioneFinale.DateTime;
// ====================================================================
// Lista Versamenti
// ====================================================================
IList<ImportiDTO> versamenti;
var formVersamenti = new ExecuteLoadDataObjectAsync<ResultImportiDTO>("Sono in corso di caricamento i versamenti ....." + Environment.NewLine + "Si prega di attendere.");
Func<ResultImportiDTO> loadDatiVersamenti = () => getVersamentiCondominiService().GetImportoMovimentiVersatoByEsercizio((int)esercizi.Value, (int?)stabili.Value, (int?)gruppi.Value, null);
formVersamenti.LoadData(loadDatiVersamenti);
formVersamenti.ShowDialog();
if (string.IsNullOrEmpty(formVersamenti.DataSourceObject.FatalMessage))
{
versamenti = formVersamenti.DataSourceObject.Importi;
formVersamenti.Dispose();
}
else
{
CommonMessages.DisplayWarning($"Si sono verificati dei problemi nella lettura dei versamenti dei condomini:{Environment.NewLine}{formVersamenti.DataSourceObject.FatalMessage}");
formVersamenti.Dispose();
return new BilancioConsuntivoReportParameters { TipoReport = TipoReportBilancio.Undefined };
}
var form = new ExecuteLoadDataObjectAsync<ResultImportoSaldo>("Sono in corso di caricamento i saldi ....." + Environment.NewLine + "Si prega di attendere.");
Func<ResultImportoSaldo> loadDati = () => getBilancioService().GetSaldoEsercizioPrecedente((int)esercizi.Value, (int?)stabili.Value, (int?)gruppi.Value);
form.LoadData(loadDati);
form.ShowDialog();
if (string.IsNullOrEmpty(form.DataSourceObject.Message))
{
var saldoEsercizioPrecedente = form.DataSourceObject.Importo;
var reportParameters =
new BilancioConsuntivoReportParameters
(
righeDaPubblicare,
condominio.Codice,
esercizio.DisplayName,
string.Empty,
griglia.Checked,
getTipoDettaglio(),
suddivisioneProprietari.Checked,
TipoReportBilancio.Rendiconto,
tipoRendiconto,
false,
null,
false,
noteRtf,
intestazioneStudio,
viaStudio,
capStudio,
localitaStudio,
versamenti.Sum(item => item.Importo),
saldoEsercizioPrecedente,
esercizio.DataChiusura.GetValueOrDefault(),
parzialeGruppo.Checked,
parzialeStabile.Checked,
false,
false,
TipoAccorpamentoRateEnum.Undefined,
numeroRegistrazioneDatiFattura.Value.ToString(),
false,
salvaBilancio.Checked,
Security.Login.Instance.CurrentLogin().InversioneSaldiCondomini,
dataIniziale,
dataFinale
);
form.Dispose();
return reportParameters;
}
CommonMessages.DisplayWarning($"Si sono verificati dei problemi nella lettura dei saldi condomini:{Environment.NewLine}{form.DataSourceObject.Message}");
return new BilancioConsuntivoReportParameters { TipoReport = TipoReportBilancio.Undefined };
}
public RendicontoAnnuale(Esercizio esercizio, string descrizione, TipoRendiconto tipo)
{
Esercizio = esercizio;
Descrizione = descrizione;
Tipo = tipo;
}
public List<RendicontoAnnualeDTO> GetRendicontiByEsercizio(int idEsercizio, TipoRendiconto? tipo, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var rep = new RendicontoAnnualeRepository(userinfo, windsorRep);
var item = rep.GetByEsercizio(idEsercizio, tipo);
windsorRep.Commit();
return item;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella esecuzione della funzione - {0} - esercizio:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), idEsercizio, userinfo.Azienda);
windsorRep.Rollback();
throw;
}
}
public ResultBilancioPreventivo CalcolaPreventivo(int idEsercizio, int? idStabile, int? idScala, TipoRendiconto riferimentoVariazione, decimal? variazione, bool dettaglioSottoConto, bool copiaEsercizioPrecedente, bool importiEsercizioPrecedente, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var bilancioService = windsorRep.GetContainer(userinfo.Azienda).Resolve<IBilancioService>();
var item = bilancioService.CalcolaPreventivo(idEsercizio, idStabile, idScala, riferimentoVariazione,
variazione, dettaglioSottoConto, copiaEsercizioPrecedente, importiEsercizioPrecedente);
windsorRep.Commit();
return new ResultBilancioPreventivo(item, null);
}
catch (InvalidDataException ex)
{
windsorRep.Rollback();
return new ResultBilancioPreventivo(null, ex.Message);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella esecuzione della funzione - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), userinfo.Azienda);
windsorRep.Rollback();
throw;
}
}
public void SalvaBilancio(int idEsercizio, byte[] bytes, TipoRendiconto tipo, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var bilancioService = windsorRep.GetContainer(userinfo.Azienda).Resolve<IBilancioService>();
bilancioService.SalvaBilancio(idEsercizio, bytes, tipo);
windsorRep.Commit();
}
catch (Exception ex)
{
_log.Error("Errore nella esecuzione della funzione - " + Utility.GetMethodDescription() + " - azienda:" + userinfo.Azienda, ex);
windsorRep.Rollback();
throw;
}
}
private IList<ReportRipartizioneBilancioDTO> getStoricoRiparto(int idEsercizio, int? idStabile, int? idScala, bool addebitiDirettiStabileScala, TipoRendiconto tipo)
{
IList<ReportRipartizioneBilancioDTO> result = new List<ReportRipartizioneBilancioDTO>();
var storico = _daoFactory.GetStoricoRipartoDao().GetByEsercizioTipo(idEsercizio, tipo);
if (storico.Count > 0)
{
var listaStorico = new List<ReportRipartizioneBilancioDTO>(storico.Count);
if (!addebitiDirettiStabileScala)
{
if (idStabile > 0)
storico = storico.Where(item => item.IdStabile == idStabile.GetValueOrDefault()).ToList();
if (idScala > 0)
storico = storico.Where(item => item.IdGruppoStabile == idScala.GetValueOrDefault()).ToList();
}
else
{
if (idStabile > 0)
storico = storico.Where(item => item.IdStabileAddebito == idStabile.GetValueOrDefault()).ToList();
if (idScala > 0)
storico = storico.Where(item => item.IdGruppoStabileAddebito == idScala.GetValueOrDefault()).ToList();
}
foreach (var storicoRiparto in storico)
{
listaStorico.Add(new ReportRipartizioneBilancioDTO
{
IdConto = storicoRiparto.IdConto,
IdSottoConto = storicoRiparto.IdSottoConto,
IdGruppoStabile = storicoRiparto.IdGruppoStabile,
CodiceConto = storicoRiparto.CodiceConto,
CodiceSottoConto = storicoRiparto.CodiceSottoConto,
DescrizioneConto = storicoRiparto.DescrizioneConto,
DescrizioneSottoConto = storicoRiparto.DescrizioneSottoConto,
DescrizioneGruppoStabile = storicoRiparto.DescrizioneGruppoStabile,
DescrizioneStabile = storicoRiparto.DescrizioneStabile,
DisabilitaStampaMillesimi = storicoRiparto.DisabilitaStampaMillesimi,
IdPartecipante = storicoRiparto.IdPartecipante.GetValueOrDefault(),
IdPersona = storicoRiparto.IdPersona.GetValueOrDefault(),
IdRendiconto = storicoRiparto.IdRendiconto,
IdStabile = storicoRiparto.IdStabile,
IdUnitaImmobiliare = storicoRiparto.IdUnitaImmobiliare,
Importo = storicoRiparto.Importo,
InternoUnitaImmobiliare = storicoRiparto.InternoUnitaImmobiliare,
Millesimi = storicoRiparto.Millesimi,
Nominativo = storicoRiparto.Nominativo,
NumeroColonne = storicoRiparto.NumeroColonne,
OrdineConto = storicoRiparto.OrdineConto,
OrdineGruppoStabile = storicoRiparto.OrdineGruppoStabile,
OrdineStabile = storicoRiparto.OrdineStabile,
OrdineUnitaImmobiliare = storicoRiparto.OrdineUnitaImmobiliare,
SubalternoUnitaImmobiliare = storicoRiparto.SubalternoUnitaImmobiliare,
PianoUnitaImmobiliare = storicoRiparto.PianoUnitaImmobiliare,
TipoNominativo = storicoRiparto.TipoNominativo,
TipoNominativoEffettivo = storicoRiparto.TipoNominativoEffettivo,
TipoUnitaImmobiliare = storicoRiparto.TipoUnitaImmobiliare,
UnitaMisuraMillesimi = storicoRiparto.UnitaMisuraMillesimi,
GiorniCompetenza = storicoRiparto.GiorniCompetenza
});
}
result = listaStorico.OrderBy(item => item.IdGruppoStabile).ToList();
}
return result;
}
public virtual string StoricizzaRiparto(int idEsercizio, TipoRendiconto tipoRendiconto)
{
throw new InvalidOperationException("Deve essere usato il metodo della classe BilancioRipartoAggregatoService");
}
public ResultBilancioPreventivo CalcolaPreventivo(int idEsercizio, int? idStabile, int? idScala, TipoRendiconto riferimentoVariazione, decimal variazione, bool dettaglioSottoConto, bool copiaEsercizioPrecedente, bool importiEsercizioPrecedente)
{
var result = GetServiceClient().CalcolaPreventivo(idEsercizio, idStabile, idScala, riferimentoVariazione, variazione, dettaglioSottoConto, copiaEsercizioPrecedente, importiEsercizioPrecedente, GetUserInfo());
CloseService();
return result;
}
public BilancioPreventivoDTO CalcolaPreventivo(int idEsercizio, int? idStabile, int? idScala, TipoRendiconto riferimentoVariazione, decimal? variazione, bool dettaglioSottoConto, bool copiaEsercizioPrecedente, bool importiEsercizioPrecedente)
{
try
{
var esercizio = _daoFactory.GetEsercizioDao().GetById(idEsercizio, false);
// ==========================================================================================================
// Se richiesto lo copio dall'esercizio precedente
// ==========================================================================================================
if (copiaEsercizioPrecedente)
{
var esercizioPrecedente = esercizio.GetEsercizioPrecedente();
if (esercizioPrecedente != null)
{
var consuntivoPrecedente = GetDataSourceBilancioConsuntivo_SottoConto(esercizioPrecedente.ID, null, null, null, null, true, true).ToList();
var rendiconti = _daoFactory.GetRendicontoAnnualeDao().GetByEsercizio(esercizioPrecedente.ID).Where(item => item.Tipo == TipoRendiconto.Preventivo).ToList();
if (rendiconti.Count > 0)
{
var rendicontoPrecedente = rendiconti[0];
var rendiconto = new BilancioPreventivoDTO
{
DescrizioneEsercizio = esercizio.DisplayName,
IdEsercizio = esercizio.ID,
CalcoloPerSottoconto = rendicontoPrecedente.CalcoloPerSottoconto,
StatoRendiconto = StatoRendicontoEnum.Provvisorio,
Dettaglio = new List<CalcoloBilancioPreventivoDTO>()
};
foreach (var rendicontoAnnualeContoPrecedente in rendicontoPrecedente.Conti)
{
var conto = rendicontoAnnualeContoPrecedente.ContoRiferimento;
if (conto == null && rendicontoAnnualeContoPrecedente.SottoContoRiferimento != null)
conto = rendicontoAnnualeContoPrecedente.SottoContoRiferimento.ContoRiferimento;
if (conto != null && conto.EsercizioRiferimento == null)
{
var rendicontoConto = new CalcoloBilancioPreventivoDTO { DettaglioUnita = new List<CalcoloUnitaBilancioPreventivoDTO>() };
if(rendicontoAnnualeContoPrecedente.ContoRiferimento != null)
{
rendicontoConto.IdConto = rendicontoAnnualeContoPrecedente.ContoRiferimento.ID;
rendicontoConto.Codice = rendicontoAnnualeContoPrecedente.ContoRiferimento.Codice;
rendicontoConto.OrdineConto = rendicontoAnnualeContoPrecedente.ContoRiferimento.Ordine;
rendicontoConto.Descrizione = rendicontoAnnualeContoPrecedente.ContoRiferimento.Descrizione;
}
if (rendicontoAnnualeContoPrecedente.SottoContoRiferimento != null)
{
rendicontoConto.IdConto = rendicontoAnnualeContoPrecedente.SottoContoRiferimento.ContoRiferimento.ID;
rendicontoConto.Codice = rendicontoAnnualeContoPrecedente.SottoContoRiferimento.Codice;
rendicontoConto.OrdineConto = rendicontoAnnualeContoPrecedente.SottoContoRiferimento.ContoRiferimento.Ordine;
rendicontoConto.IdSottoConto = rendicontoAnnualeContoPrecedente.SottoContoRiferimento.ID;
rendicontoConto.Descrizione = rendicontoAnnualeContoPrecedente.SottoContoRiferimento.GetDescrizione(esercizio, null, null);
}
if(rendicontoAnnualeContoPrecedente.Stabile != null)
{
rendicontoConto.IdStabile = rendicontoAnnualeContoPrecedente.Stabile.ID;
rendicontoConto.DescrizioneStabile = rendicontoAnnualeContoPrecedente.Stabile.DisplayName;
}
if (rendicontoAnnualeContoPrecedente.GruppoStabile != null)
{
rendicontoConto.IdStabile = rendicontoAnnualeContoPrecedente.GruppoStabile.PalazzinaRiferimento.ID;
rendicontoConto.DescrizioneStabile = rendicontoAnnualeContoPrecedente.GruppoStabile.PalazzinaRiferimento.DisplayName;
rendicontoConto.IdGruppoStabile = rendicontoAnnualeContoPrecedente.GruppoStabile.ID;
rendicontoConto.DescrizioneGruppoStabile = rendicontoAnnualeContoPrecedente.GruppoStabile.Descrizione;
}
var importoConsuntivo = getImportoConsuntivo(rendicontoConto.IdConto, rendicontoConto.IdSottoConto, rendicontoConto.IdStabile, rendicontoConto.IdGruppoStabile, consuntivoPrecedente);
rendicontoConto.ImportoConsuntivo = importoConsuntivo;
rendicontoConto.ImportoPreventivoAnnoPrecedente = rendicontoAnnualeContoPrecedente.Importo;
var importo = rendicontoConto.ImportoPreventivoAnnoPrecedente;
if (variazione != null)
{
if (riferimentoVariazione == TipoRendiconto.Consuntivo && rendicontoConto.ImportoConsuntivo != null)
importo = rendicontoConto.ImportoConsuntivo + ((rendicontoConto.ImportoConsuntivo * variazione) / 100);
else if (riferimentoVariazione == TipoRendiconto.Preventivo && rendicontoConto.ImportoPreventivoAnnoPrecedente != null)
importo = rendicontoConto.ImportoPreventivoAnnoPrecedente + ((rendicontoConto.ImportoPreventivoAnnoPrecedente * variazione) / 100);
}
rendicontoConto.ImportoPreventivo = importo;
foreach (var rendicontoAnnualeUnitaPrecedente in rendicontoAnnualeContoPrecedente.DettagliUnita)
{
var rendicontoUnita = new CalcoloUnitaBilancioPreventivoDTO
{
IdUnita = rendicontoAnnualeUnitaPrecedente.Unita.ID,
Ordine = rendicontoAnnualeUnitaPrecedente.Unita.Ordine.GetValueOrDefault(),
Descrizione = rendicontoAnnualeUnitaPrecedente.Unita.Descrizione,
ImportoPreventivoAnnoPrecedente = rendicontoAnnualeUnitaPrecedente.Importo,
ImportoPreventivo = rendicontoAnnualeUnitaPrecedente.Importo
};
rendicontoConto.DettaglioUnita.Add(rendicontoUnita);
}
rendiconto.Dettaglio.Add(rendicontoConto);
}
}
return rendiconto;
}
}
}
// ==========================================================================================================
// Il calcolo del preventivo può essere effettuato sulla base del consuntivo/preventivo dell'anno precedente
// ==========================================================================================================
IList<ReportBilancioDTO> consuntivo = null;
IList<ReportBilancioDTO> preventivoBilancio = null;
if (esercizio.GetEsercizioPrecedente() != null && importiEsercizioPrecedente)
{
preventivoBilancio = GetDataSourceBilancioPreventivo_SottoConto(esercizio.GetEsercizioPrecedente().ID, idStabile, idScala, false, false, false, false);
consuntivo = dettaglioSottoConto ? GetDataSourceBilancioConsuntivo_SottoConto(esercizio.GetEsercizioPrecedente().ID, null, null, null, null, false, false).ToList() : GetDataSourceBilancioConsuntivoConto(esercizio.GetEsercizioPrecedente().ID).ToList();
}
var preventivoCalcolato = new List<CalcoloBilancioPreventivoDTO>();
var conti = _daoFactory.GetContoDao().GetBilancioByEsercizio(idEsercizio, esercizio.CondominioRiferimento.ID);
foreach (var conto in conti)
{
var sottoConti = conto.SottoConti.Where(item => item.Deleted != "Y").OrderBy(item => item.Codice);
// ====================================================
// Calcolo per sotto conto
// ====================================================
if (sottoConti.Any() && dettaglioSottoConto)
{
// -----------------------
// Righe conto
// -----------------------
if (sottoConti.Any())
{
try
{
var preventivoConto = new CalcoloBilancioPreventivoDTO
{
IdConto = conto.ID,
Codice = conto.Codice,
Descrizione = conto.Descrizione,
OrdineConto = conto.Ordine
};
if (preventivoBilancio != null || consuntivo != null)
{
// Preventivo anno precedente
if (preventivoBilancio != null)
preventivoConto.ImportoPreventivoAnnoPrecedente = getImportoConsuntivo(conto.ID, 0, preventivoBilancio, true);
// Consuntivo anno precedente
if (consuntivo != null)
preventivoConto.ImportoConsuntivo = getImportoConsuntivo(conto.ID, 0, consuntivo, true);
// Preventivo attuale proposto
if (variazione != null)
{
if (riferimentoVariazione == TipoRendiconto.Consuntivo && preventivoConto.ImportoConsuntivo != null)
preventivoConto.ImportoPreventivo = preventivoConto.ImportoConsuntivo + ((preventivoConto.ImportoConsuntivo * variazione) / 100);
else if (riferimentoVariazione == TipoRendiconto.Preventivo && preventivoConto.ImportoPreventivoAnnoPrecedente != null)
preventivoConto.ImportoPreventivo = preventivoConto.ImportoPreventivoAnnoPrecedente + ((preventivoConto.ImportoPreventivoAnnoPrecedente * variazione) / 100);
}
}
// --------------------------------------------------------------------------------
// Stabile
// --------------------------------------------------------------------------------
if (idStabile != null)
{
var palazzina = _daoFactory.GetPalazzinaDao().GetById(idStabile.Value, false);
preventivoConto.IdStabile = palazzina.ID;
preventivoConto.DescrizioneStabile = palazzina.Descrizione;
}
// --------------------------------------------------------------------------------
// Scala
// --------------------------------------------------------------------------------
if (idScala != null)
{
var scala = _daoFactory.GetGruppoStabileDao().GetById(idScala.Value, false);
preventivoConto.IdGruppoStabile = scala.ID;
preventivoConto.DescrizioneGruppoStabile = scala.Descrizione;
preventivoConto.IdStabile = scala.PalazzinaRiferimento.ID;
preventivoConto.DescrizioneStabile = scala.PalazzinaRiferimento.Descrizione;
}
// --------------------------------------------------------------------------------
// Aggiungo i dettagli se il conto è di spese personali
// --------------------------------------------------------------------------------
preventivoConto.DettaglioUnita = new List<CalcoloUnitaBilancioPreventivoDTO>();
if (conto.IsSpesePersonali)
{
IList<ImportiDTO> importi = new List<ImportiDTO>();
if (esercizio.GetEsercizioPrecedente() != null)
importi = _daoFactory.GetSpeseUnitaDao().GetTotaleSpeseByConto(conto.ID, esercizio.GetEsercizioPrecedente());
addPreventivoPerUnita(preventivoConto, esercizio, importi);
}
preventivoCalcolato.Add(preventivoConto);
}
catch (Exception ex)
{
_log.Error("Errore inaspettato durante la creazione della lista per l'inserimento dei valori di preventivo - Calcolo per sottoconto - " + Utility.GetMethodDescription() + " - idEsercizio: " + idEsercizio + " - Conto:" + conto.ID, ex);
throw;
}
}
// -----------------------
// Righe Sotto Conto
// -----------------------
foreach (var sottoConto in sottoConti)
{
try
{
var preventivo = new CalcoloBilancioPreventivoDTO
{
IdConto = conto.ID,
IdSottoConto = sottoConto.ID,
Codice = sottoConto.Codice,
Descrizione = sottoConto.GetDescrizione(esercizio, null, null),
OrdineConto = conto.Ordine
};
if (preventivoBilancio != null || consuntivo != null)
{
// Preventivo anno precedente
if (preventivoBilancio != null)
preventivo.ImportoPreventivoAnnoPrecedente = getImportoConsuntivo(0, sottoConto.ID, preventivoBilancio, true);
// Consuntivo anno precedente
if (consuntivo != null)
preventivo.ImportoConsuntivo = getImportoConsuntivo(0, sottoConto.ID, consuntivo, true);
// Preventivo attuale proposto
if (variazione != null)
{
if (riferimentoVariazione == TipoRendiconto.Consuntivo && preventivo.ImportoConsuntivo != null)
preventivo.ImportoPreventivo = preventivo.ImportoConsuntivo + ((preventivo.ImportoConsuntivo * variazione) / 100);
else if (riferimentoVariazione == TipoRendiconto.Preventivo && preventivo.ImportoPreventivoAnnoPrecedente != null)
preventivo.ImportoPreventivo = preventivo.ImportoPreventivoAnnoPrecedente + ((preventivo.ImportoPreventivoAnnoPrecedente * variazione) / 100);
}
}
// --------------------------------------------------------------------------------
// Stabile
// --------------------------------------------------------------------------------
if (idStabile != null)
{
var palazzina = _daoFactory.GetPalazzinaDao().GetById(idStabile.Value, false);
preventivo.IdStabile = palazzina.ID;
preventivo.DescrizioneStabile = palazzina.Descrizione;
}
// --------------------------------------------------------------------------------
// Scala
// --------------------------------------------------------------------------------
if (idScala != null)
{
var scala = _daoFactory.GetGruppoStabileDao().GetById(idScala.Value, false);
preventivo.IdGruppoStabile = scala.ID;
preventivo.DescrizioneGruppoStabile = scala.Descrizione;
preventivo.IdStabile = scala.PalazzinaRiferimento.ID;
preventivo.DescrizioneStabile = scala.PalazzinaRiferimento.Descrizione;
}
// --------------------------------------------------------------------------------
// Aggiungo i dettagli se il conto è di spese personali
// --------------------------------------------------------------------------------
preventivo.DettaglioUnita = new List<CalcoloUnitaBilancioPreventivoDTO>();
if (conto.IsSpesePersonali)
{
IList<ImportiDTO> importi = new List<ImportiDTO>();
if (esercizio.GetEsercizioPrecedente() != null)
importi = _daoFactory.GetSpeseUnitaDao().GetTotaleSpeseByConto(conto.ID, esercizio.GetEsercizioPrecedente());
addPreventivoPerUnita(preventivo, esercizio, importi);
}
preventivoCalcolato.Add(preventivo);
}
catch (Exception ex)
{
_log.Error("Errore inaspettato durante la creazione della lista per l'inserimento dei valori di preventivo - Calcolo per sottoconto - Righe SottoConto - " + Utility.GetMethodDescription() + " - idEsercizio: " + idEsercizio + " - SottoConto:" + sottoConto.ID, ex);
throw;
}
}
}
// ====================================================
// Calcolo per Conto
// ====================================================
else
{
try
{
var preventivo = new CalcoloBilancioPreventivoDTO
{
IdConto = conto.ID,
Codice = conto.Codice,
Descrizione = conto.Descrizione,
OrdineConto = conto.Ordine
};
if (preventivoBilancio != null || consuntivo != null)
{
// Consuntivo anno precedente
if (consuntivo != null)
preventivo.ImportoConsuntivo = getImportoConsuntivo(conto.ID, 0, consuntivo, dettaglioSottoConto);
// Preventivo anno precedente
if (preventivoBilancio != null)
preventivo.ImportoPreventivoAnnoPrecedente = getImportoConsuntivo(conto.ID, 0, preventivoBilancio, dettaglioSottoConto);
// Preventivo attuale proposto
if (variazione != null)
{
if (riferimentoVariazione == TipoRendiconto.Consuntivo && preventivo.ImportoConsuntivo != null)
preventivo.ImportoPreventivo = preventivo.ImportoConsuntivo + ((preventivo.ImportoConsuntivo * variazione) / 100);
else if (riferimentoVariazione == TipoRendiconto.Preventivo && preventivo.ImportoPreventivoAnnoPrecedente != null)
preventivo.ImportoPreventivo = preventivo.ImportoPreventivoAnnoPrecedente + ((preventivo.ImportoPreventivoAnnoPrecedente * variazione) / 100);
}
}
// --------------------------------------------------------------------------------
// Stabile
// --------------------------------------------------------------------------------
if (idStabile != null)
{
var palazzina = _daoFactory.GetPalazzinaDao().GetById(idStabile.Value, false);
preventivo.IdStabile = palazzina.ID;
preventivo.DescrizioneStabile = palazzina.Descrizione;
}
// --------------------------------------------------------------------------------
// Scala
// --------------------------------------------------------------------------------
if (idScala != null)
{
var scala = _daoFactory.GetGruppoStabileDao().GetById(idScala.Value, false);
preventivo.IdGruppoStabile = scala.ID;
preventivo.DescrizioneGruppoStabile = scala.Descrizione;
preventivo.IdStabile = scala.PalazzinaRiferimento.ID;
preventivo.DescrizioneStabile = scala.PalazzinaRiferimento.Descrizione;
}
// --------------------------------------------------------------------------------
// Aggiungo i dettagli se il conto è di spese personali
// --------------------------------------------------------------------------------
preventivo.DettaglioUnita = new List<CalcoloUnitaBilancioPreventivoDTO>();
if (conto.IsSpesePersonali)
{
IList<ImportiDTO> importi = new List<ImportiDTO>();
if (esercizio.GetEsercizioPrecedente() != null)
importi = _daoFactory.GetSpeseUnitaDao().GetTotaleSpeseByConto(conto.ID, esercizio.GetEsercizioPrecedente());
addPreventivoPerUnita(preventivo, esercizio, importi);
}
preventivoCalcolato.Add(preventivo);
}
catch (Exception ex)
{
_log.Error("Errore inaspettato durante la creazione della lista per l'inserimento dei valori di preventivo - Calcolo per Conto - " + Utility.GetMethodDescription() + " - idEsercizio: " + idEsercizio, ex);
throw;
}
}
}
var bilancioPreventivo = new BilancioPreventivoDTO
{
ID = 0,
CalcoloPerSottoconto = dettaglioSottoConto,
IdEsercizio = esercizio.ID,
DescrizioneEsercizio = esercizio.DisplayName,
Dettaglio = preventivoCalcolato.OrderBy(item => item.OrdineConto).ToList(),
StatoRendiconto = StatoRendicontoEnum.Provvisorio
};
return bilancioPreventivo;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la creazione della lista per l'inserimento dei valori di preventivo - {0} - idEsercizio:{1}", ex, Utility.GetMethodDescription(), idEsercizio);
throw;
}
}
public void SalvaRiparto(int idEsercizo, byte[] body, List<ReportRipartizioneBilancioDTO> ripartizione, TipoRendiconto tipoRendiconto)
{
var ripartoToSave = new List<ReportRipartizioneBilancioDTO> ((ripartizione.Where(riparto => riparto.IdConto > 0)).ToList());
GetServiceClient().SalvaRiparto(idEsercizo, body, ripartoToSave, tipoRendiconto, GetUserInfo());
CloseService();
}
public void SalvaRiparto(int idEsercizio, byte[] bytes, IList<ReportRipartizioneBilancioDTO> riparto, TipoRendiconto tipo)
{
if (riparto.Count > 0)
{
var esercizio = _daoFactory.GetEsercizioDao().GetById(idEsercizio, false);
// Elenco rendiconti
var rendiconto = riparto[0].IdRendiconto > 0
? _daoFactory.GetRendicontoAnnualeDao().GetById(riparto[0].IdRendiconto, false)
: new RendicontoAnnuale(esercizio, "Riparto", tipo) { Stato = StatoRendicontoEnum.Salvato };
var fileName = "Riparto " + tipo + " - " + esercizio.DataApertura.GetValueOrDefault().Year + ".pdf";
var documentMessage = _documentService.SaveDocument(bytes, fileName, ".pdf", null, esercizio.CondominioRiferimento.Azienda.ID);
if (documentMessage.Documento != null)
{
var checksum = documentMessage.Documento.Checksum;
rendiconto.Documento = new Documento(checksum, fileName, ".pdf", "Riparto", false, esercizio.CondominioRiferimento.Azienda);
_daoFactory.GetDocumentoDao().SaveOrUpdate(rendiconto.Documento);
_daoFactory.GetRendicontoAnnualeDao().SaveOrUpdate(rendiconto);
// Salvataggio riparto
if (tipo == TipoRendiconto.Consuntivo)
{
foreach (var item in riparto)
{
// Se IdConto non è valorizzato trattasi solo di righe riepilogative necessarie solo per la stampa.
// TODO: Per migliorare le performance escluderle direttamente sul client.
if (item.IdConto > 0 && item.IdPartecipante > 0)
{
var soggetto = _daoFactory.GetSoggettoCondominioDao().Find(item.IdPartecipante, false);
if (soggetto != null && item.Importo != null)
{
var conto = _daoFactory.GetContoDao().GetById(item.IdConto, false);
var itemRipartoConsuntivo = new RipartoConsuntivoSoggettoCondominio(soggetto, esercizio, conto, item.Importo) { Rendiconto = rendiconto };
_daoFactory.GetRipartoConsuntivoSoggettoCondominioDao().SaveOrUpdate(itemRipartoConsuntivo);
}
}
}
}
}
}
}
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 void SalvaBilancio(int idEsercizio, byte[] bytes, TipoRendiconto tipo)
{
var esercizio = _daoFactory.GetEsercizioDao().GetById(idEsercizio, false);
// Elenco rendiconti
var rendiconto = new RendicontoAnnuale(esercizio, "Bilancio", tipo) { Stato = StatoRendicontoEnum.Salvato };
var fileName = "Bilancio " + tipo + " - " + esercizio.DataApertura.GetValueOrDefault().Year + ".pdf";
var documentMessage = _documentService.SaveDocument(bytes, fileName, ".pdf", null, esercizio.CondominioRiferimento.Azienda.ID);
if(documentMessage.Documento != null)
{
var checksum = documentMessage.Documento.Checksum;
rendiconto.Documento = new Documento(checksum, fileName, ".pdf", "Bilancio", false, esercizio.CondominioRiferimento.Azienda);
_daoFactory.GetDocumentoDao().SaveOrUpdate(rendiconto.Documento);
_daoFactory.GetRendicontoAnnualeDao().SaveOrUpdate(rendiconto);
}
}
/// <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 BilancioConsuntivoReportParameters getParameters(CondominioDTO condominio, EsercizioDTO esercizio, TipoRendiconto tipoRendiconto, string tipoNote)
{
// ====================================================================
// Descrizione del condominio
// ====================================================================
var righeCondominio = condominio.IndirizzoCompleto.Split('&');
var righeDaPubblicare = new string[4];
if (righeCondominio.Length > 0)
righeDaPubblicare[0] = righeCondominio[0];
for (var i = 1; i < 4; i++)
{
if (righeCondominio.Length > i)
{
if (!string.IsNullOrEmpty(righeDaPubblicare[1]))
righeDaPubblicare[1] += " - ";
righeDaPubblicare[1] += righeCondominio[i];
}
if (i > 1)
righeDaPubblicare[i] = string.Empty;
}
// ====================================================================
// Recupero l'intestazione dello studio
// ====================================================================
var azienda = getAziendaService().GetAzienda();
var intestazioneStudio = azienda.Descrizione;
var viaStudio = string.Empty;
var capStudio = string.Empty;
var localitaStudio = string.Empty;
if (azienda.IndirizzoSede != null)
{
viaStudio = azienda.IndirizzoSede.Indirizzo + " n. " + azienda.IndirizzoSede.Civico;
capStudio = azienda.IndirizzoSede.Cap;
localitaStudio = azienda.IndirizzoSede.DescrizioneComune + " " + azienda.IndirizzoSede.CodiceProvincia;
// Collasso diverse informazioni nel campo viaStudio
viaStudio += " - " + capStudio + " " + localitaStudio;
}
var reportParameters =
new BilancioConsuntivoReportParameters(
righeDaPubblicare,
condominio.Codice,
esercizio.DisplayName,
string.Empty, griglia.Checked,
TipoDettaglioReportBilancio.Undefined,
suddivisioneProprietari.Checked,
TipoReportBilancio.Ripartizione,
tipoRendiconto,
salvaRiparto.Checked,
stampaMillesimi.Checked,
stampaSaldi.Checked,
Conversione.ToString(note.GetDocumento(tipoNote)),
intestazioneStudio,
viaStudio,
capStudio,
localitaStudio,
0,
0,
esercizio.DataChiusura.GetValueOrDefault(),
parzialeGruppo.Checked,
parzialeStabile.Checked,
accorpamentoUnita.Checked,
totalePerPersona.Checked,
getTipoAccorpamento(),
null,
numeroInterno.Checked,
salvaRiparto.Checked,
Security.Login.Instance.CurrentLogin().InversioneSaldiCondomini,
esercizio.DataApertura.GetValueOrDefault(),
esercizio.DataChiusura.GetValueOrDefault()
);
return reportParameters;
}
public BilancioConsuntivoReportParameters(string[] descrizioneCondominio, string codiceCondominio, string descrizioneEsercizio, string descrizioneAzienda, bool? visualizzaGriglia, TipoDettaglioReportBilancio tipoDettaglio, bool? visualizzaProprietariInquilini, TipoReportBilancio tipoReport, TipoRendiconto tipoRendiconto, bool? definitivo, bool? stampaMillesimi, bool stampaSaldi, string note, string intestazioneStudio, string viaStudio, string capStudio, string localitaStudio, decimal totaleVersamenti, decimal saldoPrecedente, DateTime dataFineEsercizio, bool parzialeGruppo, bool parzialeStabile, bool accorpamentoUnita, bool totalePerPersona, TipoAccorpamentoRateEnum tipoAccorpamento, string datiFatturaNumeroRegistrazione, bool numeroInterno, bool salvaRiparto, bool inversioneSaldi, DateTime dataPrimaRegistrazione, DateTime dataUltimaRegistrazione)
{
DescrizioneCondominio = descrizioneCondominio;
CodiceCondominio = codiceCondominio;
DescrizioneAzienda = descrizioneAzienda;
DescrizioneEsercizio = descrizioneEsercizio;
VisualizzaGriglia = visualizzaGriglia;
TipoDettaglio = tipoDettaglio;
VisualizzaProprietariInquilini = visualizzaProprietariInquilini;
TipoReport = tipoReport;
TipoRendiconto = tipoRendiconto;
Definitivo = definitivo;
StampaMillesimi = stampaMillesimi;
StampaSaldi = stampaSaldi;
Note = note;
IntestazioneStudio = intestazioneStudio;
ViaStudio = viaStudio;
CapStudio = capStudio;
LocalitaStudio = localitaStudio;
TotaleVersamenti = totaleVersamenti;
SaldoPrecedente = saldoPrecedente;
DataFineEsercizio = dataFineEsercizio;
ParzialeGruppo = parzialeGruppo;
ParzialeStabile = parzialeStabile;
AccorpamentoUnita = accorpamentoUnita;
TotalePerPersona = totalePerPersona;
TipoAccorpamento = tipoAccorpamento;
DatiFatturaNumeroRegistrazione = datiFatturaNumeroRegistrazione;
NumeroInterno = numeroInterno;
SalvaRiparto = salvaRiparto;
InversioneSaldi = inversioneSaldi;
DataPrimaRegistrazione = dataPrimaRegistrazione;
DataUltimaRegistrazione = dataUltimaRegistrazione;
}
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;
}
