public MovimentoContabileGenericoUC(int idTestata, CondominioDTO condominio, EsercizioDTO esercizio, bool allowUpdate)
{
_allowUpdate = allowUpdate;
InitializeComponent();
if (!DesignMode)
{
inizializza();
_condominio = condominio;
_esercizio = esercizio;
_testata = _movimentoService.GetTestataGenericaById(idTestata);
if (_condominio != null)
{
var eserciziDataSource = getEsercizioService().GetByCondominio(_condominio);
if (eserciziDataSource != null)
eserciziDTOBindingSource.DataSource = eserciziDataSource;
}
validationSummary1.Validators.Add(reqEsercizi);
}
}
public string SetTestataContabileGenerica(TestataMovimentoContabileGenericoDTO dto)
{
try
{
var message = string.Empty;
var numeroRiga = 0;
if (dto.IdEsercizio > 0)
{
if (dto.Movimenti.Sum(mov => mov.ImportoDare.GetValueOrDefault()) !=
dto.Movimenti.Sum(mov => mov.ImportoAvere.GetValueOrDefault()))
message = "Il totale Dare:" + dto.Movimenti.Sum(mov => mov.ImportoDare.GetValueOrDefault()).ToString("c") + " non corrisponde col totale Avere:" + dto.Movimenti.Sum(mov => mov.ImportoAvere.GetValueOrDefault()).ToString("c") + Environment.NewLine;
else if (dto.DataRegistrazione == null)
message = "Deve essere definita la data di registrazione" + Environment.NewLine;
else
{
var esercizio = _daoFactory.GetEsercizioDao().Find(dto.IdEsercizio.GetValueOrDefault(), false);
if (esercizio != null && esercizio.Stato == StatoEsercizioEnum.Aperto)
{
// controllo data registrazione
var messageData = IsAllowDataRegistrazione(new List<int> {esercizio.CondominioRiferimento.ID}, esercizio, dto.DataRegistrazione.GetValueOrDefault());
if (messageData.Count > 0)
{
_log.WarnFormat("Data di registrazione non valida - {0} - data:{1} - esercizio:{2}", Utility.GetMethodDescription(), dto.DataRegistrazione.GetValueOrDefault(), esercizio.ID);
return messageData.Aggregate(message, (current, mess) => current + (mess + Environment.NewLine));
}
var causale = _daoFactory.GetCausaleContabileDao().GetById(dto.IdCausale, false);
var testata = _daoFactory.GetTestataMovimentoContabileDao().Find(dto.ID, false);
if (testata == null)
{
testata = new TestataMovimentoContabile(esercizio, dto.DataRegistrazione.Value, TipoTestataMovimentoContabileEnum.Manuale, null) {IsAllowUpdate = false};
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
}
else
{
// ----------------------------------------------------------
// Verifico che tutti i movimenti siano aggiornabili
// ----------------------------------------------------------
message = testata.Movimenti.Select(movimento => IsAllowUpdateMovimento(movimento.ID)).Where(messageMovimento => !string.IsNullOrEmpty(messageMovimento)).Aggregate(message, (current, messageMovimento) => current + string.Format("{0}{1}", messageMovimento, Environment.NewLine));
if (!string.IsNullOrEmpty(message))
return message;
// ----------------------------------------------------------
testata.EsercizioRiferimento = esercizio;
testata.DataRegistrazione = dto.DataRegistrazione.Value;
testata.Movimenti.Clear();
}
testata.Descrizione = dto.Descrizione;
foreach (var movimentoDto in dto.Movimenti)
{
numeroRiga++;
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";
}
var movimento = _daoFactory.GetMovimentoContabileDao().Find(movimentoDto.ID, false);
if (movimento == null)
{
movimento = new MovimentoContabile(testata, causale, numeroRiga, conto, importo, segno) {Descrizione = movimentoDto.Descrizione};
if (movimentoDto.IdFornitore != null && movimentoDto.IdFornitore.GetValueOrDefault() > 0)
movimento.FornitoreRiferimento = _daoFactory.GetFornitoreDao().GetById(movimentoDto.IdFornitore.Value, false);
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimento);
}
else
{
movimento.Causale = causale;
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 (movimentoDto.IdSottoConto != null)
{
if (movimentoDto.IdSottoConto > 0)
{
var sottoConto = _daoFactory.GetSottoContoDao().GetById(movimentoDto.IdSottoConto.Value, false);
movimento.SottoContoRiferimento = sottoConto;
}
else if (movimentoDto.IdSottoConto < 0)
{
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.GetCodiceContoFornitori())
{
var fornitore = _daoFactory.GetFornitoreDao().Find(movimentoDto.IdSottoConto.Value*-1, false);
if (fornitore != null)
movimento.FornitoreRiferimento = fornitore;
}
else if (movimento.ContoRiferimento.Codice == _pianoContiService.GetCodiceContoVersamentiCondomini() || movimento.ContoRiferimento.Codice == _pianoContiService.GetCodiceContoRateCondomini())
{
var soggetto = _daoFactory.GetSoggettoCondominioDao().Find(movimentoDto.IdSottoConto.Value*-1, false);
if (soggetto != null)
movimento.CondominoRiferimento = soggetto;
}
}
}
}
// Aggiorno l'importo dell'eventuale versamento associato
foreach (var movimentoContabile in testata.Movimenti)
{
var versamento = _daoFactory.GetVersamentoSoggettoDao().GetByMovimentoContabile(movimentoContabile);
if (versamento != null)
versamento.Importo = movimentoContabile.Importo.GetValueOrDefault();
}
}
else
{
if (esercizio != null)
message += "La registrazione non è possibile perchè l'esercizio è chiuso." + Environment.NewLine;
else
{
message += "L'esercizio non è più presente nel database." + Environment.NewLine;
_log.WarnFormat("Tentativo di registrare una testata generica di movimento contabile per un esercizio inesistente - {0} - esercizio:{1} - testata:{2}", Utility.GetMethodDescription(), dto.IdEsercizio, dto.ID);
}
}
}
}
return message;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante l'aggiornamento della testata generica di movimento contabile - {0}", Utility.GetMethodDescription(), ex);
throw;
}
}
private TestataMovimentoContabileGenericoDTO setGenericoDto(TestataMovimentoContabile item)
{
try
{
if (item != null)
{
var movRep = new MovimentoContabileRepository(_info, _windsorRepository);
var dto = new TestataMovimentoContabileGenericoDTO
{
DataRegistrazione = item.DataRegistrazione,
IdCausale = Library.IesiGenericCollections<MovimentoContabile>.GetByIndex(item.Movimenti, 0).Causale.ID,
IdEsercizio = item.EsercizioRiferimento.ID,
ID = item.ID,
Tipo = item.Tipo,
NumeroProtocollo = item.NumeroProtocollo,
IsAllowUpdate = item.IsAllowUpdate,
Descrizione = item.Descrizione
};
foreach (var movimento in item.Movimenti)
{
var movDto = movRep.GetGenericoByDomainEntity(movimento);
movDto.IdTestata = dto.ID;
dto.Movimenti.Add(movDto);
}
return dto;
}
return null;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel caricamento della Testata Contabile - {0} - testata:{1}", ex, Library.Utility.GetMethodDescription(), item != null ? item.ID.ToString() : "<NULL>");
throw;
}
}
public TestataMovimentoContabileGenericoDTO GetTestataGenericaNew(EsercizioDTO esercizio)
{
var testata = new TestataMovimentoContabileGenericoDTO
{
Movimenti = new List<MovimentoContabileGenericoDTO>(),
Tipo = TipoTestataMovimentoContabileEnum.Manuale
};
if (esercizio != null)
testata.IdEsercizio = esercizio.ID;
return testata;
}
public string SetTestataContabileGenerica(TestataMovimentoContabileGenericoDTO testata)
{
var result = GetServiceClient().SetTestataContabileGenerica(testata, GetUserInfo());
CloseService();
return result;
}
public string SetTestataContabileGenerica(TestataMovimentoContabileGenericoDTO dto, UserInfo userinfo)
{
var retryCount = 5;
var success = false;
var windsorRep = new WindsorConfigRepository();
string item = null;
while (retryCount >= 0 && !success)
{
try
{
windsorRep.BeginTransaction(userinfo);
var service = windsorRep.GetContainer(userinfo.Azienda).Resolve<IMovimentiContabiliService>();
item = service.SetTestataContabileGenerica(dto);
windsorRep.Commit();
success = true;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella conferma di una testata contabile generica - TENTATIVO:{0} - {1} - esercizio:{2} - azienda:{3} - number:{4}", ex, (6 - retryCount), Utility.GetMethodDescription(), dto.IdEsercizio, userinfo.Azienda, getExceptionId(ex));
windsorRep.Rollback();
if (!isRetryException(ex))
{
if (getExceptionId(ex) == "547")
return "Non è consentito l'aggiornamento del movimento perchè è collegato con altre registrazioni, probabilmente un pagamento a fornitore o un versamento di ritenuta.";
throw;
}
// Add delay here if you wish.
System.Threading.Thread.Sleep(1000 * (6 - retryCount));
retryCount--;
_log.InfoFormat("Conferma di una testata contabile generica - INIZIO TENTATIVO:{0} - {1} - esercizio:{2} - azienda:{3}", (6 - retryCount), Utility.GetMethodDescription(), dto.IdEsercizio, userinfo.Azienda);
}
}
if (!success)
windsorRep.Rollback();
return item;
}
public bool Conferma()
{
validationSummary1.Validate();
if (validationSummary1.IsValid)
{
if (_testata.IdEsercizio > 0)
{
var message = _movimentoService.SetTestataContabileGenerica(_testata);
if (string.IsNullOrEmpty(message))
{
CommonMessages.DisplayComplete("I movimenti contabili sono stati correttamente salvati.");
// Sono in inserimento mi preparo per inserire una nuova registrazione
if (_testata.ID == 0)
{
_testata = _movimentoService.GetTestataGenericaNew(getEsercizio());
testataMovimentoContabileGenericoDTOBindingSource.DataSource = _testata;
}
return true;
}
CommonMessages.DisplayWarning("Si sono verificati i seguenti problemi durante il salvataggio dei movimenti contabili:" + Environment.NewLine + message);
}
else
{
CommonMessages.DisplayWarning("Non è stato scelto nessun esercizio.");
_log.WarnFormat("Errore nel caricamento del movimento generico - {0} - testata:{1} - azienda:{2}", Gipasoft.Library.Utility.GetMethodDescription(), _testata.ID, Security.Login.Instance.CurrentLogin().Azienda);
}
}
else
validationSummary1.ShowErrorSummary();
return false;
}
private void load()
{
try
{
if ((_testata == null || _testata.ID == 0) && getEsercizio() != null)
_testata = _movimentoService.GetTestataGenericaNew(getEsercizio());
if (_testata != null)
{
causaleContabileDTOBindingSource.DataSource = _testata.IsAllowUpdate ? _tabelleContabiliService.GetCausaliUtente() : _tabelleContabiliService.GetAllCausali();
testataMovimentoContabileGenericoDTOBindingSource.DataSource = _testata;
fornitoreListaDTOBindingSource.DataSource = getFornitoreService().GetAll(true);
if (listaMovimenti.DisplayLayout != null)
{
listaMovimenti.DisplayLayout.ValueLists.Clear();
var conti = getEsercizio() != null ? getPianoContiService().GetAllByEsercizio(getEsercizio().ID, true) : getPianoContiService().GetByCondominio(_condominio, false);
listaMovimenti.DisplayLayout.ValueLists.Add(DataSourceHelper.GetValueList(conti, "ID", "DescrizioneCompleta", "Conti"));
listaMovimenti.DisplayLayout.Bands[0].Columns["IdConto"].ValueList = listaMovimenti.DisplayLayout.ValueLists["Conti"];
var listaSegni = new System.Collections.SortedList(2) { { "D", "Dare" }, { "A", "Avere" } };
listaMovimenti.DisplayLayout.ValueLists.Add(DataSourceHelper.GetValueList("Segno", listaSegni));
listaMovimenti.DisplayLayout.Bands[0].Columns["Segno"].ValueList = listaMovimenti.DisplayLayout.ValueLists["Segno"];
}
if (listaMovimenti.DisplayLayout != null && listaMovimenti.DisplayLayout.Bands[0].Summaries.Count == 0)
{
DataGridHelper.AddSummary(listaMovimenti.DisplayLayout.Bands[0], "ImportoDare", "c");
DataGridHelper.AddSummary(listaMovimenti.DisplayLayout.Bands[0], "ImportoAvere", "c");
}
listaMovimenti.PerformAction(UltraGridAction.ExitEditMode);
listaMovimenti.UpdateData();
if(_testata != null)
esercizi.Value = _testata.IdEsercizio;
if (getEsercizio() != null && getEsercizio().StatoEsercizio == StatoEsercizioEnum.Chiuso)
{
validationSummary1.Validators.Remove(customEsercizi);
descrizione.ReadOnly = true;
esercizi.ReadOnly = true;
causale.ReadOnly = true;
dataRegistrazione.ReadOnly = true;
foreach (var column in listaMovimenti.DisplayLayout.Bands[0].Columns)
column.CellActivation = Activation.ActivateOnly;
btnConferma.Enabled = false;
}
}
}
catch (Exception)
{
if (_testata != null)
_log.Error("Errore nel caricamento del movimento generico - " + Gipasoft.Library.Utility.GetMethodDescription() + " - testata:" + _testata.ID);
else
_log.Error("Errore nel caricamento del movimento generico - " + Gipasoft.Library.Utility.GetMethodDescription() + " - testata:NULL");
throw;
}
}
