public void LoadData(CondominioDTO condominio, EsercizioDTO esercizio)
{
try
{
_condominio = condominio;
_esercizio = esercizio;
_pianoRateale = getRateCondominiService().GetPianoRatealeByEsercizio(_esercizio.ID, true);
if (_pianoRateale != null)
pianoRatealeDettaglioDTOBindingSource.DataSource = _pianoRateale.Rate;
_rateDaAggiornare.Clear();
btnConferma.Visible = true;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante il caricamento dei dati del piano rateale - {0} - condominio:{1} - esercizio:{1}", ex, Gipasoft.Library.Utility.GetMethodDescription(), _condominio.ID, _esercizio.ID);
throw;
}
}
public void LoadData(CondominioDTO condominio, EsercizioDTO esercizio, TipoListaRate tipoLista, bool isAllowEmpty, bool rateAcconto, TipoAccorpamentoRateEnum tipo)
{
try
{
Clear();
_condominio = condominio;
_esercizio = esercizio;
_tipo = tipo;
_rateAcconto = rateAcconto;
if (condominio != null && esercizio != null && listaRateSoggetti != null)
{
loadConti();
_pianoRateale = getRateCondominiService().GetPianoRatealeByEsercizio(_esercizio.ID, false);
if (_pianoRateale != null && _pianoRateale.ID > 0)
_tipo = _pianoRateale.Tipo;
var form = new ExecuteLoadDataListAsync<RataSoggettoDTO>("Le rate sono in corso di caricamento ....." + Environment.NewLine + "Si prega di attendere.");
Func<List<RataSoggettoDTO>> loadDati = () => getRateCondominiService().GetByEsercizio(esercizio.ID);
form.LoadData(loadDati);
form.ShowDialog();
if (form.DataSourceObject == null)
{
ParentForm?.Close();
return;
}
_rateSoggetti = form.DataSourceObject;
form.Dispose();
var formSaldi = new ExecuteLoadDataObjectAsync<ResultSaldiCondomini>("I saldi dei condomini sono in corso di caricamento ....." + Environment.NewLine + "Si prega di attendere.");
Func<ResultSaldiCondomini> loadSaldi = () => getRateCondominiService().GetSaldiSoggetti(esercizio.ID, null, null, _tipo);
formSaldi.LoadData(loadSaldi);
formSaldi.ShowDialog();
if ((string.IsNullOrEmpty(formSaldi.DataSourceObject.Message) && formSaldi.DataSourceObject.Saldi != null) || !_isCreazione)
{
_saldiSoggetti = formSaldi.DataSourceObject.Saldi;
formSaldi.Dispose();
if (_rateSoggetti.Count > 0 || isAllowEmpty)
{
btnStampa.Visible = true;
btnConferma.Visible = true;
chkDataEmissione.Visible = true;
sceltaTipoLista.Visible = true;
listaRateSoggetti.Visible = true;
if (_isCreazione)
{
btnStampa.Visible = false;
nuovaDataPanel.Visible = false;
}
else
{
btnStampa.Visible = true;
nuovaDataPanel.Visible = true;
}
// Se è ancora a null carico la lista dei soggetti relativi all'esercizio.
if (_soggetti == null)
_soggetti = getRateCondominiService().GetPartecipanti(esercizio.ID, _tipo);
if (tipoLista == TipoListaRate.Pivot)
{
try
{
var resultMessage = getRateCondominiService().ConvertRateSoggettiToPivot(_rateSoggetti, _saldiSoggetti, null, _allowInvertiSegno, _pianoRateale, _isCreazione);
if (resultMessage.DataTable == null)
{
CommonMessages.DisplayWarning(string.Format("Si sono verificati i seguenti errori:{1}{0}{1}Si prega di riprovare", resultMessage.FatalMessage, Environment.NewLine));
ParentForm?.Close();
return;
}
listaRateSoggetti.DataSource = resultMessage.DataTable;
setGridLayout(tipoLista);
setRowsLayout();
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante il caricamento delle rate - DATA SOURCE - {0} - condominio:{1} - esercizio:{2}", ex, Utility.GetMethodDescription(), _condominio.ID, _esercizio.ID);
}
}
else if (tipoLista == TipoListaRate.Editabile)
{
listaRateSoggetti.DataSource = _rateSoggetti;
listaRateSoggetti.DisplayLayout.ValueLists.Clear();
listaRateSoggetti.DisplayLayout.ValueLists.Add(DataSourceHelper.GetValueList(_soggetti, "ID", "DisplayNominativo", "SoggettiCondominio"));
listaRateSoggetti.DisplayLayout.Bands[0].Columns["IdSoggettoCondominio"].ValueList = listaRateSoggetti.DisplayLayout.ValueLists["SoggettiCondominio"];
setGridLayout(tipoLista);
}
listaRateSoggetti.DisplayLayout.Bands[0].Summaries.Clear();
foreach (var column in listaRateSoggetti.DisplayLayout.Bands[0].Columns)
{
if (column.DataType == typeof (decimal))
DataGridHelper.AddSummary(listaRateSoggetti.DisplayLayout.Bands[0], column.Key, "c");
}
}
else
{
listaRateSoggetti.DataSource = new List<RataSoggettoDTO>();
CommonMessages.DisplayWarning("Non sono presenti rate.");
var parentForm = _parentForm as MainContabilita;
if (parentForm != null)
parentForm.ToClose = true;
else if (ParentForm != null)
((MainContabilita) ParentForm).ToClose = true;
}
listaRateSoggetti.PerformAction(UltraGridAction.FirstRowInBand);
loadPianoRateale();
}
else
{
CommonMessages.DisplayWarning($"Si sono verificati degli errori nel caricamento dei saldi:{Environment.NewLine}{formSaldi.DataSourceObject.Message}");
formSaldi.Dispose();
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante il caricamento dei dati del piano rateale - 1 - {0} - condominio:{1} - esercizio:{2}", ex, Utility.GetMethodDescription(), _condominio.ID, _esercizio.ID);
throw;
}
}
public PianoRatealeSoggetti GetPianoRatealeSoggetti(PianoRatealeDTO testataPianoRateale, int numeroRate, IList<RiepilogoRipartoDTO> riepilogoRiparto)
{
var pianoRateale = CreatePianoRateale(testataPianoRateale, numeroRate, riepilogoRiparto);
var saldi = new List<ImportoSaldoSoggettoDTO>();
if (riepilogoRiparto != null)
{
saldi.AddRange(riepilogoRiparto.Select(riepilogo => new ImportoSaldoSoggettoDTO
{
ID = 0, IdSoggettoCondominio = riepilogo.IdSoggettoCondominio, IdPersona = riepilogo.IdPersona, Importo = riepilogo.SaldoEsercizioPrecedente, Version = 0
}));
}
else
saldi = GetSaldiSoggetti(testataPianoRateale.IdEsercizio, null, null, testataPianoRateale.Tipo);
return new PianoRatealeSoggetti(pianoRateale, saldi, _rateCreate);
}
private int getSoggettoCondominioPrincipale(int idPersona, int idSoggetto, SoggettoCondominio soggettoPrincipale, IList<RiepilogoRipartoDTO> riepilogoRiparto, PianoRatealeDTO testataPianoRateale)
{
var idSoggettoPrincipale = idSoggetto;
switch (testataPianoRateale.Tipo)
{
case TipoAccorpamentoRateEnum.Nessuno:
idSoggettoPrincipale = idSoggetto;
break;
case TipoAccorpamentoRateEnum.Persona:
var foundItem = (from item in riepilogoRiparto
where item.IdPersona == idPersona && item.CodiceTipoUnita == 1
select item).FirstOrDefault() ?? (from item in riepilogoRiparto
where item.IdPersona == idPersona
select item).FirstOrDefault();
if (foundItem != null)
idSoggettoPrincipale = foundItem.IdSoggettoCondominio;
break;
case TipoAccorpamentoRateEnum.Personalizzato:
if (soggettoPrincipale != null)
idSoggettoPrincipale = soggettoPrincipale.ID;
else
{
SoggettoCondominio soggetto = _daoFactory.GetSoggettoCondominioDao().GetById(idSoggetto, false);
if (soggetto.SoggettoPrincipale != null)
idSoggettoPrincipale = soggetto.SoggettoPrincipale.ID;
else // se non sono presenti accorpamenti personalizzati non viene eseguito nessun accorpamento
goto case TipoAccorpamentoRateEnum.Nessuno;
}
break;
}
return idSoggettoPrincipale;
}
public ResultDataTable ConvertRateSoggettiToPivot(List<RataSoggettoDTO> rate, List<ImportoSaldoSoggettoDTO> saldi, IList<RiepilogoRipartoDTO> riepilogoRiparto, bool allowInvertiSegno, PianoRatealeDTO pianoRateale, bool showError)
{
try
{
IList<ImportiDTO> importi = null;
if (riepilogoRiparto == null && rate.Count > 0)
{
var result = GetServiceClient().GetImportiBilancioPreventivoCorrente(rate[0].IdEsercizio, pianoRateale.Tipo, GetUserInfo());
if (result.Importi != null || !showError)
importi = result.Importi;
else
{
return new ResultDataTable(null, result.FatalMessage);
}
}
var inversioneSaldi = GetServiceClient().GetInversioneSaldiCondomini(GetUserInfo());
var tb = new DataTable("RateSoggettiPivot");
var dateColumn = new List<DataColumn>();
try
{
tb.Columns.Add("IdSoggetto", typeof(int));
tb.Columns.Add("IdPersona", typeof(int));
tb.Columns.Add("Nominativo", typeof(string));
tb.Columns.Add("DescrizioneUnitaImmobiliare", typeof(string));
tb.Columns.Add("OrdineUnitaImmobiliare", typeof(int));
tb.Columns.Add("ImportoSaldoPrecedente", typeof(decimal));
tb.Columns.Add("ImportoPreventivo", typeof(decimal));
tb.Columns.Add("TotaleImporto", typeof(decimal));
tb.PrimaryKey = new[] { tb.Columns["IdSoggetto"] };
// ----------------------------------------------
// Aggiungo una colonna per ogni Data
// ----------------------------------------------
if (rate.Count > 0)
{
var idExampleSoggetto = rate[0].IdSoggettoCondominio;
var listaRateExample = rate.Where(rata => rata != null && rata.IdSoggettoCondominio == idExampleSoggetto).ToList();
dateColumn = new List<DataColumn>(listaRateExample.Count);
dateColumn = listaRateExample.Aggregate(dateColumn, (current, rataExample) => addColumnByData(rataExample.DataScadenza.GetValueOrDefault(), tb, current));
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel calcolo del pivot delle rate - CREAZIONE TABLE - {0} - pianoRateale:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), pianoRateale?.ID.ToString() ?? "<NULL>", Login.Instance.CurrentLogin().Azienda);
throw;
}
// ----------------------------------------------
// Riempio la tabella
// ----------------------------------------------
var dateVersamento = new Dictionary<string, DateTime>();
tb.ExtendedProperties.Add("DateVersamento", dateVersamento);
try
{
foreach (var rata in rate.OrderBy(rt => rt.OrdineUnitaImmobiliare).ThenBy(rt => rt.TipoSoggettoCondominio))
{
try
{
var row = tb.Rows.Find(rata.IdSoggettoCondominio);
if (row == null)
{
row = tb.NewRow();
row["IdSoggetto"] = rata.IdSoggettoCondominio;
row["IdPersona"] = rata.IdPersona;
row["Nominativo"] = rata.DescrizioneSoggettoCondominio;
row["DescrizioneUnitaImmobiliare"] = rata.DescrizioneUnitaImmobiliare;
row["OrdineUnitaImmobiliare"] = rata.OrdineUnitaImmobiliare;
tb.Rows.Add(row);
}
if (!tb.Columns.Contains("Data_" + rata.DataScadenza.GetValueOrDefault().ToShortDateString()))
dateColumn = addColumnByData(rata.DataScadenza.GetValueOrDefault(), tb, dateColumn);
decimal importo = 0;
if (row["Decimal_Data_" + rata.DataScadenza.GetValueOrDefault().ToShortDateString()] is decimal)
importo = (decimal)row["Decimal_Data_" + rata.DataScadenza.GetValueOrDefault().ToShortDateString()];
if (rata.Importo != null)
importo += rata.Importo.GetValueOrDefault();
if (importo != 0)
row["Decimal_Data_" + rata.DataScadenza.GetValueOrDefault().ToShortDateString()] = importo;
else
row["Decimal_Data_" + rata.DataScadenza.GetValueOrDefault().ToShortDateString()] = DBNull.Value;
if (rata.DataEmissione != null)
row["Data_" + rata.DataScadenza.GetValueOrDefault().ToShortDateString()] = rata.DataEmissione.GetValueOrDefault().ToShortDateString();
row["Stato_" + rata.DataScadenza.GetValueOrDefault().ToShortDateString()] = rata.StatoRata.ToString();
row["NumeroSolleciti_" + rata.DataScadenza.GetValueOrDefault().ToShortDateString()] = rata.NumeroSolleciti;
row["Alert_" + rata.DataScadenza.GetValueOrDefault().ToShortDateString()] = rata.Alert;
if (rata.ImportoPagato != null)
row["Versato_" + rata.DataScadenza.GetValueOrDefault().ToShortDateString()] = rata.ImportoPagato.GetValueOrDefault();
if (rata.DataUltimoVersamento != null)
{
var key = $"{rata.IdSoggettoCondominio}_{rata.DataScadenza.GetValueOrDefault().ToShortDateString()}";
var dataVersamento = DateTime.MinValue;
if (dateVersamento.ContainsKey(key))
{
dataVersamento = dateVersamento[key];
dateVersamento.Remove(key);
}
if (rata.DataUltimoVersamento.GetValueOrDefault() > dataVersamento)
dataVersamento = rata.DataUltimoVersamento.GetValueOrDefault();
dateVersamento.Add(key, dataVersamento);
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel calcolo del pivot delle rate - SINGOLA RATA - {0} - rata:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), rata.ID, Login.Instance.CurrentLogin().Azienda);
throw;
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel calcolo del pivot delle rate - CARICAMENTO RATE - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), Login.Instance.CurrentLogin().Azienda);
throw;
}
// ----------------------------------------------
// Calcolo i totali
// ----------------------------------------------
foreach (DataRow row in tb.Rows)
{
try
{
var totaleImporto = dateColumn.Where(dc => row["Stato_" + dc.ColumnName.Split('_')[2]].ToString() != StatoRataEnum.Richiamata.ToString() && row[dc] != null && row[dc] != DBNull.Value).Sum(dc => (decimal)row[dc]);
row["TotaleImporto"] = totaleImporto;
try
{
var row1 = row;
IEnumerable<ImportoSaldoSoggettoDTO> saldiDTO = new List<ImportoSaldoSoggettoDTO>();
if(saldi != null)
saldiDTO = pianoRateale.Tipo != TipoAccorpamentoRateEnum.Persona ? saldi.Where(item => item.IdSoggettoCondominio == (int)row1["IdSoggetto"]) : saldi.Where(item => item.IdPersona == (int)row1["IdPersona"]);
foreach (var saldoDTO in saldiDTO)
{
try
{
var importoPreventivo = 0m;
if (row["ImportoPreventivo"] != null && row["ImportoPreventivo"] != DBNull.Value)
importoPreventivo = (decimal)row["ImportoPreventivo"];
var importoSaldo = 0m;
if (row["ImportoSaldoPrecedente"] != null && row["ImportoSaldoPrecedente"] != DBNull.Value)
importoSaldo = (decimal)row["ImportoSaldoPrecedente"];
if (saldoDTO != null)
{
if (riepilogoRiparto != null)
row["ImportoPreventivo"] = importoPreventivo + riepilogoRiparto.Where(item => item.IdSoggettoCondominio == saldoDTO.IdSoggettoCondominio).Sum(item => item.Importo);
else if (importi != null)
row["ImportoPreventivo"] = importoPreventivo + importi.Where(item => item.Id == saldoDTO.IdSoggettoCondominio).Sum(item => item.Importo);
var saldo = saldoDTO.Importo;
if (allowInvertiSegno && inversioneSaldi)
saldo = saldo * -1;
row["ImportoSaldoPrecedente"] = importoSaldo + saldo;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel calcolo del pivot delle rate - TOTALI SINGOLO SALDO - {0} - saldo:{1} - rata:{2} - azienda:{3}", ex, Utility.GetMethodDescription(), saldoDTO.ID, row["IdSoggetto"], Login.Instance.CurrentLogin().Azienda);
throw;
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel calcolo del pivot delle rate - TOTALI CARICAMENTO SALDI - {0} - rata:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), row["IdSoggetto"], Login.Instance.CurrentLogin().Azienda);
throw;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel calcolo del pivot delle rate - TOTALI SINGOLA ROW - {0} - rata:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), row["IdSoggetto"], Login.Instance.CurrentLogin().Azienda);
throw;
}
}
// -----------------------------------------------------------------------------------
// Se calcolo per soggetto rielaboro le righe in modo da averne una sola per soggetto
// -----------------------------------------------------------------------------------
if (pianoRateale != null && pianoRateale.Tipo == TipoAccorpamentoRateEnum.Persona)
{
try
{
var personePresenti = new Dictionary<int, DataRow>();
var rowsToDelete = new Dictionary<int, DataRow>();
foreach (DataRow row in tb.Rows)
{
try
{
var idPersona = (int)row["IdPersona"];
if (personePresenti.ContainsKey(idPersona))
{
if (isImportiNull(personePresenti[idPersona]))
{
if (!rowsToDelete.ContainsKey(idPersona))
rowsToDelete.Add(idPersona, personePresenti[idPersona]);
}
else if (isImportiNull(row))
{
if (!rowsToDelete.ContainsKey(idPersona))
rowsToDelete.Add(idPersona, row);
}
}
else
personePresenti.Add(idPersona, row);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel calcolo del pivot delle rate - RIELABORAZIONE RIGHE PER SOGGETTO - SINGOLO SOGGETTO - {0} - persona:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), row["IdPersona"], Login.Instance.CurrentLogin().Azienda);
throw;
}
}
foreach (var kvp in rowsToDelete)
{
if (tb.Rows.Contains(kvp.Value["IdSoggetto"]))
tb.Rows.Remove(kvp.Value);
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel calcolo del pivot delle rate - RIELABORAZIONE RIGHE PER SOGGETTO - {0} - pianoRateale:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), pianoRateale.ID, Login.Instance.CurrentLogin().Azienda);
throw;
}
}
CloseService();
var columnCaption = new Dictionary<string, string>();
try
{
foreach (var rataSoggettoDTO in rate)
{
try
{
var key = $"Decimal_Data_{rataSoggettoDTO.DataScadenza.GetValueOrDefault().ToShortDateString()}";
if (rataSoggettoDTO.VersamentiDopoChiusura && !columnCaption.ContainsKey(key))
columnCaption.Add(key, "Versamenti dopo chiusura");
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel calcolo del pivot delle rate - CAPTION VERSAMENTI DOPO CHIUSURA - SINGOLA RATA - {0} - rata:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), rataSoggettoDTO.ID, Login.Instance.CurrentLogin().Azienda);
throw;
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel calcolo del pivot delle rate - CAPTION VERSAMENTI DOPO CHIUSURA - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), Login.Instance.CurrentLogin().Azienda);
throw;
}
tb.ExtendedProperties.Add("ColumnCaption", columnCaption);
return new ResultDataTable(tb, null);
}
catch (Exception ex)
{
var idEsercizio = "rate a null";
if (rate != null && rate.Count > 0 && rate[0] != null)
idEsercizio = rate[0].IdEsercizio.ToString();
else if (rate != null && rate.Count == 0)
idEsercizio = "rate a 0";
_log.ErrorFormat("Errore nel caricamento del piano rateale a tabella - {0} - esercizio:{1} - azienda:{2} - allowInvertiSegno:{2}", ex, Utility.GetMethodDescription(), idEsercizio, Login.Instance.CurrentLogin().Azienda, allowInvertiSegno);
throw;
}
}
public PianoRatealeDTO CreatePianoRateale(PianoRatealeDTO testataPianoRateale, int numeroRate, IList<RiepilogoRipartoDTO> riepilogoRiparto)
{
var esercizio =_daoFactory.GetEsercizioDao().GetById(testataPianoRateale.IdEsercizio, false);
var impostazioni = _daoFactory.GetImpostazioniAziendaDao().GetByAzienda(esercizio.CondominioRiferimento.Azienda.ID);
var arrotondamenti = new Dictionary<int, decimal>();
var rendiconto = _daoFactory.GetRendicontoAnnualeDao().Find(testataPianoRateale.IdRendiconto.GetValueOrDefault(), false) ??
_bilancioService.GetPreventivoCorrente(testataPianoRateale.IdEsercizio);
testataPianoRateale.IdRendiconto = rendiconto.ID;
// Se non è stato definito nessun arrotondamento, arrotondo comunque a .01
var arrotondamentoImporti = 0.01m;
if (testataPianoRateale.ArrontondamentoImporti > 0)
arrotondamentoImporti = testataPianoRateale.ArrontondamentoImporti;
// --------------------------------------------------------------------
// Leggo eventuali rate di acconto presenti
// --------------------------------------------------------------------
var pianoAcconto = _daoFactory.GetPianoRatealeDao().GetByEsercizio(esercizio);
IList<PianoRatealeDettaglio> listaDettaglioPianoAcconto = null;
if (pianoAcconto != null)
{
testataPianoRateale.ID = pianoAcconto.ID;
listaDettaglioPianoAcconto = (pianoAcconto.Rate.Where(item => item.IsAcconto)).ToList();
}
// --------------------------------------------------------------------
// Creazione Piano Rateale
// --------------------------------------------------------------------
var startIndex = 1;
var numeroRateAcconto = 0;
DateTime? dataIniziale = null;
if (listaDettaglioPianoAcconto != null)
{
startIndex = listaDettaglioPianoAcconto.Count + 1;
numeroRateAcconto = listaDettaglioPianoAcconto.Count(item => item.IsAcconto);
var ultimaRata = listaDettaglioPianoAcconto.OrderBy(item => item.DataScadenza).LastOrDefault();
if (ultimaRata?.DataScadenza != null)
dataIniziale = ultimaRata.DataScadenza.GetValueOrDefault();
}
numeroRate += numeroRateAcconto;
if (testataPianoRateale.Rate == null || testataPianoRateale.Rate.Count != numeroRate)
{
testataPianoRateale.Rate = new List<PianoRatealeDettaglioDTO>();
// Calcolo la distanza proposto, in numero di mesi, tra una rata e quella successiva
var denominatore = numeroRate - startIndex + 1;
var numeroMesi = DivideRoundingUp(numeroRate, 12)*12;
var monthGap = numeroMesi/12;
if (dataIniziale == null && esercizio.DataApertura != null)
dataIniziale = esercizio.DataApertura.GetValueOrDefault();
if (dataIniziale == null)
dataIniziale = new DateTime(DateTime.Today.Year, 2, 1);
if(esercizio.DataChiusura != null && esercizio.Gestione == GestioneEsercizioEnum.Ordinario && numeroMesi <= 12)
numeroMesi = Convert.ToInt32(Math.Round((esercizio.DataChiusura.GetValueOrDefault() - dataIniziale.GetValueOrDefault()).TotalDays / 30));
if(denominatore > 0)
monthGap = numeroMesi / denominatore;
var scadenza = new DateTime(dataIniziale.GetValueOrDefault().AddMonths(1).Year, dataIniziale.GetValueOrDefault().AddMonths(1).Month, 1);
var rataIndex = 0;
for (var i = startIndex; i <= numeroRate; i++)
{
var dettaglio = new PianoRatealeDettaglioDTO {DataScadenza = scadenza, Progressivo = i};
if (i == startIndex)
dettaglio.PercentualeRipartoSaldo = 1m;
dettaglio.PercentualeRiparto = Math.Round(1m / Convert.ToDecimal(numeroRate - startIndex + 1), 4);
rataIndex++;
dettaglio.Descrizione = $"Rata n. {rataIndex} del {scadenza:d}";
scadenza = scadenza.AddMonths(monthGap);
testataPianoRateale.Rate.Add(dettaglio);
}
}
// --------------------------------------------------------------------
// Calcolo importi piano rateale
// --------------------------------------------------------------------
if (riepilogoRiparto == null)
riepilogoRiparto = GetRiepilogoRiparto(testataPianoRateale.IdEsercizio, null, null, testataPianoRateale.Tipo);
// Se arriva dal client cambio segno agli importi.
else if (impostazioni.InversioneSaldiRate)
{
foreach (var item in riepilogoRiparto)
item.Importo = item.Importo * -1;
}
var importiNegativi = new Dictionary<int, decimal>();
var importiMinimi = new Dictionary<int, decimal>();
_rateCreate = new List<RataSoggettoDTO>();
foreach (var dettaglio in testataPianoRateale.Rate)
{
if (dettaglio.ID == 0)
{
dettaglio.Importo = 0;
// ===========================================================================
// Creazione delle rate
// ===========================================================================
foreach (var itemRiepilogo in riepilogoRiparto)
{
var idSoggettoCondominio = getSoggettoCondominioPrincipale(itemRiepilogo.IdPersona, itemRiepilogo.IdSoggettoCondominio, null, riepilogoRiparto, testataPianoRateale);
RataSoggettoDTO rata;
if (!_rateCreate.Any(item => item.IdSoggettoCondominio == idSoggettoCondominio && item.DataScadenza == dettaglio.DataScadenza))
{
rata = new RataSoggettoDTO
{
IdEsercizio = esercizio.ID,
DescrizioneEsercizio = esercizio.DisplayName,
DataScadenza = dettaglio.DataScadenza,
Progressivo = dettaglio.Progressivo,
IdPianoDettaglioRatealeRiferimento = dettaglio.ID,
IdSoggettoCondominio = idSoggettoCondominio,
DisplayName = itemRiepilogo.Nominativo,
DescrizioneUnitaImmobiliare = itemRiepilogo.DescrizioneUnitaImmobiliare,
IdPersona = itemRiepilogo.IdPersona,
DescrizioneSoggettoCondominio = itemRiepilogo.Nominativo,
OrdineUnitaImmobiliare = itemRiepilogo.OrdineUnitaImmobiliare,
TipoSoggettoCondominio = itemRiepilogo.TipoSoggettoCondominio,
Subalterno = itemRiepilogo.Subalterno
};
_rateCreate.Add(rata);
}
else
{
var dettaglio2 = dettaglio;
rata = (from item in _rateCreate
where idSoggettoCondominio == item.IdSoggettoCondominio && item.DataScadenza == dettaglio2.DataScadenza
select item).SingleOrDefault();
}
// ===========================================================================
// Calcolo Importo
// ===========================================================================
// Importo preventivo
// ------------------------------
var importoPreventivo = getImportoNettoAcconti(itemRiepilogo, listaDettaglioPianoAcconto) * dettaglio.PercentualeRiparto.GetValueOrDefault();
// Importo saldo
// ------------------------------
var importoSaldo = itemRiepilogo.SaldoEsercizioPrecedente * dettaglio.PercentualeRipartoSaldo.GetValueOrDefault();
if (impostazioni.InversioneSaldiRate)
importoSaldo = importoSaldo*-1;
// Rata totale
// ------------------------------
if (rata != null)
{
var importoRata = rata.Importo.GetValueOrDefault() + importoSaldo + importoPreventivo;
rata.Importo = importoRata;
}
}
// ===========================================================================
// Rilettura delle rate la gestione degli importi minimi
// ===========================================================================
var dettaglio1 = dettaglio;
var ratePerDettaglio = from item in _rateCreate
where dettaglio1 != null && item.DataScadenza == dettaglio1.DataScadenza
select item;
foreach (var rata in ratePerDettaglio)
{
var importoRata = rata.Importo.GetValueOrDefault();
// Se presenti importi minimi devo aggiungerli alla rata
if (importiNegativi.ContainsKey(rata.IdSoggettoCondominio))
{
var importoNegativo = importiNegativi[rata.IdSoggettoCondominio];
importoRata += importoNegativo;
importiNegativi.Remove(rata.IdSoggettoCondominio);
}
// Creo rata solo se importo è maggiore dell'importo minimo, se è inferiore al minimo lo memorizzo per utilizzarlo nelle rate successive
if (importoRata > testataPianoRateale.ImportoMinimo)
{
rata.Importo = Convert.ToDecimal(Arrotonda.Round(Convert.ToDouble(importoRata), Convert.ToDouble(arrotondamentoImporti)));
// memorizzo eventuali arrotondamenti
decimal importoArrontondamento = 0;
if (arrotondamenti.ContainsKey(rata.IdSoggettoCondominio))
{
importoArrontondamento = arrotondamenti[rata.IdSoggettoCondominio];
arrotondamenti.Remove(rata.IdSoggettoCondominio);
}
importoArrontondamento += importoRata - rata.Importo.GetValueOrDefault();
arrotondamenti.Add(rata.IdSoggettoCondominio, importoArrontondamento);
}
else
{
rata.Importo = 0;
if (importoRata < 0)
{
decimal importo = 0;
if (importiNegativi.ContainsKey(rata.IdSoggettoCondominio))
{
importo = importiNegativi[rata.IdSoggettoCondominio];
importiNegativi.Remove(rata.IdSoggettoCondominio);
}
importo += importoRata;
importiNegativi.Add(rata.IdSoggettoCondominio, importo);
}
else
{
decimal importo = 0;
if (importiMinimi.ContainsKey(rata.IdSoggettoCondominio))
{
importo = importiMinimi[rata.IdSoggettoCondominio];
importiMinimi.Remove(rata.IdSoggettoCondominio);
}
importo += importoRata;
importiMinimi.Add(rata.IdSoggettoCondominio, importo);
}
}
// -------------------------------
// Aggiorno dettaglio rata
// -------------------------------
dettaglio.Importo += rata.Importo.GetValueOrDefault();
}
}
}
// ---------------------------------------------------------------------------------
// Aggiungo le rate di acconto
// ---------------------------------------------------------------------------------
int index = 0;
if (listaDettaglioPianoAcconto != null)
{
foreach (PianoRatealeDettaglio dettaglioPianoAcconto in listaDettaglioPianoAcconto)
{
if (testataPianoRateale.Rate.All(item => item.ID != dettaglioPianoAcconto.ID))
{
index++;
var dettaglioAccontoDto = new PianoRatealeDettaglioDTO
{
ID = dettaglioPianoAcconto.ID,
IsAcconto = true,
DataScadenza = dettaglioPianoAcconto.DataScadenza.GetValueOrDefault(),
Descrizione = dettaglioPianoAcconto.Descrizione,
IsDeleteAllow = false,
IdPianoRatealeRiferimento = dettaglioPianoAcconto.PianoRatealeRiferimento.ID,
StatoRata = dettaglioPianoAcconto.Stato,
Version = dettaglioPianoAcconto.Version,
Progressivo = index,
Importo = dettaglioPianoAcconto.RateSoggetti.Where(item => !item.DaRichiamare && item.Stato != StatoRataEnum.Richiamata).Sum(item => item.Importo)
};
testataPianoRateale.Rate.Add(dettaglioAccontoDto);
}
foreach (RataSoggetto rataAcconto in dettaglioPianoAcconto.RateSoggetti.Where(item => !item.DaRichiamare && item.Stato != StatoRataEnum.Richiamata))
{
var rataAccontoDto = new RataSoggettoDTO
{
ID = rataAcconto.ID,
DataScadenza = rataAcconto.DataScadenza,
DescrizioneSoggettoCondominio = rataAcconto.Soggetto.DisplayName,
DescrizioneUnitaImmobiliare = rataAcconto.Soggetto.UnitaImmobiliare.Descrizione,
IdEsercizio = rataAcconto.PianoRatealeDettaglio.PianoRatealeRiferimento.Esercizio.ID,
DescrizioneEsercizio = rataAcconto.PianoRatealeDettaglio.PianoRatealeRiferimento.Esercizio.DisplayName,
IdPianoDettaglioRatealeRiferimento = rataAcconto.PianoRatealeDettaglio.ID,
IdUnitaImmobiliare = rataAcconto.Soggetto.UnitaImmobiliare.ID,
Subalterno = rataAcconto.Soggetto.UnitaImmobiliare.Subalterno,
Importo = rataAcconto.Importo,
ImportoPagato = rataAcconto.GetImportoVersato(null),
OrdineUnitaImmobiliare = rataAcconto.Soggetto.UnitaImmobiliare.Ordine.GetValueOrDefault(),
StatoRata = rataAcconto.Stato,
TipoSoggettoCondominio = rataAcconto.Soggetto.Tipo,
Version = rataAcconto.Version,
IsDeleteAllow = false,
Progressivo = rataAcconto.Progressivo,
IdPersona = rataAcconto.Soggetto.Persona.ID,
IdSoggettoCondominio = getSoggettoCondominioPrincipale(rataAcconto.Soggetto.Persona.ID, rataAcconto.Soggetto.ID, rataAcconto.Soggetto.SoggettoPrincipale, riepilogoRiparto, testataPianoRateale)
};
_rateCreate.Insert(0, rataAccontoDto);
}
}
}
testataPianoRateale.Rate = testataPianoRateale.Rate.OrderBy(item => item.Progressivo).ToList();
// ---------------------------------------------------------------------------------
// Se ho ancora importi minimi li addebito alla prima rata ancora a 0
// Può capitare, ad esempio, se abbiamo definito una rata che comprende il solo saldo
// ---------------------------------------------------------------------------------
foreach (var kvp in importiMinimi)
{
var kvp1 = kvp;
var ratePerImporto = from item in _rateCreate
where item.IdSoggettoCondominio == kvp1.Key
orderby item.Importo, item.Progressivo
select item;
if (ratePerImporto.Any())
{
var importoArrotondato = Convert.ToDecimal(Arrotonda.Round(Convert.ToDouble(kvp.Value), Convert.ToDouble(arrotondamentoImporti)));
var rata = ratePerImporto.FirstOrDefault();
if(rata != null)
rata.Importo += importoArrotondato;
// Aggiungo il residuo alla lista degli arrontondamenti
if (kvp.Value != importoArrotondato)
{
if (arrotondamenti.ContainsKey(kvp.Key))
arrotondamenti[kvp.Key] += (kvp.Value - importoArrotondato);
else
arrotondamenti.Add(kvp.Key, kvp.Value - importoArrotondato);
}
}
else
{
_log.WarnFormat("Non trovata nessun rata a cui addebitare l'importo minimo di {0} - {1} - id:{2}", kvp.Value.ToString("c"), Utility.GetMethodDescription(), kvp.Key);
}
}
// ---------------------------------------------------------------------------------
// Calcolo residui - Solo se presente rata di arrotondamento
// ---------------------------------------------------------------------------------
if (testataPianoRateale.IdRataArrotondamenti > 0)
{
decimal residuoTotale = 0;
foreach (RiepilogoRipartoDTO itemRiepilogo in riepilogoRiparto)
{
if (arrotondamenti.ContainsKey(itemRiepilogo.IdSoggettoCondominio))
{
decimal importoResiduo = arrotondamenti[itemRiepilogo.IdSoggettoCondominio];
var riepilogo = itemRiepilogo;
RataSoggettoDTO rataResiduo = (from rata in _rateCreate
where rata.Progressivo == testataPianoRateale.IdRataArrotondamenti && rata.IdSoggettoCondominio == riepilogo.IdSoggettoCondominio && rata.Importo > 0
select rata).SingleOrDefault();
if (rataResiduo != null)
{
rataResiduo.Importo += importoResiduo;
residuoTotale += importoResiduo;
arrotondamenti.Remove(itemRiepilogo.IdSoggettoCondominio);
}
}
}
// ---------------------------------------------------------------------------------
// Se ho ancora residui di arrotondamento li addebito alla prima rata disponibile > 0
// ---------------------------------------------------------------------------------
foreach (var kvp in arrotondamenti)
{
var importoResiduo = kvp.Value;
var kvp1 = kvp;
var rateResiduo = from item in _rateCreate
where item.IdSoggettoCondominio == kvp1.Key && item.Importo > 0
orderby item.Progressivo
select item;
if (rateResiduo.Any())
{
foreach (var rataResiduo in rateResiduo)
{
if (rataResiduo.Importo + importoResiduo >= 0)
{
rataResiduo.Importo += importoResiduo;
residuoTotale += importoResiduo;
break;
}
}
}
}
// ---------------------------------------------------------------------------------
// Aggiorno col residuo la rata di dettaglio
// ---------------------------------------------------------------------------------
var dettaglioResiduo = (from dettaglio in testataPianoRateale.Rate
where dettaglio.Progressivo == testataPianoRateale.IdRataArrotondamenti
select dettaglio).SingleOrDefault();
if (dettaglioResiduo != null)
dettaglioResiduo.Importo += residuoTotale;
}
// ---------------------------------------------------------------------------------
// Se ho ancora importi negativi verifico se riesco a sottrarli da qualche rata:
// Può capitare, ad esempio, se abbiamo definito una rata che comprende il solo saldo
// ---------------------------------------------------------------------------------
var importiNegativiDaSottrarre = importiNegativi.Select(kvp => new ImportiDTO
{
Id = kvp.Key, Importo = kvp.Value*-1
}).ToList();
foreach (var importoDto in importiNegativiDaSottrarre)
{
var dto = importoDto;
var rateSoggetto = from item in _rateCreate
where item.IdSoggettoCondominio == dto.Id
select item;
foreach (var rata in rateSoggetto)
{
// Solo per le rate nuove
if (rata.ID == 0)
{
decimal importoOriginale = rata.Importo.GetValueOrDefault();
if (rata.Importo >= importoDto.Importo)
rata.Importo -= importoDto.Importo;
else if (rata.Importo < importoDto.Importo)
rata.Importo = 0;
importoDto.Importo -= importoOriginale - rata.Importo.GetValueOrDefault();
}
}
}
return testataPianoRateale;
}
public ResultMessagesOfPianoRatealeDTOn0Zc5SOa CreatePianoRateale(PianoRatealeDTO pianoRateale, int numeroRate, List<RiepilogoRipartoDTO> riepilogo)
{
var result = GetServiceClient().CreatePianoRateale(pianoRateale, numeroRate, riepilogo, GetUserInfo());
CloseService();
return result;
}
public PianoRatealeSoggetti GetPianoRatealeSoggetti(PianoRatealeDTO pianoRateale, int numeroRate, IList<RiepilogoRipartoDTO> riepilogoRiparto, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var rateService = windsorRep.GetContainer(userinfo.Azienda).Resolve<IRateService>();
var item = rateService.GetPianoRatealeSoggetti(pianoRateale, numeroRate, riepilogoRiparto);
windsorRep.Commit();
return item;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella esecuzione della funzione - {0} - pianoRateale:{1} - esercizio:{2} - numeroRate:{3} - azienda:{4}", ex, Utility.GetMethodDescription(), pianoRateale.ID, pianoRateale.IdEsercizio, numeroRate, userinfo.Azienda);
windsorRep.Rollback();
throw;
}
}
private PianoRatealeDTO setDto(PianoRateale item, bool dettaglioRate)
{
var dto = new PianoRatealeDTO
{
Version = item.Version,
ArrontondamentoImporti = item.ArrotondamentoImporti.GetValueOrDefault(),
ID = item.ID,
IdEsercizio = item.Esercizio.ID,
Tipo = item.Tipo
};
if (item.RataArrotondamenti != null)
{
try
{
dto.IdRataArrotondamenti = item.RataArrotondamenti.ID;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella lettura della rata di arrotondamento - {0} - pianoRateale:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), item.ID, _info.Azienda);
}
}
if(item.Rendiconto != null)
dto.IdRendiconto = item.Rendiconto.ID;
// Dettaglio Rate
dto.Rate = new List<PianoRatealeDettaglioDTO>(item.Rate.Count);
if (dettaglioRate)
{
foreach (var dettaglio in item.Rate.OrderBy(itemDettaglio => itemDettaglio.Progressivo))
{
var dettaglioDTO = new PianoRatealeDettaglioDTO
{
DataScadenza = dettaglio.DataScadenza.GetValueOrDefault(),
Descrizione = dettaglio.Descrizione,
DisplayName = dettaglio.Descrizione,
ID = dettaglio.ID,
IdPianoRatealeRiferimento = item.ID,
Importo = dettaglio.RateSoggetti.Sum(itemRata => itemRata.Importo),
PercentualeRiparto = dettaglio.PercentualeRiparto,
PercentualeRipartoSaldo = dettaglio.PercentualeSaldoEsercizioPrecedente,
Progressivo = dettaglio.Progressivo,
IsAcconto = dettaglio.IsAcconto,
StatoRata = dettaglio.Stato
};
dto.Rate.Add(dettaglioDTO);
}
}
return dto;
}
public AuthorizationMessages IsAllowUpdateDataPianoRateale(PianoRatealeDTO pianoRateale, int? idDettaglio, DateTime data)
{
if (pianoRateale != null)
{
var result = GetServiceClient().IsAllowUpdateDataPianoRateale(idDettaglio, pianoRateale.ID, data, GetUserInfo());
CloseService();
return result;
}
return new AuthorizationMessages();
}
private void load()
{
_loaded = false;
// ----------------------------------------------------------------------
// Caricamento primo TAB
// ----------------------------------------------------------------------
var form = new ExecuteLoadDataObjectAsync<PianoRatealeDTO>("Il piano rateale è in corso di caricamento ....." + Environment.NewLine + "Si prega di attendere.");
Func<PianoRatealeDTO> loadDati = () => getRateCondominiService().GetPianoRatealeByEsercizio(_esercizio.ID, true);
form.LoadData(loadDati);
form.ShowDialog();
_pianoRateale = form.DataSourceObject;
form.Dispose();
if (_pianoRateale != null)
{
listaRate.InitializeRow += listaRate_InitializeRow;
listaRate.CellChange += listaRateCellChange;
pianoRatealeDettaglioDTOBindingSource.DataSource = _pianoRateale.Rate;
var formSoggetti = new ExecuteLoadDataListAsync<RiepilogoRataSoggettoDTO>("E' in corso la ricerca dei condomini ....." + Environment.NewLine + "Si prega di attendere.");
Func<List<RiepilogoRataSoggettoDTO>> loadDatiSoggetti = () => getRateCondominiService().GetRiepilogoRataSoggettoByEsercizio(_esercizio.ID, getRateRichiamate());
formSoggetti.LoadData(loadDatiSoggetti);
formSoggetti.ShowDialog();
riepilogoRataSoggettoDTOBindingSource.DataSource = formSoggetti.DataSourceObject;
formSoggetti.Dispose();
var testoCausale = getRateCondominiService().GetCausale(_esercizio);
if (testoCausale.Length > 94)
testoCausale = testoCausale.Substring(0, 94);
causale.Text = testoCausale;
intestazoneAzienda.Text = getRateCondominiService().GetIntestazioneMAVAzienda();
mainTab.Tabs["parametri"].Enabled = true;
mainTab.Tabs["riepilogoRate"].Enabled = false;
mainTab.Tabs["emissione"].Enabled = false;
mainTab.SelectedTab = mainTab.Tabs["parametri"];
_avanzamento = AvanzamentoWizard.SceltaParametri;
listaSoggetti.UpdateData();
listaSoggetti.PerformAction(UltraGridAction.ExitEditMode);
listaSoggetti.BeforeHeaderCheckStateChanged += listaSoggetti_BeforeHeaderCheckStateChanged;
listaSoggetti.AfterHeaderCheckStateChanged += listaSoggetti_AfterHeaderCheckStateChanged;
}
else
{
CommonMessages.DisplayWarning("Non è stato definito alcun piano rateale.");
}
}
private void setPianoRatealeDataSource(bool restoreRataResiduo, bool getRate)
{
// Reimposto il data source
int? rataResiduo = null;
if (restoreRataResiduo)
{
if (assegnazioneResiduo.Value != null && (int)assegnazioneResiduo.Value > -1)
rataResiduo = (int)assegnazioneResiduo.Value;
}
assegnazioneResiduo.ValueChanged -=assegnazioneResiduoValueChanged;
assegnazioneResiduo.DataSource = null;
if (!getRate)
{
var resultPianoRateale = getRateCondominiService().CreatePianoRateale(new PianoRatealeDTO { IdEsercizio = _esercizio.ID, ArrontondamentoImporti = (decimal)arrotondamentoImporti.Value, ImportoMinimo = importoMinimo.Value, IdRendiconto = getIdRendiconto(), IdRataArrotondamenti = rataResiduo, Rate = (List<PianoRatealeDettaglioDTO>)pianoRatealeDettaglioDTOBindingSource.DataSource, Tipo = _tipo }, (int)numeroRate.Value, (List<RiepilogoRipartoDTO>)riepilogoRipartoBindingSource.DataSource);
if (resultPianoRateale.Result != null)
{
_pianoRateale = resultPianoRateale.Result;
}
else
{
if (!string.IsNullOrEmpty(resultPianoRateale.FatalMessage))
CommonMessages.DisplayWarning(string.Format("Si sono verificati dei problemi nella creazione del piano rateale:{0}{1}", Environment.NewLine, resultPianoRateale.FatalMessage));
var mainContabilita = (MainContabilita)ParentForm;
if (mainContabilita != null)
mainContabilita.ToClose = true;
}
}
else
{
var pianoRatealeSoggetti = getRateCondominiService().GetPianoRatealeSoggetti(new PianoRatealeDTO { IdEsercizio = _esercizio.ID, ArrontondamentoImporti = (decimal)arrotondamentoImporti.Value, ImportoMinimo = importoMinimo.Value, IdRendiconto = getIdRendiconto(), IdRataArrotondamenti = rataResiduo, Rate = (List<PianoRatealeDettaglioDTO>)pianoRatealeDettaglioDTOBindingSource.DataSource, Tipo = _tipo }, (int)numeroRate.Value, (List<RiepilogoRipartoDTO>)riepilogoRipartoBindingSource.DataSource);
_pianoRateale = pianoRatealeSoggetti.PianoRateale;
_rateSoggetti = pianoRatealeSoggetti.RateSoggetti;
_saldiSoggetti = pianoRatealeSoggetti.SaldiSoggetti;
}
pianoRatealeDettaglioDTOBindingSource.DataSource = _pianoRateale.Rate;
loadRataArrotondamento();
rendicontoPreventivo.ValueChanged -= rendicontoPreventivoValueChanged;
rendicontoPreventivo.Value = _pianoRateale.IdRendiconto;
rendicontoPreventivo.ValueChanged += rendicontoPreventivoValueChanged;
loadRataArrotondamento();
assegnazioneResiduo.Value = rataResiduo;
assegnazioneResiduo.ValueChanged += assegnazioneResiduoValueChanged;
listaRate.DisplayLayout.Bands[0].Columns["PercentualeRiparto"].EditorComponent = percentageDataFilter;
listaRate.DisplayLayout.Bands[0].Columns["PercentualeRipartoSaldo"].EditorComponent = percentageDataFilter;
}
private void load()
{
Visible = false;
// --------------------------------------------------------
// Controllo se è ammessa creazione del riparto
// --------------------------------------------------------
var importo = getBilancioService().GetImportoPreventivo(_esercizio.ID);
if (importo != null)
{
var messaggio = getRateCondominiService().IsAllowNewPianoRateale(_esercizio.ID);
if (string.IsNullOrEmpty(messaggio.FatalMessage))
{
var result = DialogResult.Yes;
if(!string.IsNullOrEmpty(messaggio.WarnMessage))
result = CommonMessages.DisplayConfirm("ATTENZIONE: " + messaggio.WarnMessage + Environment.NewLine + "Vuoi confermare l'operazione?");
if(result == DialogResult.Yes)
{
importoDaRipartire.Text = importo.Value.ToString("c");
Visible = true;
hideShowControls(true);
numeroRate.ValueChanged -= numeroRateValueChanged;
arrotondamentoImporti.ValueChanged -= arrotondamentoImportiValueChanged;
numeroRate.Value = 4;
arrotondamentoImporti.SelectedIndex = 0;
numeroRate.ValueChanged += numeroRateValueChanged;
arrotondamentoImporti.ValueChanged += arrotondamentoImportiValueChanged;
// --------------------------------------------------------
// Caricamento primo tab del wizard
// --------------------------------------------------------
rendicontoBindingSource.DataSource = getBilancioService().GetRendicontiByEsercizio(_esercizio.ID, TipoRendiconto.Preventivo);
if (rendicontoBindingSource.Count == 1)
{
rendicontoPreventivo.ValueChanged -=rendicontoPreventivoValueChanged;
rendicontoPreventivo.SelectedIndex = 0;
rendicontoPreventivo.ValueChanged += rendicontoPreventivoValueChanged;
}
var form = new ExecuteLoadDataObjectAsync<ResultRiepilogoRipartoDTO>();
Func<ResultRiepilogoRipartoDTO> loadDati = () => getRateCondominiService().GetRiepilogoRiparto(_esercizio.ID, null, null, getIdRendiconto(), _tipo);
form.LoadData(loadDati);
form.ShowDialog();
if (form.DataSourceObject.RiepilogoRiparto != null)
{
riepilogoRipartoBindingSource.DataSource = form.DataSourceObject.RiepilogoRiparto;
form.Dispose();
hideShowControls(false);
//riepilogoRipartoBindingSource.DataSource = getRateCondominiService().GetRiepilogoRiparto(_esercizio.ID, null, null, getIdRendiconto());
if (listaRiepilogoRiparto.DisplayLayout.Bands[0].Summaries.Count == 0)
{
DataGridHelper.AddSummary(listaRiepilogoRiparto.DisplayLayout.Bands[0], "SaldoEsercizioPrecedente", "c");
DataGridHelper.AddSummary(listaRiepilogoRiparto.DisplayLayout.Bands[0], "TotaleADebito", "c");
DataGridHelper.AddSummary(listaRiepilogoRiparto.DisplayLayout.Bands[0], "Importo", "c");
}
// --------------------------------------------------------
// Caricamento secondo tab del wizard
// --------------------------------------------------------
int? rataAssegnazioneResiduo = null;
if (assegnazioneResiduo.Value != null && (int)assegnazioneResiduo.Value > -1)
rataAssegnazioneResiduo = (int)assegnazioneResiduo.Value;
var resultPianoRateale = getRateCondominiService().CreatePianoRateale(new PianoRatealeDTO { IdEsercizio = _esercizio.ID, ArrontondamentoImporti = (decimal)arrotondamentoImporti.Value, IdRendiconto = getIdRendiconto(), IdRataArrotondamenti = rataAssegnazioneResiduo, Tipo = _tipo }, (int)numeroRate.Value, (List<RiepilogoRipartoDTO>)riepilogoRipartoBindingSource.DataSource);
if (resultPianoRateale.Result != null)
{
_pianoRateale = resultPianoRateale.Result;
pianoRatealeDettaglioDTOBindingSource.DataSource = _pianoRateale.Rate;
loadRataArrotondamento();
rendicontoPreventivo.ValueChanged -= rendicontoPreventivoValueChanged;
rendicontoPreventivo.Value = _pianoRateale.IdRendiconto;
rendicontoPreventivo.ValueChanged += rendicontoPreventivoValueChanged;
if (listaRate.DisplayLayout.Bands[0].Summaries.Count == 0)
{
DataGridHelper.AddSummary(listaRate.DisplayLayout.Bands[0], "PercentualeRipartoSaldo", "##.00%");
DataGridHelper.AddSummary(listaRate.DisplayLayout.Bands[0], "PercentualeRiparto", "##.00%");
DataGridHelper.AddSummary(listaRate.DisplayLayout.Bands[0], "Importo", "c");
}
assegnazioneResiduo.ValueChanged -= assegnazioneResiduoValueChanged;
assegnazioneResiduo.SelectedIndex = 0;
assegnazioneResiduo.ValueChanged += assegnazioneResiduoValueChanged;
mainTab.Tabs["pianoRateale"].Enabled = false;
mainTab.Tabs["rateSoggetti"].Enabled = false;
_avanzamento = AvanzamentoWizard.RiepilogoRiparto;
listaRiepilogoRiparto.PerformAction(UltraGridAction.EnterEditMode, false, false);
listaRiepilogoRiparto.UpdateData();
}
else
{
if (!string.IsNullOrEmpty(resultPianoRateale.FatalMessage))
CommonMessages.DisplayWarning(string.Format("Si sono verificati dei problemi nella creazione del piano rateale:{0}{1}", Environment.NewLine, resultPianoRateale.FatalMessage));
var mainContabilita = (MainContabilita)ParentForm;
if (mainContabilita != null)
mainContabilita.ToClose = true;
}
}
else
{
if (!string.IsNullOrEmpty(form.DataSourceObject.FatalMessage))
CommonMessages.DisplayWarning("Non è ammessa la creazione del piano rateale:" + Environment.NewLine + form.DataSourceObject.FatalMessage);
var mainContabilita = (MainContabilita)ParentForm;
if (mainContabilita != null)
mainContabilita.ToClose = true;
}
}
}
else
{
CommonMessages.DisplayWarning("Non è ammessa la creazione del piano rateale:" + Environment.NewLine + messaggio.FatalMessage);
var mainContabilita = (MainContabilita)ParentForm;
if (mainContabilita != null)
mainContabilita.ToClose = true;
}
}
else
{
CommonMessages.DisplayWarning("Prima di definire il riparto rateale occorre generare il bilancio preventivo.");
var mainContabilita = (MainContabilita)ParentForm;
if (mainContabilita != null)
mainContabilita.ToClose = true;
}
}
public void LoadData(CondominioDTO condominio, EsercizioDTO esercizio, List<RataSoggettoDTO> rateSoggetti, List<ImportoSaldoSoggettoDTO> saldiSoggetti, IList<RiepilogoRipartoDTO> riepilogoRiparto, TipoListaRate tipoLista, bool isCreazione, TipoAccorpamentoRateEnum tipo)
{
try
{
_tipo = tipo;
_condominio = condominio;
_esercizio = esercizio;
_rateSoggetti = rateSoggetti;
_saldiSoggetti = saldiSoggetti;
_riepilogoRiparto = riepilogoRiparto;
_isCreazione = isCreazione;
loadConti();
_pianoRateale = getRateCondominiService().GetPianoRatealeByEsercizio(_esercizio.ID, false) ?? new PianoRatealeDTO { Tipo = tipo };
_pianoRateale.Tipo = tipo;
if (_isCreazione)
{
btnStampa.Visible = false;
nuovaDataPanel.Visible = false;
}
else
{
btnStampa.Visible = true;
nuovaDataPanel.Visible = true;
}
sceltaTipoLista.Value = tipoLista.ToString().ToLower();
// Se è ancora a null carico la lista dei soggetti relativi al condominio.
if (_soggetti == null)
_soggetti = getRateCondominiService().GetPartecipanti(_condominio.ID, _tipo);
if(tipoLista == TipoListaRate.Pivot)
{
try
{
var resultMessage = getRateCondominiService().ConvertRateSoggettiToPivot(rateSoggetti, _saldiSoggetti, riepilogoRiparto, _allowInvertiSegno, _pianoRateale, _isCreazione);
if (resultMessage.DataTable == null)
{
CommonMessages.DisplayWarning(string.Format("Si sono verificati i seguenti errori:{1}{0}{1}Si prega di riprovare", resultMessage.FatalMessage, Environment.NewLine));
ParentForm?.Close();
return;
}
else
{
listaRateSoggetti.DataSource = resultMessage.DataTable;
setGridLayout(tipoLista);
setRowsLayout();
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante il caricamento dei dati del piano rateale - DataSource di listaRateSoggetti - {0} - condominio:{1} - esercizio:{2}", ex, Utility.GetMethodDescription(), _condominio.ID, _esercizio.ID);
throw;
}
}
else if (tipoLista == TipoListaRate.Editabile)
{
var dataSourceEditabile = rateSoggetti;
if (!_isCreazione)
dataSourceEditabile = new List<RataSoggettoDTO>(dataSourceEditabile.Where(item => item.ID > 0 && item.Importo > 0).ToList());
listaRateSoggetti.DataSource = new System.ComponentModel.BindingList<RataSoggettoDTO>(dataSourceEditabile);
listaRateSoggetti.DisplayLayout.ValueLists.Clear();
listaRateSoggetti.DisplayLayout.ValueLists.Add(DataSourceHelper.GetValueList(_soggetti, "ID", "DisplayNominativo", "SoggettiCondominio"));
listaRateSoggetti.DisplayLayout.Bands[0].Columns["IdSoggettoCondominio"].ValueList = listaRateSoggetti.DisplayLayout.ValueLists["SoggettiCondominio"];
setGridLayout(tipoLista);
}
listaRateSoggetti.DisplayLayout.Bands[0].Summaries.Clear();
foreach (var column in listaRateSoggetti.DisplayLayout.Bands[0].Columns)
{
if(column.DataType == typeof(decimal))
DataGridHelper.AddSummary(listaRateSoggetti.DisplayLayout.Bands[0], column.Key, "c");
}
btnConferma.Visible = false;
listaRateSoggetti.PerformAction(UltraGridAction.FirstRowInBand);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante il caricamento dei dati del piano rateale - 2 - {0} - condominio:{1} - esercizio:{2}", ex, Utility.GetMethodDescription(), _condominio.ID, _esercizio.ID);
throw;
}
}
public PianoRatealeSoggetti GetPianoRatealeSoggetti(PianoRatealeDTO pianoRateale, int numeroRate, List<RiepilogoRipartoDTO> riepilogo)
{
var result = GetServiceClient().GetPianoRatealeSoggetti(pianoRateale, numeroRate, riepilogo, GetUserInfo());
CloseService();
return result;
}
public PianoRatealeSoggetti(PianoRatealeDTO pianoRateale, List<ImportoSaldoSoggettoDTO> saldiSoggetti, List<RataSoggettoDTO> rateSoggetti)
{
PianoRateale = pianoRateale;
RateSoggetti = rateSoggetti;
SaldiSoggetti = saldiSoggetti;
}
public ResultMessages<PianoRatealeDTO> CreatePianoRateale(PianoRatealeDTO pianoRateale, int numeroRate, IList<RiepilogoRipartoDTO> riepilogoRiparto, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var rateService = windsorRep.GetContainer(userinfo.Azienda).Resolve<IRateService>();
var item = rateService.CreatePianoRateale(pianoRateale, numeroRate, riepilogoRiparto);
windsorRep.Commit();
return new ResultMessages<PianoRatealeDTO>(item, null, null);
}
catch (InvalidDataException ex)
{
return new ResultMessages<PianoRatealeDTO>(null, ex.Message, null);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella esecuzione della funzione - {0} - esercizio:{1} - numeroRate:{2} - azienda:{3}", ex, Utility.GetMethodDescription(), pianoRateale.IdEsercizio, numeroRate, userinfo.Azienda);
windsorRep.Rollback();
throw;
}
}
