private void btnCalcolaClick(object sender, EventArgs e)
{
string message = getBilancioService().IsAllowNewPreventivo(_esercizio.ID);
if (string.IsNullOrEmpty(message))
{
provvisorioDefinitivo.Value = "P";
provvisorioDefinitivo.Enabled = false;
var form = new ExecuteLoadDataObjectAsync<ResultBilancioPreventivo>("E' in corso il calcolo del bilancio preventivo ....." + Environment.NewLine + "Si prega di attendere.");
Func<ResultBilancioPreventivo> loadDati = () => getBilancioService().CalcolaPreventivo((int)esercizi.Value, (int?)stabili.Value, (int?)gruppi.Value, (TipoRendiconto)Enum.Parse(typeof(TipoRendiconto), variazionePreventivoConsuntivo.Value.ToString()), Convert.ToDecimal(variazionePercentuale.Value), livelloContoSottoconto.Value.ToString() == "S", chkPreventivoEsercizioPrecedente.Checked, importiEsercizioPrecedente.Checked);
form.LoadData(loadDati);
form.ShowDialog();
if (form.DataSourceObject.Bilancio != null)
{
_bilancioPreventivo = form.DataSourceObject.Bilancio;
form.Dispose();
calcoloBilancioPreventivoDTOBindingSource.DataSource = _bilancioPreventivo.Dettaglio;
if (calcoloBilancioPreventivoDTOBindingSource.DataSource != null)
{
if (lista.DisplayLayout.Bands[0].Summaries.Count == 0)
{
DataGridHelper.AddSummary(lista.DisplayLayout.Bands[0], "ImportoPreventivoAnnoPrecedente", "c");
DataGridHelper.AddSummary(lista.DisplayLayout.Bands[0], "ImportoConsuntivo", "c");
DataGridHelper.AddSummary(lista.DisplayLayout.Bands[0], "ImportoPreventivo", "c");
}
if (lista.DisplayLayout.Bands[1].Summaries.Count == 0)
{
DataGridHelper.AddSummary(lista.DisplayLayout.Bands[1], "ImportoPreventivoAnnoPrecedente", "c");
DataGridHelper.AddSummary(lista.DisplayLayout.Bands[1], "ImportoConsuntivo", "c");
DataGridHelper.AddSummary(lista.DisplayLayout.Bands[1], "ImportoPreventivo", "c");
}
lista.Visible = true;
btnConferma.Visible = true;
lista.UpdateData();
lista.PerformAction(UltraGridAction.ExitEditMode);
}
else
CommonMessages.DisplayWarning("Non è possibile aprire il bilancio preventivo, verificare la correttezza del piano dei conti.");
}
else
{
if (!string.IsNullOrEmpty(form.DataSourceObject.Message))
{
CommonMessages.DisplayWarning(string.Format("Non è possibile aprire il bilancio preventivo:{0}{1}", Environment.NewLine, form.DataSourceObject.Message));
}
}
}
else
CommonMessages.DisplayWarning("Non è ammessa la creazione di un nuovo bilancio preventivo:" + Environment.NewLine + Environment.NewLine + message);
}
private void load()
{
btnConferma.Visible = false;
if (esercizi.Value != null)
{
// -------------------------------------------------------------------------------
// Preventivo già aperto propongo l'apertura per eventuali modifiche .....
// -------------------------------------------------------------------------------
if (getBilancioService().IsOpen((int)esercizi.Value) == ControlEnableEnum.True)
{
var form = new ExecuteLoadDataObjectAsync<ResultBilancioPreventivo>("E' in corso il caricamento del bilancio preventivo ....." + Environment.NewLine + "Si prega di attendere.");
Func<ResultBilancioPreventivo> loadDati = () => getBilancioService().GetPreventivo((int)esercizi.Value, (int?)stabili.Value, (int?)gruppi.Value, importiEsercizioPrecedente.Checked);
form.LoadData(loadDati);
form.ShowDialog();
if (form.DataSourceObject.Bilancio != null)
{
_bilancioPreventivo = form.DataSourceObject.Bilancio;
form.Dispose();
if (_bilancioPreventivo != null)
{
calcoloBilancioPreventivoDTOBindingSource.DataSource = _bilancioPreventivo.Dettaglio;
livelloContoSottoconto.Value = _bilancioPreventivo.CalcoloPerSottoconto ? "S" : "C";
if (lista.DisplayLayout.Bands[0].Summaries.Count == 0)
{
DataGridHelper.AddSummary(lista.DisplayLayout.Bands[0], "ImportoPreventivoAnnoPrecedente", "c");
DataGridHelper.AddSummary(lista.DisplayLayout.Bands[0], "ImportoConsuntivo", "c");
DataGridHelper.AddSummary(lista.DisplayLayout.Bands[0], "ImportoPreventivo", "c");
}
if (lista.DisplayLayout.Bands[1].Summaries.Count == 0)
{
DataGridHelper.AddSummary(lista.DisplayLayout.Bands[1], "ImportoPreventivoAnnoPrecedente", "c");
DataGridHelper.AddSummary(lista.DisplayLayout.Bands[1], "ImportoConsuntivo", "c");
DataGridHelper.AddSummary(lista.DisplayLayout.Bands[1], "ImportoPreventivo", "c");
}
lista.Visible = true;
btnConferma.Visible = true;
if (_bilancioPreventivo.StatoRendiconto == StatoRendicontoEnum.Definitivo)
{
provvisorioDefinitivo.Value = "D";
provvisorioDefinitivo.Enabled = false;
lista.DisplayLayout.Override.AllowUpdate = DefaultableBoolean.False;
lista.DisplayLayout.Override.AllowAddNew = AllowAddNew.No;
}
else
{
provvisorioDefinitivo.Value = "P";
provvisorioDefinitivo.Enabled = true;
lista.DisplayLayout.Override.AllowUpdate = DefaultableBoolean.True;
lista.DisplayLayout.Override.AllowAddNew = AllowAddNew.Default;
}
}
else
{
_log.ErrorFormat("Errore imprevisto nell'apertura del bilancio preventivo - {0} - condominio:{1} - esercizio:{2} - azienda:{2}", Utility.GetMethodDescription(), _condominio != null ? _condominio.ID.ToString() : "<NULL>", _esercizio != null ? _esercizio.ID.ToString() : "<NULL>");
if (ParentForm != null)
ParentForm.Close();
return;
}
}
else
{
if (!string.IsNullOrEmpty(form.DataSourceObject.Message))
{
CommonMessages.DisplayWarning(string.Format("Non è possibile aprire il bilancio preventivo:{0}{1}", Environment.NewLine, form.DataSourceObject.Message));
}
}
}
// -------------------------------------------------------------------------------------------------
// .... altrimenti verifico se è ammessa l'apertura da Preventivo o Consuntivo dell'anno precedente
// -------------------------------------------------------------------------------------------------
else if (!getBilancioService().IsAllowCalcoloPreventivoDaConsuntivo((int)esercizi.Value))
{
manuale.Value = true;
manuale.Enabled = false;
variazionePreventivoConsuntivo.Enabled = false;
variazionePercentuale.Enabled = false;
btnCalcolaClick(this, EventArgs.Empty);
}
else
{
manuale.Enabled = true;
variazionePreventivoConsuntivo.Enabled = true;
}
_enableProvvisorioDefinitivo = getBilancioService().IsAllowPreventivoDefinitivo(_esercizio.ID);
if (_enableProvvisorioDefinitivo == ControlEnableEnum.True || _enableProvvisorioDefinitivo == ControlEnableEnum.Confirm)
{
provvisorioDefinitivo.Enabled = true;
opzioniGroup.Visible = true;
if(lista.DisplayLayout != null)
lista.DisplayLayout.Override.AllowUpdate = DefaultableBoolean.True;
}
else
{
provvisorioDefinitivo.Value = "D";
provvisorioDefinitivo.Enabled = false;
opzioniGroup.Visible = false;
btnConferma.Visible = false;
if (lista.DisplayLayout != null)
lista.DisplayLayout.Override.AllowUpdate = DefaultableBoolean.False;
}
panelPiede.Visible = true;
lista.UpdateData();
lista.PerformAction(UltraGridAction.ExitEditMode);
filtroSelezionatiCheckedChanged(null, EventArgs.Empty);
}
}
public string SetRendicontoPreventivo(int idEsercizio, int? idStabile, int? idScala, BilancioPreventivoDTO preventivo, StatoRendicontoEnum stato, bool dettaglioSottoConto)
{
var result = GetServiceClient().SetRendicontoPreventivo(idEsercizio, idStabile, idScala, preventivo, stato, dettaglioSottoConto, GetUserInfo());
CloseService();
return result;
}
public string SetRendicontoPreventivo(int idEsercizio, int? idStabile, int? idScala, BilancioPreventivoDTO bilancioPreventivo, StatoRendicontoEnum stato, bool dettaglioSottoConto)
{
try
{
var message = string.Empty;
var esercizio = _daoFactory.GetEsercizioDao().GetById(idEsercizio, false);
if (esercizio.Stato == StatoEsercizioEnum.Chiuso)
return "L'esercizio è chiuso non è possibile modificare il bilancio preventivo";
// -------------------------------------------
// Testata rendiconto
// -------------------------------------------
RendicontoAnnuale rendiconto = null;
try
{
rendiconto = _daoFactory.GetRendicontoAnnualeDao().Find(bilancioPreventivo.ID, false);
if (rendiconto == null)
{
// Eliminazione vecchi rendiconti provvisori
// -----------------------------------------------------------------
try
{
var rendiconti = _daoFactory.GetRendicontoAnnualeDao().GetByEsercizio(idEsercizio);
foreach (var rendicontoOld in rendiconti)
{
try
{
if (rendicontoOld.Stato == StatoRendicontoEnum.Provvisorio && rendicontoOld.Tipo == TipoRendiconto.Preventivo)
_daoFactory.GetRendicontoAnnualeDao().Delete(rendicontoOld);
else if (rendicontoOld.Stato == StatoRendicontoEnum.Definitivo && rendicontoOld.Tipo == TipoRendiconto.Preventivo)
throw new InvalidOperationException("E' già presente un rendiconto Preventivo DEFINITIVO non è possibile creare un ulteriore rendiconto.");
}
catch (Exception ex)
{
var idRendiconto = "<NULL>";
if (rendicontoOld != null)
idRendiconto = rendicontoOld.ID.ToString(CultureInfo.InvariantCulture);
_log.ErrorFormat("Errore inaspettato durante la creazione del bilancio preventivo - ELIMINAZIONE SINGOLO RENDICONTO - {0} - rendiconto:{1} - idEsercizio:{2} - stabile:{3} - scala:{4} - dettaglioSottoConto:{5}", ex, Utility.GetMethodDescription(), idRendiconto, idEsercizio, idStabile.GetValueOrDefault(), idScala.GetValueOrDefault(), dettaglioSottoConto);
throw;
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la creazione del bilancio preventivo - ELIMINAZIONE VECCHI RENDICONTI - {0} - idEsercizio:{1} - stabile:{2} - scala:{3} - dettaglioSottoConto:{5}", ex, Utility.GetMethodDescription(), idEsercizio, idStabile.GetValueOrDefault(), idScala.GetValueOrDefault(), dettaglioSottoConto);
throw;
}
// Elimino il riparto storico
// -----------------------------------------------------------------
try
{
var storico = _daoFactory.GetStoricoRipartoDao().GetByEsercizioTipo(idEsercizio, TipoRendiconto.Preventivo);
foreach (var storicoRiparto in storico)
_daoFactory.GetStoricoRipartoDao().Delete(storicoRiparto);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la creazione del bilancio preventivo - ELIMINAZIONE STORICO - {0} - idEsercizio:{1} - stabile:{2} - scala:{3} - dettaglioSottoConto:{4}", ex, Utility.GetMethodDescription(), idEsercizio, idStabile.GetValueOrDefault(), idScala.GetValueOrDefault(), dettaglioSottoConto);
throw;
}
// Creo il nuovo rendiconto
// -----------------------------------------------------------------
try
{
rendiconto = new RendicontoAnnuale(esercizio, "Bilancio", TipoRendiconto.Preventivo) { CalcoloPerSottoconto = dettaglioSottoConto, Stato = stato };
_daoFactory.GetRendicontoAnnualeDao().SaveOrUpdate(rendiconto);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la creazione del bilancio preventivo - NUOVO RENDICONTO - {0} - idEsercizio:{1} - stabile:{2} - scala:{3} - dettaglioSottoConto:{4}", ex, Utility.GetMethodDescription(), idEsercizio, idStabile.GetValueOrDefault(), idScala.GetValueOrDefault(), dettaglioSottoConto);
throw;
}
}
rendiconto.Stato = stato;
}
catch (Exception ex)
{
var idRendiconto = "<NULL>";
if (rendiconto != null)
idRendiconto = rendiconto.ID.ToString(CultureInfo.InvariantCulture);
_log.ErrorFormat("Errore inaspettato durante la creazione del bilancio preventivo - TESTATA RENDICONTO - {0} - rendiconto:{1} - idEsercizio:{2} - stabile:{3} - scala:{4} - dettaglioSottoConto:{5}", ex, Utility.GetMethodDescription(), idRendiconto, idEsercizio, idStabile.GetValueOrDefault(), idScala.GetValueOrDefault(), dettaglioSottoConto);
throw;
}
// -------------------------------------------
// Dettaglio conti
// -------------------------------------------
foreach (var dettaglioConto in bilancioPreventivo.Dettaglio)
{
try
{
if (dettaglioConto.ImportoPreventivo != null && dettaglioConto.ImportoPreventivo != 0)
{
RendicontoAnnualeConto conto;
if (dettaglioConto.ID == 0)
{
// Stabile e/o Gruppo Stabile (Scala) di riferimento
// --------------------------------------------------
Palazzina stabile = null;
if (dettaglioConto.IdStabile > 0)
stabile = _daoFactory.GetPalazzinaDao().GetById(dettaglioConto.IdStabile.Value, false);
GruppoStabile scala = null;
if (dettaglioConto.IdGruppoStabile > 0)
scala = _daoFactory.GetGruppoStabileDao().GetById(dettaglioConto.IdGruppoStabile.Value, false);
conto = dettaglioConto.IdSottoConto > 0 ? new RendicontoAnnualeConto(rendiconto, _daoFactory.GetSottoContoDao().GetById(dettaglioConto.IdSottoConto, false), dettaglioConto.ImportoPreventivo) : new RendicontoAnnualeConto(rendiconto, _daoFactory.GetContoDao().GetById(dettaglioConto.IdConto, false), dettaglioConto.ImportoPreventivo);
conto.Stabile = stabile;
conto.GruppoStabile = scala;
}
else
{
conto = _daoFactory.GetRendicontoAnnualeContoDao().Find(dettaglioConto.ID, false);
if (conto == null)
{
message = "Errore inaspettato nella creazione del bilancio preventivo." + Environment.NewLine + "Ricaricare la videata e riprovare";
_log.Error("Errore inaspettato durante la creazione del bilancio preventivo - Dettaglio Conti - GetById - " + Utility.GetMethodDescription() + " - dettaglioConto:" + dettaglioConto.ID + " - idEsercizio: " + idEsercizio + " - Stabile:" + idStabile.GetValueOrDefault() + " - Scala:" + idScala.GetValueOrDefault() + " - dettaglio:" + dettaglioSottoConto);
return message;
}
conto.Importo = dettaglioConto.ImportoPreventivo;
}
// Eventuali dettagli per unità
// -------------------------------------
if (dettaglioConto.DettaglioUnita != null && dettaglioConto.DettaglioUnita.Count > 0)
{
decimal importoConto = 0;
foreach (var calcoloUnita in dettaglioConto.DettaglioUnita)
{
try
{
var dettaglioUnita = _daoFactory.GetRendicontoAnnualeUnitaDao().Find(calcoloUnita.ID, false);
if (dettaglioUnita != null)
{
if (calcoloUnita.ImportoPreventivo != null && calcoloUnita.ImportoPreventivo != 0)
dettaglioUnita.Importo = calcoloUnita.ImportoPreventivo;
else // se importo == 0 elimino il dettaglio per unità
{
dettaglioUnita.Conto.DettagliUnita.Remove(dettaglioUnita);
dettaglioUnita.Conto = null;
}
}
else
{
if (calcoloUnita.ImportoPreventivo != null && calcoloUnita.ImportoPreventivo != 0)
new RendicontoAnnualeUnita(conto, _daoFactory.GetUnitaImmobiliareDao().GetById(calcoloUnita.IdUnita, false), calcoloUnita.ImportoPreventivo);
}
if (calcoloUnita.ImportoPreventivo != null)
importoConto += calcoloUnita.ImportoPreventivo.Value;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la creazione del bilancio preventivo - SINGOLA UNITA' - {0} - dettaglioConto:{1} - idEsercizio:{2} - stabile:{3} - scala:{4} - conto:{5} - unità:{6}", ex, Utility.GetMethodDescription(), dettaglioConto.ID, idEsercizio, idStabile.GetValueOrDefault(), idScala.GetValueOrDefault(), dettaglioSottoConto, calcoloUnita.ID);
throw;
}
}
conto.Importo = importoConto;
}
_daoFactory.GetRendicontoAnnualeContoDao().SaveOrUpdate(conto);
}
else if (dettaglioConto.ID > 0)
{
var conto = _daoFactory.GetRendicontoAnnualeContoDao().Find(dettaglioConto.ID, false);
if (conto != null)
{
conto.Rendiconto.Conti.Remove(conto);
conto.Rendiconto = null;
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la creazione del bilancio preventivo - SINGOLO CONTO - {0} - dettaglioConto:{1} - idEsercizio:{2} - stabile:{3} - scala:{4} - dettaglio:{5}", ex, Utility.GetMethodDescription(), dettaglioConto.ID, idEsercizio, idStabile.GetValueOrDefault(), idScala.GetValueOrDefault(), dettaglioSottoConto);
throw;
}
}
// -------------------------------------------------------------
// Memorizzo nell'esercizio il codice del rendiconto DEFINITIVO
// -------------------------------------------------------------
if (stato == StatoRendicontoEnum.Definitivo)
{
esercizio.RendicontoPreventivoCorrente = rendiconto;
if (esercizio.AnnoGestionale.AnnoGestionalePrecedente?.EsercizioOrdinario != null)
esercizio.AnnoGestionale.AnnoGestionalePrecedente.EsercizioOrdinario.RendicontoPreventivoEsercizioSuccessivo = rendiconto;
// se è definitivo storicizzo il riparto
// ===================================================================================
// TODO: Per ora non viene salvato lo storico perchè può capitare che per sbaglio il
// preventivo sia reso definitivo senza che siano stati inseriti i millesimi.
// ===================================================================================
//var messageStorico = StoricizzaRiparto(idEsercizio, TipoRendiconto.Preventivo);
//if (!string.IsNullOrEmpty(messageStorico))
// message += messageStorico + Environment.NewLine;
}
return message;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la creazione del bilancio preventivo - {0} - idEsercizio:{1} - Stabile:{2} - Scala:{3} - Dettaglio:{4}", ex, Utility.GetMethodDescription(), idEsercizio, idStabile.GetValueOrDefault(), idScala.GetValueOrDefault(), dettaglioSottoConto);
throw;
}
}
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 BilancioPreventivoDTO GetPreventivo(int idEsercizio, int? idStabile, int? idScala, bool importiEsercizioPrecedente)
{
try
{
// ===================================================================================
// Domain Model
// ===================================================================================
var esercizio = _daoFactory.GetEsercizioDao().GetById(idEsercizio, false);
IList<ReportBilancioDTO> consuntivo = null;
IList<ReportBilancioDTO> preventivoBilancio = null;
if (esercizio.GetEsercizioPrecedente() != null && importiEsercizioPrecedente)
{
// PER evitare timeout per ora non facciamo calcoli su preventivo o consuntivo dell'anno precedente
consuntivo = GetDataSourceBilancioConsuntivo_SottoConto(esercizio.GetEsercizioPrecedente().ID, null, null, null, null, false, false).ToList();
preventivoBilancio = GetDataSourceBilancioPreventivo_SottoConto(esercizio.GetEsercizioPrecedente().ID, idStabile, idScala, false, false, false, false);
}
var rendiconto = getRendicontoPreventivoCorrente(idEsercizio);
if(rendiconto == null)
{
_log.ErrorFormat("Rendiconto a NULL - {0} - esercizio:{1}", Utility.GetMethodDescription(), idEsercizio);
return null;
}
var bilancio = new BilancioPreventivoDTO
{
ID = rendiconto.ID,
CalcoloPerSottoconto = rendiconto.CalcoloPerSottoconto,
DescrizioneEsercizio = rendiconto.Esercizio.DisplayName,
IdEsercizio = rendiconto.Esercizio.ID,
Note = rendiconto.Note,
StatoRendiconto = rendiconto.Stato
};
if (rendiconto.Documento != null)
bilancio.IdDocumento = rendiconto.Documento.ID;
var preventivoCalcolato = new List<CalcoloBilancioPreventivoDTO>();
// =======================================================================================
// Dettaglio Preventivo
// =======================================================================================
const string hql = "FROM RendicontoAnnualeConto RAC WHERE RAC.Rendiconto = :rendiconto";
var parameters = new List<QueryParam>(3) {new QueryParam("rendiconto", rendiconto)};
var conti = _daoFactory.GetRendicontoAnnualeContoDao().GetByQuery(hql, parameters.ToArray());
// ========================================================
// Elaboro tutte le righe di rendiconto già presenti
// ========================================================
foreach (var conto in conti)
{
if ((conto.ContoRiferimento == null || conto.ContoRiferimento.Deleted != "Y") && (conto.SottoContoRiferimento == null || conto.SottoContoRiferimento.ContoRiferimento.Deleted != "Y"))
{
try
{
var preventivo = new CalcoloBilancioPreventivoDTO {ID = conto.ID};
if (conto.ContoRiferimento != null)
preventivo.OrdineConto = conto.ContoRiferimento.Ordine;
else if (conto.SottoContoRiferimento != null)
preventivo.OrdineConto = conto.SottoContoRiferimento.ContoRiferimento.Ordine;
if (conto.ContoRiferimento != null)
{
preventivo.IdConto = conto.ContoRiferimento.ID;
preventivo.Codice = conto.ContoRiferimento.Codice;
preventivo.Descrizione = conto.ContoRiferimento.Descrizione;
}
else
{
preventivo.IdConto = conto.SottoContoRiferimento.ContoRiferimento.ID;
preventivo.IdSottoConto = conto.SottoContoRiferimento.ID;
preventivo.Codice = conto.SottoContoRiferimento.Codice;
preventivo.Descrizione = conto.SottoContoRiferimento.GetDescrizione(esercizio, null, null);
}
preventivo.ImportoPreventivo = conto.Importo;
if (consuntivo != null)
{
var idConto = 0;
var idSottoConto = 0;
var dettaglioSottoConto = false;
if (preventivo.IdSottoConto > 0)
idSottoConto = preventivo.IdSottoConto;
else
{
idConto = preventivo.IdConto;
dettaglioSottoConto = true;
}
preventivo.ImportoConsuntivo = getImportoConsuntivo(idConto, idSottoConto, consuntivo, dettaglioSottoConto);
}
if (preventivoBilancio != null)
{
var idConto = 0;
var idSottoconto = 0;
if (conto.ContoRiferimento != null)
idConto = conto.ContoRiferimento.ID;
if (conto.SottoContoRiferimento != null)
idSottoconto = conto.SottoContoRiferimento.ID;
preventivo.ImportoPreventivoAnnoPrecedente = getImportoConsuntivo(idConto, idSottoconto, preventivoBilancio, false);
}
// --------------------------------------------------------------------
// Stabile
// --------------------------------------------------------------------
if (conto.Stabile != null)
{
preventivo.IdStabile = conto.Stabile.ID;
preventivo.DescrizioneStabile = conto.Stabile.Descrizione;
}
// --------------------------------------------------------------------
// Gruppo Stabile (Scala)
// --------------------------------------------------------------------
if (conto.GruppoStabile != null)
{
preventivo.IdGruppoStabile = conto.GruppoStabile.ID;
preventivo.DescrizioneGruppoStabile = conto.GruppoStabile.Descrizione;
preventivo.IdStabile = conto.GruppoStabile.PalazzinaRiferimento.ID;
preventivo.DescrizioneStabile = conto.GruppoStabile.PalazzinaRiferimento.Descrizione;
}
// Eventuali dettagli per unita
// -----------------------------
preventivo.DettaglioUnita = new List<CalcoloUnitaBilancioPreventivoDTO>(conto.DettagliUnita.Count);
if (conto.DettagliUnita.Count > 0)
{
int? idConto = null;
int? idSottoConto = null;
if (conto.ContoRiferimento != null)
idConto = conto.ContoRiferimento.ID;
else if (conto.SottoContoRiferimento != null)
{
idSottoConto = conto.SottoContoRiferimento.ID;
idConto = conto.SottoContoRiferimento.ContoRiferimento.ID;
}
var rendiconti = _daoFactory.GetRendicontoAnnualeUnitaDao().GetByConto(rendiconto, idConto, idSottoConto);
IList<ImportiDTO> importi = new List<ImportiDTO>();
if (esercizio.GetEsercizioPrecedente() != null)
importi = _daoFactory.GetSpeseUnitaDao().GetTotaleSpeseByConto(idConto.GetValueOrDefault(), esercizio.GetEsercizioPrecedente());
foreach (var dettaglio in conto.DettagliUnita)
{
try
{
var unita = new CalcoloUnitaBilancioPreventivoDTO
{
ID = dettaglio.ID,
IdTestata = preventivo.ID,
IdUnita = dettaglio.Unita.ID,
Ordine = dettaglio.Unita.Ordine.GetValueOrDefault(),
ImportoPreventivo = dettaglio.Importo,
Descrizione = dettaglio.Unita.Descrizione
};
// --------------------------------------------------------------------
// Importi consuntivo e preventivo anno precedente
// --------------------------------------------------------------------
var rendicontoUnita = (from rend in rendiconti
where rend.Unita.ID == unita.IdUnita
select rend).SingleOrDefault();
if (rendicontoUnita != null)
unita.ImportoPreventivo = rendicontoUnita.Importo;
var importoDTO = (from importo in importi
where importo.Id == unita.IdUnita
select importo).SingleOrDefault();
if (importoDTO != null)
unita.ImportoConsuntivo = importoDTO.Importo;
preventivo.DettaglioUnita.Add(unita);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante il recupero del Preventivo - Elaborazione righe rendiconto già presenti - Dettagli per Unità Immobiliare - {0} - esercizio:{1} - conto:{2} - dettaglio:{3}", ex, Utility.GetMethodDescription(), idEsercizio, conto.ID, dettaglio.ID);
throw;
}
}
// Eventuali dettagli per unità non presenti
addPreventivoPerUnita(preventivo, esercizio, importi);
}
preventivoCalcolato.Add(preventivo);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante il recupero del Preventivo - Elaborazione righe rendiconto già presenti - {0} - esercizio:{1} - conto:{2}", ex, Utility.GetMethodDescription(), idEsercizio, conto.ID);
throw;
}
}
}
// ========================================================
// Aggiungo righe per Stabile
// ========================================================
if (idStabile != null && idScala == null)
{
var contiStabili = from item in conti
where item.Stabile != null && item.Stabile.ID == idStabile.GetValueOrDefault()
select item;
if (contiStabili != null && !contiStabili.Any())
preventivoCalcolato.AddRange(CalcolaPreventivo(idEsercizio, idStabile, idScala, rendiconto.Tipo, null, rendiconto.CalcoloPerSottoconto, false, importiEsercizioPrecedente).Dettaglio);
}
// ========================================================
// Aggiungo righe per Scala
// ========================================================
if (idScala != null)
{
var contiScale = from item in conti
where item.GruppoStabile != null && item.GruppoStabile.ID == idScala.GetValueOrDefault()
select item;
if (contiScale != null && !contiScale.Any())
{
preventivoCalcolato.AddRange(CalcolaPreventivo(idEsercizio, idStabile, idScala, rendiconto.Tipo, null, rendiconto.CalcoloPerSottoconto, false, importiEsercizioPrecedente).Dettaglio);
}
}
// ========================================================
// Aggiungo eventuali conti sottoconti non presenti
// ========================================================
IList<CalcoloBilancioPreventivoDTO> contiAll = CalcolaPreventivo(idEsercizio, idStabile, idScala, rendiconto.Tipo, null, rendiconto.CalcoloPerSottoconto, false, importiEsercizioPrecedente).Dettaglio;
foreach (var contoItem in contiAll)
{
var item1 = contoItem;
var itemFound = from item in preventivoCalcolato
where item.IdConto == item1.IdConto && item.IdSottoConto == item1.IdSottoConto &&
item.IdGruppoStabile == item1.IdGruppoStabile && item.IdStabile == item1.IdStabile
select item;
if (!itemFound.Any())
{
contoItem.IdGruppoStabile = idScala;
contoItem.IdStabile = idStabile;
preventivoCalcolato.Add(contoItem);
}
}
bilancio.Dettaglio = preventivoCalcolato.OrderBy(item => item.OrdineConto).ToList();
return bilancio;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante il recupero del Preventivo - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), idEsercizio);
throw;
}
}
public string SetRendicontoPreventivo(int idEsercizio, int? idStabile, int? idScala, BilancioPreventivoDTO bilancioPreventivo, StatoRendicontoEnum stato, bool dettaglioSottoConto, UserInfo userinfo)
{
var retryCount = 10;
var success = false;
var windsorRep = new WindsorConfigRepository();
string item = null;
while (retryCount >= 0 && !success)
{
try
{
windsorRep.BeginTransaction(userinfo);
var bilancioService = windsorRep.GetContainer(userinfo.Azienda).Resolve<IBilancioService>();
item = bilancioService.SetRendicontoPreventivo(idEsercizio, idStabile, idScala, bilancioPreventivo, stato, dettaglioSottoConto);
windsorRep.Commit();
success = true;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella esecuzione della funzione - TENTATIVO:{0} - {1} - esercizio:{2} - stabile:{3} - scala:{4} - dettaglioSottoConto:{5} - stato:{6} - azienda:{7} - number:{8}", ex, (11 - retryCount), Utility.GetMethodDescription(), idEsercizio, idStabile, idScala, dettaglioSottoConto, stato, userinfo.Azienda, getExceptionId(ex));
windsorRep.Rollback();
if (!isRetryException(ex))
throw;
// Add delay here if you wish.
System.Threading.Thread.Sleep(1000 * (11 - retryCount));
retryCount--;
_log.InfoFormat("Set rendiconto preventivo - INIZIO TENTATIVO:{0} - {1} - esercizio:{2} - stabile:{3} - scala:{4} - dettaglioSottoConto:{5} - stato:{6} - azienda:{7}", (11 - retryCount), Utility.GetMethodDescription(), idEsercizio, idStabile, idScala, dettaglioSottoConto, stato, userinfo.Azienda);
}
}
if (!success)
windsorRep.Rollback();
return item;
}
