public TestataResult SetBilancioApertura(TestataMovimentoContabileGestioneDTO testataDto)
{
try
{
if(testataDto.DataRegistrazione == null)
throw new InvalidDataException("Non è definita la data di registrazione");
var message = string.Empty;
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("AB");
var numeroRiga = 0;
var esercizio = _daoFactory.GetEsercizioDao().GetById(testataDto.CodiceEsercizio, false);
var saldiCondomini = _daoFactory.GetSaldoSoggettoDao().GetByEsercizioStabileScala(esercizio, null, null);
// Controllo correttezza importi
TestataMovimentoContabile testata = null;
if (testataDto.Movimenti.Sum(mov => mov.ImportoDare.GetValueOrDefault()) != testataDto.Movimenti.Sum(mov => mov.ImportoAvere.GetValueOrDefault()))
message = "Il totale Dare:" + testataDto.Movimenti.Sum(mov => mov.ImportoDare.GetValueOrDefault()).ToString("c") + " non corrisponde col totale Avere:" + testataDto.Movimenti.Sum(mov => mov.ImportoAvere.GetValueOrDefault()).ToString("c") + Environment.NewLine;
else if (testataDto.DataRegistrazione == null)
message = "Deve essere definita la data di registrazione" + Environment.NewLine;
else
{
foreach (var movimentoDto in testataDto.Movimenti)
{
if (movimentoDto.Stato == "U")
{
var conto = _daoFactory.GetContoDao().GetById(movimentoDto.IdConto.GetValueOrDefault(), false);
if (conto.Codice == _pianoContiService.GetCodiceContoVersamentiCondomini() && saldiCondomini.Count == 0)
{
message = "Prima di registrare il bilancio di apertura occorre inserire i saldi iniziali dei condomini" + Environment.NewLine;
break;
}
}
}
}
if(string.IsNullOrEmpty(message))
{
// controllo data registrazione
var messageData = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, testataDto.DataRegistrazione.GetValueOrDefault());
if (messageData.Count > 0)
{
_log.WarnFormat("Data di registrazione non valida - {0} - data:{1} - esercizio:{2}", Utility.GetMethodDescription(), testataDto.DataRegistrazione.GetValueOrDefault(), esercizio.ID);
return new TestataResult(null, messageData.Aggregate(message, (current, mess) => current + (mess + Environment.NewLine)));
}
const string hql = "FROM Esercizio ES WHERE ES.CondominioRiferimento = :condominio AND ES.DataApertura >= :data AND ES.DataChiusura <= :data AND ES.Gestione = :gestione";
var listaEsercizi = _daoFactory.GetEsercizioDao().GetByQuery(hql, new[] { new QueryParam("condominio", esercizio.CondominioRiferimento), new QueryParam("data", testataDto.DataRegistrazione.Value), new QueryParam("gestione", Conversione.ToHQLParameter(GestioneEsercizioEnum.Ordinario)) });
if (listaEsercizi.Count == 1)
esercizio = listaEsercizi[0];
testata = _daoFactory.GetTestataMovimentoContabileDao().Find(testataDto.ID, false);
if (testata == null)
{
testata = new TestataMovimentoContabile(esercizio, testataDto.DataRegistrazione.Value, TipoTestataMovimentoContabileEnum.Automatica, null) {AperturaBilancio = true};
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
}
else
{
testata.EsercizioRiferimento = esercizio;
testata.DataRegistrazione = testataDto.DataRegistrazione.Value;
}
testata.Descrizione = testataDto.Descrizione;
foreach (var movimentoDto in testataDto.Movimenti)
{
if (movimentoDto.Stato == "U")
{
var conto = _daoFactory.GetContoDao().GetById(movimentoDto.IdConto.GetValueOrDefault(), false);
string segno;
decimal importo;
if (movimentoDto.ImportoAvere > 0)
{
importo = movimentoDto.ImportoAvere.GetValueOrDefault();
segno = "A";
}
else
{
importo = movimentoDto.ImportoDare.GetValueOrDefault();
segno = "D";
}
// =========================================================================================
// Per il conto versamenti SOLO ESERCIZIO ORDINARIO spalmo l'importo in base ai versamenti dei singoli condomini
// Elimino tutti i movimenti presenti
// =========================================================================================
MovimentoContabile movimento = null;
if (conto.Codice == _pianoContiService.GetCodiceContoVersamentiCondomini() && conto.EsercizioRiferimento == null)
{
// elimino i movimenti
var movimentiOld = testata.Movimenti.Where(item => item.ContoRiferimento.Codice == _pianoContiService.GetCodiceContoVersamentiCondomini()).ToList();
bool deleteOriginalMovimento = movimentoDto.ID > 0;
foreach (var movimentoContabile in movimentiOld)
{
if (movimentoContabile.ID == movimentoDto.ID)
deleteOriginalMovimento = false;
DeleteSingoloMovimento(movimentoContabile);
}
if(deleteOriginalMovimento)
DeleteSingoloMovimento(_daoFactory.GetMovimentoContabileDao().Find(movimentoDto.ID, false));
// creo i nuovi movimenti
foreach (var saldoSoggetto in saldiCondomini)
{
var importoCondomino = saldoSoggetto.Importo;
segno = "D";
if (importoCondomino < 0)
{
segno = "A";
importoCondomino = importoCondomino*-1;
}
numeroRiga++;
movimento = new MovimentoContabile(testata, causale, numeroRiga, conto, importoCondomino, segno) {Descrizione = movimentoDto.Descrizione};
if (string.IsNullOrEmpty(movimento.Descrizione))
movimento.Descrizione = string.Format("Apertura Conto {0}", saldoSoggetto.Soggetto.DisplayName);
movimento.CondominoRiferimento = saldoSoggetto.Soggetto;
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimento);
testata.Movimenti.Add(movimento);
}
}
else
{
movimento = _daoFactory.GetMovimentoContabileDao().Find(movimentoDto.ID, false);
if (movimento == null)
{
numeroRiga++;
movimento = new MovimentoContabile(testata, causale, numeroRiga, conto, importo, segno) {Descrizione = movimentoDto.Descrizione};
if (string.IsNullOrEmpty(movimento.Descrizione))
movimento.Descrizione = "Apertura Conto";
if (movimentoDto.IdFornitore != null && movimentoDto.IdFornitore.GetValueOrDefault() > 0)
movimento.FornitoreRiferimento = _daoFactory.GetFornitoreDao().GetById(movimentoDto.IdFornitore.Value, false);
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimento);
testata.Movimenti.Add(movimento);
}
else
{
numeroRiga++;
movimento.Segno = segno;
movimento.Importo = importo;
movimento.ContoRiferimento = conto;
movimento.NumeroRiga = numeroRiga;
movimento.Descrizione = movimentoDto.Descrizione;
if (movimentoDto.IdFornitore != null && movimentoDto.IdFornitore.GetValueOrDefault() > 0)
movimento.FornitoreRiferimento = _daoFactory.GetFornitoreDao().GetById(movimentoDto.IdFornitore.Value, false);
testata.Movimenti.Add(movimento);
}
}
if (movimento != null)
{
movimentoDto.IdMovimentoRiferimento = movimento.ID;
if (movimentoDto.IdSpesa > 0)
movimento.Spesa = _daoFactory.GetSpesaDao().GetById(movimentoDto.IdSpesa, false);
if (movimentoDto.IdSottoConto != null)
{
if (movimentoDto.IdSottoConto > 0)
{
if (movimento.ContoRiferimento.Codice != _pianoContiService.GetCodiceContoFornitori() && movimento.ContoRiferimento.Codice != _pianoContiService.GetCodiceContoRitenuta() && movimento.ContoRiferimento.Codice != _pianoContiService.GetCodiceContoVersamentiCondomini() && movimento.ContoRiferimento.Codice != _pianoContiService.GetCodiceContoRateCondomini())
{
var sottoConto = _daoFactory.GetSottoContoDao().GetById(movimentoDto.IdSottoConto.Value, false);
movimento.SottoContoRiferimento = sottoConto;
}
}
else
{
try
{
if (movimento.ContoRiferimento != null && !string.IsNullOrEmpty(movimento.ContoRiferimento.Codice))
{
if (movimento.ContoRiferimento.Codice == _pianoContiService.GetCodiceContoBancario())
{
var banca = _daoFactory.GetDatiBancariCondominiDao().Find(movimentoDto.IdSottoConto.Value * -1, false);
if (banca != null)
movimento.ContoCorrenteBancario = banca;
}
else if (movimento.ContoRiferimento.Codice == _pianoContiService.GetCodiceContoVersamentiCondomini())
{
var soggettoCondominio = _daoFactory.GetSoggettoCondominioDao().Find(movimentoDto.IdSottoConto.Value*-1, false);
if (soggettoCondominio != null)
movimento.CondominoRiferimento = soggettoCondominio;
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore imprevisto - CONTO CORRENTE - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), esercizio.ID);
}
}
}
}
}
}
}
return new TestataResult(testata, message);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante l'aggiornamento della quadratura iniziale dei contabili - {0}", ex, Utility.GetMethodDescription());
throw;
}
}
public TestataMovimentoContabileGestioneDTO GetBilancioApertura(int codiceCondominio, int idEsercizio)
{
try
{
const string hql = "FROM TestataMovimentoContabile TES LEFT JOIN FETCH TES.Movimenti MOV LEFT JOIN FETCH MOV.DettaglioRiferimento DETTSPE LEFT JOIN FETCH DETTSPE.SpesaRiferimento SPE LEFT JOIN FETCH SPE.Scadenze SCA LEFT JOIN FETCH SCA.Pagamenti PAG LEFT JOIN FETCH MOV.ContoRiferimento CON LEFT JOIN FETCH MOV.SottoContoRiferimento SOTCON LEFT JOIN FETCH MOV.CondominoRiferimento SOGGCOND LEFT JOIN FETCH MOV.ContoCorrenteBancario BANCA WHERE TES.AperturaBilancio = 1 AND TES.EsercizioRiferimento.CondominioRiferimento.ID = :codiceCondominio";
var testate = _daoFactory.GetTestataMovimentoContabileDao().GetByQuery(hql, new[] { new QueryParam("codiceCondominio", codiceCondominio) });
var contoVersamentiCondomini = _daoFactory.GetContoDao().GetByCodice(idEsercizio, codiceCondominio, _pianoContiService.GetCodiceContoVersamentiCondomini());
// ============================================================================================
// Non è possibile sia presente più di una apertura di bilancio - Loggo errore e ritorno null
// ============================================================================================
if (testate.Count > 1)
{
_log.Error("E' stata trovata più di una apertura di bilancio - " + Utility.GetMethodDescription() + " - condominio:" + codiceCondominio);
return null;
}
// ============================================================================================
// Correttamente presente una apertura di bilancio
// ============================================================================================
if (testate.Count == 1)
{
var testataDto = new TestataMovimentoContabileGestioneDTO
{
ID = testate[0].ID,
CodiceEsercizio = testate[0].EsercizioRiferimento.ID,
DataRegistrazione = testate[0].DataRegistrazione,
Descrizione = testate[0].Descrizione,
NumeroProtocollo = testate[0].NumeroProtocollo
};
foreach (var movimento in testate[0].Movimenti)
{
if (movimento.ContoRiferimento.ID == contoVersamentiCondomini.ID)
{
var movimentoSaldoCondomini = testataDto.Movimenti.SingleOrDefault(item => item.IdConto == contoVersamentiCondomini.ID);
if (movimentoSaldoCondomini != null)
{
var importo = movimentoSaldoCondomini.ImportoAvere.GetValueOrDefault() - movimentoSaldoCondomini.ImportoDare.GetValueOrDefault();
importo += movimento.GetImportoConSegno().GetValueOrDefault();
movimentoSaldoCondomini.ImportoDare = null;
movimentoSaldoCondomini.ImportoAvere = null;
if (importo < 0)
movimentoSaldoCondomini.ImportoDare = Math.Abs(importo);
else
movimentoSaldoCondomini.ImportoAvere = Math.Abs(importo);
continue;
}
}
var movDto = new MovimentoContabileGestioneDTO
{
ID = movimento.ID,
Descrizione = movimento.Descrizione,
DescrizioneCausale = movimento.Causale.Descrizione,
DescrizioneConto = movimento.ContoRiferimento.Descrizione,
IdCausale = movimento.Causale.ID,
IdConto = movimento.ContoRiferimento.ID,
IdTestata = testate[0].ID,
Note = movimento.Note,
NumeroRiga = movimento.NumeroRiga,
Segno = movimento.Segno,
NumeroRegistrazione = movimento.NumeroRegistrazione
};
switch (movimento.Segno)
{
case "D":
movDto.ImportoDare = movimento.GetImportoSenzaSegno();
break;
case "A":
movDto.ImportoAvere = movimento.GetImportoSenzaSegno();
break;
}
if (movimento.SottoContoRiferimento != null)
{
movDto.IdSottoConto = movimento.SottoContoRiferimento.ID;
movDto.DescrizioneSottoConto = movimento.SottoContoRiferimento.GetDescrizione(movimento.Testata.EsercizioRiferimento, null, movimento);
}
else if (movimento.ContoCorrenteBancario != null)
{
movDto.IdSottoConto = movimento.ContoCorrenteBancario.ID * -1;
movDto.DescrizioneSottoConto = movimento.ContoCorrenteBancario.DisplayName;
}
else if (movimento.CondominoRiferimento != null)
{
movDto.IdSottoConto = movimento.CondominoRiferimento.ID * -1;
movDto.DescrizioneSottoConto = movimento.CondominoRiferimento.DisplayName;
}
if (movimento.FornitoreRiferimento != null)
{
movDto.IdFornitore = movimento.FornitoreRiferimento.ID;
movDto.NominativoFornitore = movimento.FornitoreRiferimento.DisplayName;
}
if (movimento.DettaglioRiferimento != null && movimento.DettaglioRiferimento.SpesaRiferimento != null)
{
movDto.NumeroDocumento = movimento.DettaglioRiferimento.SpesaRiferimento.NumeroDocumento;
movDto.DataDocumento = movimento.DettaglioRiferimento.SpesaRiferimento.DataDocumento;
movDto.ImportoRitenuta = movimento.DettaglioRiferimento.SpesaRiferimento.ImportoRitenuta;
movDto.AliquotaRitenuta = movimento.DettaglioRiferimento.SpesaRiferimento.AliquotaRitenuta * 100;
movDto.ImportoIva = movimento.DettaglioRiferimento.ImportoIva;
var scadenza = movimento.DettaglioRiferimento.SpesaRiferimento.Scadenze.FirstOrDefault();
if (scadenza != null && scadenza.Pagamenti.Count == 1)
movDto.DataPagamento = IesiGenericCollections<Pagamento>.GetByIndex(scadenza.Pagamenti, 0).Data;
}
if (movimento.Spesa != null)
{
movDto.IdSpesa = movimento.Spesa.ID;
movDto.NumeroDocumento = movimento.Spesa.NumeroDocumento;
movDto.DataDocumento = movimento.Spesa.DataDocumento;
movDto.ImportoRitenuta = movimento.Spesa.ImportoRitenuta;
movDto.AltreSpese = movimento.Spesa.AltreSpese;
movDto.AltreSpeseEsenti = movimento.Spesa.AltreSpeseEsenti;
var scadenza = movimento.Spesa.Scadenze.FirstOrDefault();
if(scadenza != null)
{
if (scadenza.Pagamenti.Count == 1)
{
var pagamento = scadenza.Pagamenti.FirstOrDefault();
if (pagamento != null)
{
movDto.DataPagamento = pagamento.Data;
if (pagamento.RitenutaAcconto != null)
{
movDto.DataVersamentoRitenuta = pagamento.RitenutaAcconto.GetDataVersamento();
movDto.InteressiRitenuta = pagamento.RitenutaAcconto.ImportoInteressi;
movDto.SanzioniRitenuta = pagamento.RitenutaAcconto.ImportoSanzione;
}
}
}
}
if(movimento.Spesa.Dettagli.Count > 0)
movDto.ImportoFattura = IesiGenericCollections<DettaglioSpesa>.GetByIndex(movimento.Spesa.Dettagli, 0).ImportoLordo + movimento.Spesa.AltreSpese.GetValueOrDefault();
}
testataDto.Movimenti.Add(movDto);
}
return testataDto;
}
// ============================================================================================
// Nessuna apertura di bilancio presente - Ritorno un oggetto vuoto in data di oggi
// ============================================================================================
return new TestataMovimentoContabileGestioneDTO
{
CodiceEsercizio = idEsercizio,
Descrizione = "Apertura di Bilancio",
DataRegistrazione = DateTime.Today
};
}
catch (Exception ex)
{
_log.Fatal("Errore inaspettato durante la lettura del bilancio di apertura - " + Utility.GetMethodDescription() + " - condominio:" + codiceCondominio, ex);
throw;
}
}
private void loadData()
{
if(_condominio != null && _esercizio != null)
_testata = getMovimentoContabileService().GetBilancioApertura(_condominio, _esercizio);
if (_testata != null && _esercizio != null)
{
testataMovimentoContabileGestioneDTOBindingSource.DataSource = _testata;
movimentoContabileGestioneDTOBindingSource.DataSource = new BindingList<MovimentoContabileGestioneDTO>(_testata.Movimenti);
fornitoreListaDTOBindingSource.DataSource = getFornitoreService().GetAll(true);
if (listaConti.DisplayLayout != null)
{
listaConti.DisplayLayout.ValueLists.Clear();
listaConti.DisplayLayout.ValueLists.Add(DataSourceHelper.GetValueList(getPianoContiService().GetBilancioAperturaByCondominio(_condominio), "ID", "DescrizioneCompleta", "Conti"));
listaConti.DisplayLayout.Bands[0].Columns["IdConto"].ValueList = listaConti.DisplayLayout.ValueLists["Conti"];
var listaSegni = new SortedList(2) { { "D", "Dare" }, { "A", "Avere" } };
listaConti.DisplayLayout.ValueLists.Add(DataSourceHelper.GetValueList("Segno", listaSegni));
listaConti.DisplayLayout.Bands[0].Columns["Segno"].ValueList = listaConti.DisplayLayout.ValueLists["Segno"];
}
if (listaConti.DisplayLayout != null && listaConti.DisplayLayout.Bands[0].Summaries.Count == 0)
{
DataGridHelper.AddSummary(listaConti.DisplayLayout.Bands[0], "ImportoDare", "c");
DataGridHelper.AddSummary(listaConti.DisplayLayout.Bands[0], "ImportoAvere", "c");
DataGridHelper.AddSummary(listaConti.DisplayLayout.Bands[0], "ImportoAvere", SummaryType.Custom, new DifferenceSummary("ImportoDare", "ImportoAvere"), "c", "Differenza:");
}
sceltaFornitoreCombo1.LoadData();
listaConti.AfterRowUpdate -= listaContiAfterRowUpdate;
listaConti.PerformAction(UltraGridAction.ExitEditMode);
listaConti.UpdateData();
listaConti.AfterRowUpdate += listaContiAfterRowUpdate;
panelMovimenti.Visible = true;
}
//else
// Library.CommonMessages.DisplayWarning("Si è verificato un problema durante la lettura del Bilancio di Apertura.");
}
public BilancioAperturaMessage SetBilancioApertura(TestataMovimentoContabileGestioneDTO testata)
{
try
{
var fatalMessage = string.Empty;
var warnMessage = string.Empty;
//==============================================
// Controllo esercizio
//==============================================
if (testata.CodiceEsercizio == 0)
{
_log.ErrorFormat("Non è definito alcun esercizio - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage("Non è definito alcun esercizio", string.Empty, false);
}
var esercizio = _daoFactory.GetEsercizioDao().Find(testata.CodiceEsercizio, false);
if(esercizio == null)
{
_log.ErrorFormat("L'esercizio non è stato trovato - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage($"L'esercizio '{testata.CodiceEsercizio}' non è stato trovato.", string.Empty, false);
}
if(esercizio.Gestione == GestioneEsercizioEnum.Straordinario)
{
_log.ErrorFormat("L'esercizio deve essere un esercizio ordinario - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage("L'esercizio deve essere un esercizio ordinario", string.Empty, false);
}
//==============================================
// Controllo Saldi Condomini
//==============================================
var saldiCondomini = _daoFactory.GetSaldoSoggettoDao().GetByEsercizioStabileScala(esercizio, null, null);
var contoCreditiCondomini = _daoFactory.GetContoDao().GetAllByCodice(esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoVersamentiCondomini()).FirstOrDefault(item => item.EsercizioRiferimento == null);
if (contoCreditiCondomini != null)
{
var movimentiVersamentiCondomini = testata.Movimenti.Where(item => item.IdConto == contoCreditiCondomini.ID).ToList();
if (movimentiVersamentiCondomini.Count > 1)
{
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage($"Non può essere presente più di un movimento per il conto {contoCreditiCondomini.Codice} - {contoCreditiCondomini.Descrizione}", string.Empty, false);
}
if (movimentiVersamentiCondomini.Count == 1)
{
var importoCreditiCondomini = movimentiVersamentiCondomini.Sum(item => item.ImportoDare.GetValueOrDefault() - item.ImportoAvere.GetValueOrDefault());
if (importoCreditiCondomini > 0)
{
if (saldiCondomini.Count == 0)
{
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage("Prima di registrare il bilancio di apertura occorre inserire i saldi iniziali dei singoli condomini", string.Empty, true);
}
var totaleSaldiCondomini = saldiCondomini.Sum(item => item.Importo);
if (importoCreditiCondomini != totaleSaldiCondomini)
{
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage($"L'importo del conto crediti v/condomini: {importoCreditiCondomini:c} non corrisponde con la somma dei saldi dei singoli condomini: {totaleSaldiCondomini:c}", string.Empty, true);
}
}
}
}
//==============================================
// Controllo data registrazione
//==============================================
if (testata.DataRegistrazione == null || !Conversione.IsSqlSmallDateTime(testata.DataRegistrazione.GetValueOrDefault()))
{
_log.ErrorFormat("Non è definita la data di registrazione - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage("Non è definita la data di registrazione", string.Empty, false);
}
if(testata.DataRegistrazione.GetValueOrDefault() < esercizio.DataApertura.GetValueOrDefault())
{
_log.DebugFormat("La data di registrazione è inferiore alla data di apertura dell'esercizio - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage("La data di registrazione è inferiore alla data di apertura dell'esercizio", string.Empty, false);
}
//==============================================
// Controllo correttezza importi
//==============================================
if (testata.Movimenti == null)
{
_log.FatalFormat("I movimenti sono a null - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage("I movimenti sono a null", string.Empty, false);
}
if (testata.Movimenti.Sum(mov => mov.ImportoDare.GetValueOrDefault()) != testata.Movimenti.Sum(mov => mov.ImportoAvere.GetValueOrDefault()))
fatalMessage = $"Il totale Dare:{testata.Movimenti.Sum(mov => mov.ImportoDare.GetValueOrDefault()):c} non corrisponde col totale Avere:{testata.Movimenti.Sum(mov => mov.ImportoAvere.GetValueOrDefault()):c}.{Environment.NewLine}";
else
{
var listaDettagli = new Dictionary<int, DettaglioSpesa>();
// ==============================================================================================================
// Se il bilancio di apertura NON è registrato nel primo esercizio occorre registrare solo i movimenti contabili
// ==============================================================================================================
if (IsRequiredDatiFatturaBilancioApertura(esercizio.ID))
{
// ===============================================
// Controllo movimenti
// ===============================================
foreach (var dto in testata.Movimenti)
{
if (dto.Stato == "U")
{
var messageControllo = IsAllowUpdateMovimentoBilancioApertura(dto.ID, dto.IdSpesa);
if (string.IsNullOrEmpty(messageControllo))
{
// ------------------------------------------------------------------------------------
// Se il conto non è Fornitori e Ritenuta devo cancellare l'eventuale spesa associata
// ------------------------------------------------------------------------------------
var conto = _daoFactory.GetContoDao().GetById(dto.IdConto.GetValueOrDefault(), false);
if (conto.Codice == _pianoContiService.GetCodiceContoFornitori() || conto.Codice == _pianoContiService.GetCodiceContoRitenuta())
dto.IdSpesa = 0;
else
{
if (dto.IdSpesa > 0)
{
var messageDeleteSpesa = IsAllowDelete(dto.IdSpesa);
if (!string.IsNullOrEmpty(messageDeleteSpesa.FatalMessage))
return new BilancioAperturaMessage(messageDeleteSpesa.FatalMessage, string.Empty, false);
else
{
var movimento = _daoFactory.GetMovimentoContabileDao().Find(dto.ID, false);
if(movimento != null)
{
movimento.Spesa = null;
movimento.Testata.Movimenti.Remove(movimento);
movimento.Testata = null;
_daoFactory.GetMovimentoContabileDao().Delete(movimento);
}
Delete(dto.IdSpesa);
dto.ID = 0;
dto.IdSpesa = 0;
dto.IdFornitore = 0;
dto.NumeroDocumento = null;
dto.DataDocumento = null;
dto.ImportoFattura = null;
dto.ImportoIva = null;
dto.ImportoRitenuta = null;
dto.InteressiRitenuta = null;
dto.SanzioniRitenuta = null;
dto.AliquotaRitenuta = null;
dto.AltreSpese = null;
dto.AltreSpeseEsenti = null;
dto.DataPagamento = null;
dto.DataVersamentoRitenuta = null;
}
}
}
}
else
{
fatalMessage += messageControllo + Environment.NewLine;
_log.WarnFormat("{0} - {1} - testata:{2}", fatalMessage, Utility.GetMethodDescription(), testata.ID);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage(fatalMessage, string.Empty, false);
}
}
}
var index = 0;
// ===============================================
// Elaborazione di tutti i movimenti
// ===============================================
foreach (var movimento in testata.Movimenti)
{
try
{
if (movimento.Stato == "U")
{
if (movimento.IdConto == null)
{
_log.FatalFormat("I movimenti sono a null - 2 - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage($"Non è presente il conto per la riga:{movimento.NumeroRiga.GetValueOrDefault()}", string.Empty, false);
}
index++;
if (movimento.ID == 0)
movimento.ID = index*-1;
// ----------------------------------------------------------
// Se è presente il fornitore devo gestire la fattura
// ----------------------------------------------------------
var conto = _daoFactory.GetContoDao().GetById(movimento.IdConto.GetValueOrDefault(), false);
if (movimento.IdFornitore > 0 && (conto.Codice == _pianoContiService.GetCodiceContoFornitori() || conto.Codice == _pianoContiService.GetCodiceContoRitenuta()))
{
var fornitore = _daoFactory.GetFornitoreDao().GetById(movimento.IdFornitore.GetValueOrDefault(), false);
// ----------------------------------
// Importi
// ----------------------------------
decimal importo;
decimal? importoRitenuta = null;
try
{
if (movimento.ImportoAvere.GetValueOrDefault() > 0)
{
importo = movimento.ImportoAvere.GetValueOrDefault() - movimento.AltreSpeseEsenti.GetValueOrDefault();
importoRitenuta = movimento.ImportoRitenuta;
}
else
{
importo = (movimento.ImportoDare.GetValueOrDefault() - movimento.AltreSpeseEsenti.GetValueOrDefault()) * -1;
if(movimento.ImportoRitenuta != null)
importoRitenuta = movimento.ImportoRitenuta.GetValueOrDefault()*-1;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - IMPORTI - {0} - idTestata:{1}", ex, Utility.GetMethodDescription(), testata.ID);
throw;
}
// ----------------------------------
// Spesa
// ----------------------------------
GestioneCondomini.Domain.Spesa spesa;
try
{
if (movimento.ID > 0)
{
var mov = _daoFactory.GetMovimentoContabileDao().Find(movimento.ID, false);
if (mov != null)
{
if (mov.Spesa != null)
spesa = mov.Spesa;
else
{
if (mov.DettaglioRiferimento?.SpesaRiferimento == null)
{
var messageSpesa = getNewSpesa(fornitore, esercizio, testata, movimento, out spesa);
if (!string.IsNullOrEmpty(messageSpesa))
{
fatalMessage += messageSpesa + Environment.NewLine;
_log.ErrorFormat("Errore nella generazione della spesa - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage(fatalMessage, string.Empty, false);
}
}
else
spesa = mov.DettaglioRiferimento.SpesaRiferimento;
}
}
else
{
int? idMov = null;
if (mov != null)
idMov = mov.ID;
_log.ErrorFormat("Non è stato trovato il movimento contabile - {0} - id:{1}", Utility.GetMethodDescription(), idMov);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage("Non è stato trovato il movimento contabile", string.Empty, false);
}
if (spesa != null)
spesa.FornitoreRiferimento = fornitore;
}
else
{
spesa = new GestioneCondomini.Domain.Spesa(fornitore, esercizio, null);
try
{
if (_protocolloService == null)
{
_log.ErrorFormat("Errore di inizializzazione del protocollo service - {0} - idEsercizio:{1} - idTestata:{2}", Utility.GetMethodDescription(), testata.CodiceEsercizio, testata.ID);
fatalMessage = "Errore di inizializzazione del protocollo service.";
}
if (movimento.DataDocumento == null)
{
_log.ErrorFormat("La data del documento è null - {0} - documento:{1} - movimento:{2} - esercizio:{3} - testata:{4}", Utility.GetMethodDescription(), movimento.NumeroDocumento, movimento.ID, testata.CodiceEsercizio, testata.ID);
fatalMessage = "La data del documento è null.";
}
if (esercizio.CondominioRiferimento == null)
{
_log.FatalFormat("Il Condominio è null - {0} - documento:{1} - movimento:{2} - esercizio:{3} - testata:{4}", Utility.GetMethodDescription(), movimento.NumeroDocumento, movimento.ID, testata.CodiceEsercizio, testata.ID);
fatalMessage = "Il Condominio è null.";
}
var protocollo = _protocolloService.GetProgressivo(TipoProtocollo.Fattura, esercizio.DataApertura.GetValueOrDefault().Year, esercizio.CondominioRiferimento);
if (protocollo.Progressivo != null)
spesa.NumeroProtocollo = protocollo.Progressivo;
else
return new BilancioAperturaMessage(protocollo.Message, string.Empty, false);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel recuperare il progressivo - {0} - data:{1:d} - condominio:{2} - movimento:{3} - esercizio:{4} - testata:{5}", ex, Utility.GetMethodDescription(), movimento.DataDocumento.GetValueOrDefault(), esercizio.CondominioRiferimento.ID, movimento.ID, testata.CodiceEsercizio, testata.ID);
fatalMessage = "Errore inaspettato nel recuperare il progressivo.";
}
_daoFactory.GetSpesaDao().SaveOrUpdate(spesa);
}
if (spesa != null)
{
spesa.TipoDocumento = "FATBILAPP";
spesa.ImportoRitenuta = importoRitenuta;
spesa.AltreSpeseEsenti = movimento.AltreSpeseEsenti;
spesa.AltreSpese = movimento.AltreSpese;
spesa.IsRitenutaCalcoloImponibile = spesa.FornitoreRiferimento.IsRitenutaCalcolataImponibile;
if(movimento.AliquotaRitenuta != null)
spesa.AliquotaRitenuta = movimento.AliquotaRitenuta.GetValueOrDefault()/100;
else
spesa.AliquotaRitenuta = null;
spesa.NumeroDocumento = movimento.NumeroDocumento;
spesa.DataDocumento = movimento.DataDocumento;
spesa.Stato = conto.Codice == _pianoContiService.GetCodiceContoFornitori() ? StatoSpesaEnum.Inserita : StatoSpesaEnum.Pagata;
movimento.IdSpesa = spesa.ID;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - SPESA - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID);
throw;
}
// ----------------------------------
// Dettaglio Spesa
// ----------------------------------
DettaglioSpesa dettaglio = null;
try
{
if (conto.Codice == _pianoContiService.GetCodiceContoFornitori() || conto.Codice == _pianoContiService.GetCodiceContoRitenuta())
{
if (movimento.ID > 0 && _daoFactory.GetMovimentoContabileDao().GetById(movimento.ID, false).DettaglioRiferimento != null)
dettaglio = _daoFactory.GetMovimentoContabileDao().GetById(movimento.ID, false).DettaglioRiferimento;
else
{
dettaglio = new DettaglioSpesa(spesa, 1);
_daoFactory.GetDettaglioSpesaDao().SaveOrUpdate(dettaglio);
}
dettaglio.Descrizione = movimento.Descrizione;
dettaglio.ImportoLordo = conto.Codice == _pianoContiService.GetCodiceContoFornitori() ? importo - movimento.AltreSpese.GetValueOrDefault() : movimento.ImportoFattura;
dettaglio.ImportoIva = movimento.ImportoIva;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - DETTAGLIO SPESA - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID);
throw;
}
// ------------------------------------------------------
// Scadenza - SOLO se non di tratta di nota di accredito
// ------------------------------------------------------
ScadenzaFattura scadenza = null;
try
{
if (spesa != null && movimento.ImportoDare.GetValueOrDefault() == 0)
{
if (movimento.ID > 0)
scadenza = IesiGenericCollections<ScadenzaFattura>.GetByIndex(spesa.Scadenze, 0);
if (scadenza == null)
{
scadenza = new ScadenzaFattura(spesa, esercizio.DataApertura, importo - spesa.ImportoRitenuta.GetValueOrDefault())
{
Stato = conto.Codice == _pianoContiService.GetCodiceContoFornitori() ? StatoSpesaEnum.Inserita : StatoSpesaEnum.Pagata
};
_daoFactory.GetScadenzaFatturaDao().SaveOrUpdate(scadenza);
}
if (conto.Codice == _pianoContiService.GetCodiceContoFornitori())
{
scadenza.Importo = importo + spesa.AltreSpeseEsenti.GetValueOrDefault() - spesa.ImportoRitenuta.GetValueOrDefault();
scadenza.ImportoRitenuta = spesa.ImportoRitenuta;
if (movimento.DataPagamento != null)
scadenza.Scadenza = movimento.DataPagamento.GetValueOrDefault();
}
else
{
scadenza.Importo = 0;
scadenza.ImportoRitenuta = importoRitenuta;
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - SCADENZA - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID);
throw;
}
// =================================================================================
// RITENUTE
// ----------------------------------
// Pagamento
// ----------------------------------
try
{
// Inserimento pagamento fattura per ritenuta in bilancio di apertura da pagare
if (scadenza != null && conto.Codice == _pianoContiService.GetCodiceContoRitenuta())
{
Pagamento pagamento;
if (scadenza.Pagamenti.Count > 0)
{
pagamento = scadenza.Pagamenti.First();
pagamento.Data = movimento.DataPagamento.GetValueOrDefault();
pagamento.RitenutaAcconto.Importo = scadenza.ImportoRitenuta;
pagamento.RitenutaAcconto.ImportoInteressi = movimento.InteressiRitenuta;
pagamento.RitenutaAcconto.ImportoSanzione = movimento.SanzioniRitenuta;
pagamento.Importo = spesa.ImportoLordo - pagamento.RitenutaAcconto.Importo.GetValueOrDefault();
pagamento.Stato = StatoSpesaEnum.Pagata;
// Se il pagamento è già presente devo annullare la ritenuta eventualmente già versata
// TODO: Verificare se è necessario controllare che non si tratti di un versamento CBI
if (pagamento.RitenutaAcconto != null && pagamento.RitenutaAcconto.TestataRiferimento != null)
{
var messageDeleteRitenuta = _ritenutaService.DeletePagamentoRitenuta(pagamento.RitenutaAcconto.TestataRiferimento.ID);
if (!string.IsNullOrEmpty(messageDeleteRitenuta))
fatalMessage += messageDeleteRitenuta + Environment.NewLine;
}
}
else
{
pagamento = new Pagamento(scadenza, null, spesa.ImportoLordo, movimento.DataPagamento.GetValueOrDefault(), TipoPagamentoFatturaEnum.AltroAmministratore)
{
RitenutaAcconto = new Ritenuta(scadenza.ImportoRitenuta)
{
ImportoInteressi = movimento.InteressiRitenuta,
ImportoSanzione = movimento.SanzioniRitenuta,
Stato = StatoRitenutaEnum.Inserita
},
Stato = StatoSpesaEnum.Pagata
};
_daoFactory.GetPagamentoDao().SaveOrUpdate(pagamento);
}
// -------------------------------------------------------------------------------------------
// Se presente la data di versamento della ritenuta la ritenuta inserita è già stata versata
// -------------------------------------------------------------------------------------------
if (string.IsNullOrEmpty(fatalMessage) && movimento.DataVersamentoRitenuta != null)
{
var contoRitenuta = _daoFactory.GetContoDao().GetByCodice(scadenza.SpesaRiferimento.EsercizioRiferimento.ID, scadenza.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoBancario());
_ritenutaService.PagamentoRitenuta(pagamento, movimento.DataVersamentoRitenuta.GetValueOrDefault(), contoRitenuta, null, testata.Descrizione, null, null, null);
}
}
if (dettaglio != null)
listaDettagli.Add(movimento.ID, dettaglio);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - PAGAMENTO - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID);
throw;
}
// =================================================================================
// FATTURE
// ---------------------------------------------------------------------------------
// Inserimento pagamento fattura per fattura in bilancio di apertura ma già pagata
// ---------------------------------------------------------------------------------
try
{
if (spesa != null && string.IsNullOrEmpty(fatalMessage) && conto.Codice == _pianoContiService.GetCodiceContoFornitori() && movimento.DataPagamento != null)
{
if (spesa.ID > 0 && scadenza?.Pagamenti != null && scadenza.Pagamenti.Count > 0)
{
var messageAnnullamentoPagamenti = _pagamentoService.IsAllowAnnullamentoPagamentiSpesa(spesa.ID);
if (string.IsNullOrEmpty(messageAnnullamentoPagamenti.FatalMessage))
_pagamentoService.AnnullamentoPagamentiSpesa(spesa.ID);
else
fatalMessage += messageAnnullamentoPagamenti.FatalMessage + Environment.NewLine;
}
if (string.IsNullOrEmpty(fatalMessage))
{
var idScadenza = 0;
decimal? importoScadenza = spesa.ImportoLordo;
var dataScadenza = movimento.DataPagamento;
var statoScadenza = StatoSpesaEnum.Inserita;
if (scadenza != null)
{
idScadenza = scadenza.ID;
importoScadenza = scadenza.Importo;
dataScadenza = scadenza.Scadenza;
statoScadenza = scadenza.Stato;
}
int? idSottoConto = null;
var datiBancari = esercizio.CondominioRiferimento.DatiBancariPrincipale;
if (datiBancari != null)
idSottoConto = datiBancari.ID*-1;
var scadenze = new List<ScadenzaFatturaDTO>(1)
{
new ScadenzaFatturaDTO
{
ID = idScadenza,
IdContoPagamentoScadenza = _pianoContiService.GetContoBancario(esercizio).ID,
DataPagamentoRitenuta = null,
DataPagamentoScadenza = movimento.DataPagamento.GetValueOrDefault(),
IdSottoContoPagamentoScadenza = idSottoConto,
IdSpesa = spesa.ID,
Importo = importoScadenza,
ImportoRitenuta = movimento.ImportoRitenuta,
Scadenza = dataScadenza,
StatoScadenza = statoScadenza,
Stato = "U"
}
};
var messagePagamenti = _pagamentoService.CreatePagamentiImmediati(spesa.ID, scadenze, null);
if (!string.IsNullOrEmpty(messagePagamenti))
fatalMessage += messagePagamenti + Environment.NewLine;
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - PAGAMENTO 2 - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID);
throw;
}
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - SINGOLO MOVIMENTO - {0} - movimento:{1} - testata:{2}", ex, Utility.GetMethodDescription(), movimento.ID, testata.ID);
throw;
}
}
}
try
{
if(string.IsNullOrEmpty(fatalMessage))
{
var result = _movimentoContabileService.SetBilancioApertura(testata);
fatalMessage += result.Message;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - MOVIMENTI CONTABILI - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID);
throw;
}
try
{
if(string.IsNullOrEmpty(fatalMessage))
{
foreach (var dto in testata.Movimenti)
{
try
{
if (dto.IdMovimentoRiferimento > 0 && listaDettagli.ContainsKey(dto.ID))
_daoFactory.GetMovimentoContabileDao().GetById(dto.IdMovimentoRiferimento, false).DettaglioRiferimento = listaDettagli[dto.ID];
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - IMPOSTAZIONE DETTAGLIO RIFERIMENTO (SINGOLO DETTAGLIO) - {0} - id:{1} - testata:{2}", ex, Utility.GetMethodDescription(), dto.ID, testata.ID);
throw;
}
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - IMPOSTAZIONE DETTAGLIO RIFERIMENTO - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID);
throw;
}
// =============================================================================================
// Esercizi Precedenti: Se chiusi occorre eliminare le registrazioni di chiusura - bugid#2472
// =============================================================================================
var eserciziPrecedenti =
esercizio.CondominioRiferimento.Esercizi.Where(
item =>
item.Stato == StatoEsercizioEnum.Chiuso &&
item.Gestione == GestioneEsercizioEnum.Ordinario &&
item.DataApertura.GetValueOrDefault() < esercizio.DataApertura.GetValueOrDefault()).ToList();
foreach (var esercizioPrecedente in eserciziPrecedenti)
_movimentoContabileService.EliminazioneOperazioniAperturaChiusura(esercizioPrecedente);
}
if (!string.IsNullOrEmpty(fatalMessage))
{
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
}
return new BilancioAperturaMessage(fatalMessage, warnMessage, false);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID);
throw;
}
}
private string getNewSpesa(Fornitore fornitore, Esercizio esercizio, TestataMovimentoContabileGestioneDTO testata, MovimentoContabileGestioneDTO movimento, out GestioneCondomini.Domain.Spesa spesa)
{
var message = string.Empty;
spesa = new GestioneCondomini.Domain.Spesa(fornitore, esercizio, null);
try
{
if (_protocolloService == null)
{
_log.ErrorFormat("Errore di inizializzazione del protocollo service - {0} - documento:{1} - movimento:{2} - esercizio:{3} - testata:{4}", Utility.GetMethodDescription(), movimento.NumeroDocumento, movimento.ID, testata.CodiceEsercizio, testata.ID);
message = "Errore di inizializzazione del protocollo service.";
return message;
}
if (movimento.DataDocumento == null)
{
_log.ErrorFormat("La data del documento è null - {0} - documento:{1} - movimento:{2} - esercizio:{3} - testata:{4}", Utility.GetMethodDescription(), movimento.NumeroDocumento, movimento.ID, testata.CodiceEsercizio, testata.ID);
message = "La data del documento è null.";
}
if (esercizio.CondominioRiferimento == null)
{
_log.ErrorFormat("Il Condominio è null - {0} - documento:{1} - movimento:{2} - esercizio:{3} - testata:{4}", Utility.GetMethodDescription(), movimento.NumeroDocumento, movimento.ID, testata.CodiceEsercizio, testata.ID);
message = "Il Condominio è null.";
}
var protocollo = _protocolloService.GetProgressivo(TipoProtocollo.Fattura, esercizio.DataApertura.GetValueOrDefault().Year, esercizio.CondominioRiferimento);
if (protocollo.Progressivo != null)
spesa.NumeroProtocollo = protocollo.Progressivo;
else
return protocollo.Message;
}
catch (Exception ex)
{
var idCondominio = "<NULL>";
if (esercizio?.CondominioRiferimento != null)
idCondominio = esercizio.CondominioRiferimento.ID.ToString(CultureInfo.InvariantCulture);
_log.ErrorFormat("Errore inaspettato nel recuperare il progressivo - {0} - data:{1:d} - condominio:{2} - movimento:{3} - esercizio:{4} - testata:{5}", ex, Utility.GetMethodDescription(), movimento.DataDocumento.GetValueOrDefault(), idCondominio, movimento.ID, testata.CodiceEsercizio, testata.ID);
message = "Errore inaspettato nel recuperare il progressivo.";
}
_daoFactory.GetSpesaDao().SaveOrUpdate(spesa);
return message;
}
public BilancioAperturaMessage SetBilancioApertura(TestataMovimentoContabileGestioneDTO testata)
{
var result = GetServiceClient().SetBilancioApertura(testata, GetUserInfo());
CloseService();
return result;
}
public BilancioAperturaMessage SetBilancioApertura(TestataMovimentoContabileGestioneDTO testataDto, UserInfo userinfo)
{
var retryCount = 10;
var success = false;
var windsorRep = new WindsorConfigRepository();
var item = new BilancioAperturaMessage(null, null, false);
while (retryCount >= 0 && !success)
{
try
{
windsorRep.BeginTransaction(userinfo);
var service = windsorRep.GetContainer(userinfo.Azienda).Resolve<ISpesaService>();
item = service.SetBilancioApertura(testataDto);
windsorRep.Commit();
success = true;
}
catch (InvalidDataException ex)
{
windsorRep.Rollback();
return new BilancioAperturaMessage(ex.Message, string.Empty, false);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella conferma del bilancio di apertura - TENTATIVO:{0} - {1} - esercizio:{2} - azienda:{3} - number:{4}", ex, (11 - retryCount), Utility.GetMethodDescription(), testataDto.CodiceEsercizio, 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("Conferma del bilancio di apertura - INIZIO TENTATIVO:{0} - {1} - esercizio:{2} - azienda:{3}", (11 - retryCount), Utility.GetMethodDescription(), testataDto.CodiceEsercizio, userinfo.Azienda);
}
}
if (!success)
windsorRep.Rollback();
return item;
}
