public Movimentacao(int movimentacaoId, int produtoId, TipoMovimentoEnum tipoMovimento, DateTime data)
{
MovimentacaoId = movimentacaoId;
ProdutoId = produtoId;
TipoMovimento = tipoMovimento;
Data = data;
}
public MovimentoContabileEconomicoUC(CausaleContabileDTO causale, EsercizioDTO esercizio, ContoDTO conto, int? idContoBancario, DateTime? dataContabile, string descrizione, decimal importo, TipoMovimentoEnum incassoSpesa, int? idMovimentoBancario)
{
InitializeComponent();
_idMovimentoBancario = idMovimentoBancario;
_causalePreimpostata = true;
_causale = causale;
_esercizio = esercizio;
_conto = conto;
_idContoBancario = idContoBancario;
_importo = importo;
_dataContabile = dataContabile;
if (_importo > 0)
{
importoMovimento.TabStop = false;
importoCompareValidator.ValueToCompare = _importo.ToString();
movimentoValidationSummary.Validators.Add(importoCompareValidator);
}
inizializza();
executeNew();
_confirmByParent = true;
_tipoMovimento = incassoSpesa;
ripartizioneDettaglio.DisplayLayout.Bands[0].Override.AllowAddNew = AllowAddNew.TemplateOnBottom;
descrizioneDettaglio.Text = descrizione;
sceltaCondominioCombo1.Enabled = false;
}
public async Task <IEnumerable <Premio> > ObterPremiosPorCertificado(long itemCertificadoApoliceId, TipoMovimentoEnum tipoMovimento)
{
var query = @"SELECT P.*
FROM Premio P
INNER JOIN HistoricoCoberturaContratada H ON H.Id = P.HistoricoCoberturaId
INNER JOIN CoberturaContratada C ON C.Id = H.CoberturaContratadaId
WHERE C.ItemCertificadoApoliceId = @Id
AND P.TipoMovimentoId = @Tipo";
return(await CreateCommand.QueryAsync <Premio>(query, new { Id = itemCertificadoApoliceId, Tipo = (int)tipoMovimento }));
}
private void clearDettaglioFields()
{
try
{
descrizioneDettaglio.Text = string.Empty;
if (sceltaCondominioCombo1.CondominioSelected != null)
{
descrizioneDettaglio.Text = sceltaCondominioCombo1.CondominioSelected.FormatoDescrizioneMovimento;
archiviazioneOttica.Checked = sceltaCondominioCombo1.CondominioSelected.IsAbilitataArchiviazioneOtticaPassivi;
}
importoMovimento.ValueObject = null;
modelloRipartizione.Value = null;
_tipoMovimento = TipoMovimentoEnum.Spesa;
importoMovimento.Appearance.ForeColor = Color.Red;
btnSpesa.CheckedChanged -= btnSpesaCheckedChanged;
btnSpesa.Checked = true;
btnSpesa.CheckedChanged += btnSpesaCheckedChanged;
btnIncasso.CheckedChanged -= btnIncassoCheckedChanged;
btnIncasso.Checked = !btnSpesa.Checked;
btnIncasso.CheckedChanged += btnIncassoCheckedChanged;
btnIncasso.Enabled = true;
btnSpesa.Enabled = false;
sceltaFornitoreSottocontoCombo.Visible = false;
numeroProtocollo.Value = null;
if (!_causalePreimpostata)
{
causale.Value = null;
contoPatrimoniale.Value = null;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore non previsto nella CLEAR dei campi di DETTAGLIO della videata - {0} - movimento:{1}", ex, Utility.GetMethodDescription(), _movimentoAvere.ID);
throw;
}
}
private void btnIncassoCheckedChanged(object sender, EventArgs e)
{
try
{
btnSpesa.CheckedChanged -= btnSpesaCheckedChanged;
btnIncasso.Enabled = false;
btnSpesa.Enabled = true;
btnSpesa.Checked = !btnIncasso.Checked;
_tipoMovimento = TipoMovimentoEnum.Accredito;
importoMovimento.Appearance.ForeColor = Color.Black;
if (sender != null && !_senzaInversione)
{
foreach (var row in ripartizioneDettaglio.Rows)
{
try
{
if (row.IsDataRow && !row.IsAddRow)
{
if (row.Cells["Importo"].Value != null)
row.Cells["Importo"].Value = (decimal)row.Cells["Importo"].Value * -1;
afterRowUpdate(row);
}
}
catch(Exception ex)
{
_log.Error("Errore nella modifica del movimento tra spesa e incasso - SINGOLA RIGA " + Utility.GetMethodDescription() + " - id:" + _movimentoAvere.ID + " - azienda:" + Login.Instance.CurrentLogin().Azienda, ex);
}
}
try
{
ripartizioneDettaglio.PerformAction(UltraGridAction.EnterEditMode, false, false);
ripartizioneDettaglio.UpdateData();
}
catch (Exception ex)
{
_log.Warn("Clear layout della grid è andato in errore - " + Utility.GetMethodDescription() + " - movimento:" + _movimentoAvere.ID, ex);
}
}
btnSpesa.CheckedChanged += btnSpesaCheckedChanged;
}
catch(Exception ex)
{
_log.Error("Errore nella modifica del movimento tra spesa e incasso - " + Utility.GetMethodDescription() + " - id:" + _movimentoAvere.ID + " - azienda:" + Login.Instance.CurrentLogin().Azienda, ex);
}
}
private void btnSpesaCheckedChanged(object sender, EventArgs e)
{
btnIncasso.CheckedChanged -=btnIncassoCheckedChanged;
btnIncasso.Enabled = true;
btnSpesa.Enabled = false;
btnIncasso.Checked = !btnSpesa.Checked;
_tipoMovimento = TipoMovimentoEnum.Spesa;
importoMovimento.Appearance.ForeColor = Color.Red;
foreach (var row in ripartizioneDettaglio.Rows)
{
if (row.IsDataRow && !row.IsAddRow)
{
if (row.Cells["Importo"].Value != null)
row.Cells["Importo"].Value = (decimal)row.Cells["Importo"].Value * -1;
afterRowUpdate(row);
}
}
_senzaInversione = false;
ripartizioneDettaglio.PerformAction(UltraGridAction.EnterEditMode, false, false);
ripartizioneDettaglio.UpdateData();
btnIncasso.CheckedChanged += btnIncassoCheckedChanged;
}
public void ApplyModello(TestataMovimentoContabile testata, int idModello, decimal importo, TipoMovimentoEnum tipo, bool loadRipartizione)
{
var modello = _daoFactory.GetModelloRegistrazioneContabileDao().GetById(idModello, true);
IList<MovimentoContabile> movimentiDaRimuovere = testata.Movimenti.Where(mov => mov.IsVisibileGestione && mov.IsEconomico()).ToList();
foreach (var movimentoContabile in movimentiDaRimuovere)
testata.Movimenti.Remove(movimentoContabile);
var i = testata.Movimenti.Count;
var totalePercentualiConti = modello.Conti.Sum(item => item.PercentualeRipartizione.GetValueOrDefault());
foreach (var conto in modello.Conti)
{
i++;
decimal? importoMovimento;
if (totalePercentualiConti != 0)
importoMovimento = (importo / totalePercentualiConti) * conto.PercentualeRipartizione;
else
{
importoMovimento = importo;
if (conto.PercentualeRipartizione.GetValueOrDefault() < 0)
importoMovimento = importoMovimento * -1;
}
// se si tratta di un accredito devo invertire il segno dell'importo
var segno = "D";
if (tipo == TipoMovimentoEnum.Accredito)
segno = "A";
var movimento = new MovimentoContabile(testata, _daoFactory.GetCausaleContabileDao().GetByCodice("IF"), i, conto.ContoRiferimento, importoMovimento, segno) {SottoContoRiferimento = conto.SottoContoRiferimento};
if (movimento.SottoContoRiferimento == null)
movimento.Descrizione = modello.DescrizioneVoceFattura;
if (loadRipartizione)
{
foreach (var dettaglioModello in conto.Unita)
{
// Lotti
if (dettaglioModello.LottoRiferimento != null)
{
if (!_lottiSelezionati.ContainsKey(GetKey(movimento)))
_lottiSelezionati.Add(GetKey(movimento), GetLottiDataSource(GetKey(movimento), conto.ContoRiferimento.ID, testata.EsercizioRiferimento.CondominioRiferimento.ID, null, false));
_lottiSelezionati[GetKey(movimento)].Rows.Find(dettaglioModello.LottoRiferimento.ID)["Selezionato"] = true;
}
// Stabili
if (dettaglioModello.PalazzinaRiferimento != null)
{
if (!_stabiliSelezionati.ContainsKey(GetKey(movimento)))
_stabiliSelezionati.Add(GetKey(movimento), GetStabiliDataSource(GetKey(movimento), conto.ContoRiferimento.ID, testata.EsercizioRiferimento.CondominioRiferimento.ID, null, false));
_stabiliSelezionati[GetKey(movimento)].Rows.Find(dettaglioModello.PalazzinaRiferimento.ID)["Selezionato"] = true;
}
// Gruppi
if (dettaglioModello.GruppoStabileRiferimento != null)
{
if (!_gruppiSelezionati.ContainsKey(GetKey(movimento)))
_gruppiSelezionati.Add(GetKey(movimento), GetGruppiDataSource(GetKey(movimento), conto.ContoRiferimento.ID, testata.EsercizioRiferimento.CondominioRiferimento.ID, null, false));
_gruppiSelezionati[GetKey(movimento)].Rows.Find(dettaglioModello.GruppoStabileRiferimento.ID)["Selezionato"] = true;
}
// Unità Immobiliari
if (dettaglioModello.UnitaRiferimento != null)
{
if (!_unitaSelezionate.ContainsKey(GetKey(movimento)))
_unitaSelezionate.Add(GetKey(movimento), GetUnitaDataSource(GetKey(movimento), conto.ContoRiferimento.ID, testata.EsercizioRiferimento.CondominioRiferimento.ID, false, movimento.Testata.EsercizioRiferimento, false));
var row = _unitaSelezionate[GetKey(movimento)].Rows.Find(dettaglioModello.UnitaRiferimento.ID);
if (row != null)
row["Selezionato"] = true;
}
}
SalvaRipartizione(movimento, testata.EsercizioRiferimento.CondominioRiferimento.ID);
}
else
{
var lottiRiferimento = new List<Lotto>();
var stabiliRiferimento = new List<Palazzina>();
var gruppiRiferimento = new List<GruppoStabile>();
foreach (var dettaglioModello in conto.Unita)
{
// Lotti
if (dettaglioModello.LottoRiferimento != null)
lottiRiferimento.Add(dettaglioModello.LottoRiferimento);
// Stabili
if (dettaglioModello.PalazzinaRiferimento != null)
stabiliRiferimento.Add(dettaglioModello.PalazzinaRiferimento);
// Gruppi
if (dettaglioModello.GruppoStabileRiferimento != null)
gruppiRiferimento.Add(dettaglioModello.GruppoStabileRiferimento);
}
foreach (var lotto in lottiRiferimento)
movimento.LottiAddebito += lotto.ID + "&";
foreach (var stabile in stabiliRiferimento)
movimento.StabiliAddebito += stabile.ID + "&";
foreach (var gruppo in gruppiRiferimento)
movimento.GruppiAddebito += gruppo.ID + "&";
if (!string.IsNullOrEmpty(movimento.LottiAddebito) && movimento.LottiAddebito.EndsWith("&"))
movimento.LottiAddebito = movimento.LottiAddebito.Substring(0, movimento.LottiAddebito.Length - 1);
if (!string.IsNullOrEmpty(movimento.StabiliAddebito) && movimento.StabiliAddebito.EndsWith("&"))
movimento.StabiliAddebito = movimento.StabiliAddebito.Substring(0, movimento.StabiliAddebito.Length - 1);
if (!string.IsNullOrEmpty(movimento.GruppiAddebito) && movimento.GruppiAddebito.EndsWith("&"))
movimento.GruppiAddebito = movimento.GruppiAddebito.Substring(0, movimento.GruppiAddebito.Length - 1);
}
}
testata.ModelloRipartizione = modello;
}
public RipartizioneSpeseDTO GetRipartizioneByModello(int idEsercizio, int idTestataMovimentoContabile, int idModello, int idCausale, decimal importo, TipoMovimentoEnum tipo)
{
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
var ripartizioneSpeseService = _windsorRepository.GetContainer(_info.Azienda).Resolve<IRipartizioneSpeseService>();
var testataRep = new TestataMovimentoContabileRepository(_info, _windsorRepository, null);
var ripartizione = new RipartizioneSpeseDTO();
try
{
var testata = daoFactory.GetTestataMovimentoContabileDao().Find(idTestataMovimentoContabile, false);
if (testata != null)
ripartizioneSpeseService.ApplyModello(testata, idModello, importo, tipo, false);
else
testata = ripartizioneSpeseService.ApplyModello(idEsercizio, idModello, idCausale, importo, tipo, false);
if(testata != null)
ripartizione.Testata = testataRep.GetByDomainEntity(testata);
else
_log.WarnFormat("Testata a NULL - {0} - esercizio:{1} - modello:{2} - testataMovimentoContabile:{3}", Library.Utility.GetMethodDescription(), idEsercizio, idModello, idTestataMovimentoContabile);
return ripartizione;
// --------------------------------------
// Lotti
// --------------------------------------
var esercizio = daoFactory.GetEsercizioDao().GetById(idEsercizio, false);
var lotti = new Dictionary<string, BusinessInstanceSelectedDTO[]>(testata.Movimenti.Count);
foreach (var movimento in testata.Movimenti)
{
var key = ripartizioneSpeseService.GetKey(movimento);
var tbLotti = ripartizioneSpeseService.GetLottiDataSource(key, movimento.ContoRiferimento.ID, esercizio.CondominioRiferimento.ID, null);
lotti.Add(key, getListaDto(tbLotti));
}
ripartizione.Lotti = lotti;
// --------------------------------------
// Stabili
// --------------------------------------
var stabili = new Dictionary<string, BusinessInstanceSelectedDTO[]>(testata.Movimenti.Count);
foreach (var movimento in testata.Movimenti)
{
string key = ripartizioneSpeseService.GetKey(movimento);
var tbStabili = ripartizioneSpeseService.GetStabiliDataSource(key, movimento.ContoRiferimento.ID, esercizio.CondominioRiferimento.ID, null);
stabili.Add(key, getListaDto(tbStabili));
}
ripartizione.Stabili = stabili;
// --------------------------------------
// Gruppi
// --------------------------------------
var gruppi = new Dictionary<string, BusinessInstanceSelectedDTO[]>(testata.Movimenti.Count);
foreach (var movimento in testata.Movimenti)
{
var key = ripartizioneSpeseService.GetKey(movimento);
var tbGruppi = ripartizioneSpeseService.GetGruppiDataSource(key, movimento.ContoRiferimento.ID, esercizio.CondominioRiferimento.ID, null);
gruppi.Add(key, getListaDto(tbGruppi));
}
ripartizione.Gruppi = gruppi;
// --------------------------------------
// Unità Immobiliari
// --------------------------------------
var unita = new Dictionary<string, UnitaImmobiliareSelectedDTO[]>(testata.Movimenti.Count);
foreach (var movimento in testata.Movimenti)
{
var key = ripartizioneSpeseService.GetKey(movimento);
var tbUnita = ripartizioneSpeseService.GetUnitaDataSource(key, movimento.ContoRiferimento.ID, esercizio.CondominioRiferimento.ID, testata.EsercizioRiferimento);
unita.Add(key, getListaUnitaDto(tbUnita, movimento.ContoRiferimento));
}
ripartizione.UnitaImmobiliari = unita;
return ripartizione;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel caricamento delle ripartizioni spese - {0} - esercizio:{1} - modello:{2} - testataMovimentoContabile:{3}", ex, Library.Utility.GetMethodDescription(), idEsercizio, idModello, idTestataMovimentoContabile);
throw;
}
}
public void ApplyModello(DettaglioSpesa dettaglio, int idModello, TipoMovimentoEnum tipo)
{
try
{
if (dettaglio.Movimenti.Count > 0)
{
_gruppiSelezionati.Clear();
_lottiSelezionati.Clear();
_stabiliSelezionati.Clear();
_unitaSelezionate.Clear();
var modello = _daoFactory.GetModelloRegistrazioneContabileDao().GetById(idModello, true);
var testata = IesiGenericCollections<MovimentoContabile>.GetByIndex(dettaglio.Movimenti, 0).Testata;
var oldMovimenti = new Dictionary<int, MovimentoContabile>();
var i = 0;
foreach (var mov in dettaglio.Movimenti)
{
i++;
oldMovimenti.Add(i, mov);
if (mov.Testata != null)
{
mov.Testata.Movimenti.Remove(mov);
mov.Testata = null;
}
if (mov.ContoRiferimento != null)
{
mov.ContoRiferimento.Movimenti.Remove(mov);
mov.ContoRiferimento = null;
}
if (mov.CondominoRiferimento != null)
{
mov.CondominoRiferimento.Movimenti.Remove(mov);
mov.CondominoRiferimento = null;
}
if (mov.EvasioneBancaria != null)
{
mov.EvasioneBancaria.MovimentiContabili.Remove(mov);
mov.EvasioneBancaria = null;
}
if (mov.FornitoreRiferimento != null)
{
mov.FornitoreRiferimento.MovimentiContabili.Remove(mov);
mov.FornitoreRiferimento = null;
}
if (mov.ContoCorrenteBancario != null)
{
mov.ContoCorrenteBancario.MovimentiContabili.Remove(mov);
mov.ContoCorrenteBancario = null;
}
if (mov.Spesa != null)
{
mov.Spesa.MovimentiBollette.Remove(mov);
mov.Spesa = null;
}
}
dettaglio.Movimenti.Clear();
i = 0;
decimal importoRipartito = 0;
var totalePercentualiConti = modello.Conti.Sum(item => item.PercentualeRipartizione.GetValueOrDefault());
foreach (var conto in modello.Conti)
{
i++;
decimal importoMovimento;
var importoDettaglio = dettaglio.ImportoLordo.GetValueOrDefault();
if (dettaglio.NumeroRiga.GetValueOrDefault() == 1)
importoDettaglio += dettaglio.SpesaRiferimento.AltreSpese.GetValueOrDefault() + dettaglio.SpesaRiferimento.AltreSpeseEsenti.GetValueOrDefault();
if (totalePercentualiConti != 0)
importoMovimento = (importoDettaglio / totalePercentualiConti) * conto.PercentualeRipartizione.GetValueOrDefault();
else
{
importoMovimento = importoDettaglio;
if (conto.PercentualeRipartizione.GetValueOrDefault() < 0)
importoMovimento = importoMovimento * -1;
}
if (i == modello.Conti.Count)
{
if (tipo == TipoMovimentoEnum.Accredito)
importoRipartito = importoRipartito*-1;
importoMovimento = importoDettaglio - importoRipartito;
}
// se si tratta di un accredito devo invertire il segno dell'importo
var segno = "D";
if (tipo == TipoMovimentoEnum.Accredito)
{
segno = "A";
importoMovimento = importoMovimento * -1;
}
var movimento = new MovimentoContabile(testata, dettaglio, _daoFactory.GetCausaleContabileDao().GetByCodice("IF"), i, conto.ContoRiferimento, importoMovimento, segno) {SottoContoRiferimento = conto.SottoContoRiferimento};
importoRipartito += importoMovimento;
if (oldMovimenti.ContainsKey(i))
{
movimento.Descrizione = oldMovimenti[i].Descrizione;
movimento.PercentualeProprieta = oldMovimenti[i].PercentualeProprieta;
}
else
movimento.Descrizione = modello.DescrizioneVoceFattura;
if (conto.Unita.Count > 0)
{
movimento.IsRipartoPersonalizzato = true;
foreach (var dettaglioModello in conto.Unita)
{
// Lotti
if (dettaglioModello.LottoRiferimento != null)
{
if (!_lottiSelezionati.ContainsKey(GetKey(movimento)))
_lottiSelezionati.Add(GetKey(movimento), GetLottiDataSource(GetKey(movimento), conto.ContoRiferimento.ID, dettaglio.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, null, false));
_lottiSelezionati[GetKey(movimento)].Rows.Find(dettaglioModello.LottoRiferimento.ID)["Selezionato"] = true;
movimento.LottiAddebito += dettaglioModello.LottoRiferimento.ID + "&";
}
// Stabili
if (dettaglioModello.PalazzinaRiferimento != null)
{
if (!_stabiliSelezionati.ContainsKey(GetKey(movimento)))
_stabiliSelezionati.Add(GetKey(movimento), GetStabiliDataSource(GetKey(movimento), conto.ContoRiferimento.ID, dettaglio.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, null, false));
_stabiliSelezionati[GetKey(movimento)].Rows.Find(dettaglioModello.PalazzinaRiferimento.ID)["Selezionato"] = true;
movimento.StabiliAddebito += dettaglioModello.PalazzinaRiferimento.ID + "&";
}
// Gruppi
if (dettaglioModello.GruppoStabileRiferimento != null)
{
if (!_gruppiSelezionati.ContainsKey(GetKey(movimento)))
_gruppiSelezionati.Add(GetKey(movimento), GetGruppiDataSource(GetKey(movimento), conto.ContoRiferimento.ID, dettaglio.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, null, false));
_gruppiSelezionati[GetKey(movimento)].Rows.Find(dettaglioModello.GruppoStabileRiferimento.ID)["Selezionato"] = true;
movimento.GruppiAddebito += dettaglioModello.GruppoStabileRiferimento.ID + "&";
}
// Unità Immobiliari
if (dettaglioModello.UnitaRiferimento != null)
{
if (!_unitaSelezionate.ContainsKey(GetKey(movimento)))
_unitaSelezionate.Add(GetKey(movimento), GetUnitaDataSource(GetKey(movimento), conto.ContoRiferimento.ID, dettaglio.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, false, movimento.Testata.EsercizioRiferimento, false));
var rows = _unitaSelezionate[GetKey(movimento)].Select($"IdUnitaImmobiliare = {dettaglioModello.UnitaRiferimento.ID}");
if (rows.Length == 1)
rows[0]["Selezionato"] = true;
else if(!rows.Any() && conto.ContoRiferimento.IsSpesePersonali)
{
var soggetto = conto.ContoRiferimento.PercentualeProprieta == 0 ? dettaglioModello.UnitaRiferimento.GetConduttorePrincipale(dettaglio.SpesaRiferimento.EsercizioRiferimento.DataChiusura) : dettaglioModello.UnitaRiferimento.GetProprietarioPrincipale(dettaglio.SpesaRiferimento.EsercizioRiferimento.DataChiusura);
if (soggetto != null)
{
rows = _unitaSelezionate[GetKey(movimento)].Select($"IdSoggettoCondominio = {soggetto.ID}");
if (rows.Length == 1)
rows[0]["Selezionato"] = true;
}
}
}
}
if (!string.IsNullOrEmpty(movimento.LottiAddebito))
movimento.LottiAddebito = movimento.LottiAddebito.Substring(0, movimento.LottiAddebito.Length - 1);
if (!string.IsNullOrEmpty(movimento.StabiliAddebito))
movimento.StabiliAddebito = movimento.StabiliAddebito.Substring(0, movimento.StabiliAddebito.Length - 1);
if (!string.IsNullOrEmpty(movimento.GruppiAddebito))
movimento.GruppiAddebito = movimento.GruppiAddebito.Substring(0, movimento.GruppiAddebito.Length - 1);
}
else
{
// ===========================================================================================
// BUGID#2159 - COMMENTATO: Con la nuova funzione di riparto aggregato NON devono
// più essere usati gli oggetti SpeseUnita NON deve quindi essere ripartito lo specifico
// movimento a meno che non sia previsto un riparto personalizzato a livello di modello
// Sostuitita con calcolo degli addebiti specifici per Lotto, Stabile e Scala.
// ----------------------------------------------------------------------------------
// Se sono presenti selezioni per Stabile, Scala o specifica unità le applico ...
// ----------------------------------------------------------------------------------
movimento.LottiAddebito = string.Empty;
movimento.StabiliAddebito = string.Empty;
movimento.GruppiAddebito = string.Empty;
foreach (var dettaglioModello in conto.Unita)
{
// Lotti
if (dettaglioModello.LottoRiferimento != null)
{
if (!string.IsNullOrEmpty(movimento.LottiAddebito))
movimento.LottiAddebito += "&";
movimento.LottiAddebito += dettaglioModello.LottoRiferimento.ID;
}
// Stabili
if (dettaglioModello.PalazzinaRiferimento != null)
{
if (!string.IsNullOrEmpty(movimento.StabiliAddebito))
movimento.StabiliAddebito += "&";
movimento.StabiliAddebito += dettaglioModello.PalazzinaRiferimento.ID;
}
// Gruppi
if (dettaglioModello.GruppoStabileRiferimento != null)
{
if (!string.IsNullOrEmpty(movimento.GruppiAddebito))
movimento.GruppiAddebito += "&";
movimento.GruppiAddebito += dettaglioModello.GruppoStabileRiferimento.ID;
}
}
}
//// ----------------------------------------------------------------------------------
//// ... altrimenti seleziono tutte le unità ...
//// ----------------------------------------------------------------------------------
//else
// if (!_unitaSelezionate.ContainsKey(GetKey(movimento)))
// _unitaSelezionate.Add(GetKey(movimento), GetUnitaDataSource(GetKey(movimento), conto.ContoRiferimento.ID, dettaglio.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, movimento.GetImportoConSegno(), true, movimento.Testata.EsercizioRiferimento));
// ===========================================================================================
}
}
else
{
_log.WarnFormat("Presente dettaglio senza movimenti - {0} - dettaglio:{1} - modello:{1} - tipo:{2}", Utility.GetMethodDescription(), dettaglio.ID, idModello, tipo);
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore durante l'applicazione del modello - {0} - dettaglio:{1} - modello:{1} - tipo:{2}", ex, Utility.GetMethodDescription(), dettaglio.ID, idModello, tipo);
throw;
}
}
public TestataMovimentoContabile ApplyModello(int idEsercizio, int idModello, int idCausale, decimal importo, TipoMovimentoEnum tipo, bool loadRipartizione)
{
var esercizio = _daoFactory.GetEsercizioDao().GetById(idEsercizio, false);
var modello = _daoFactory.GetModelloRegistrazioneContabileDao().Find(idModello, true);
if (modello != null)
{
var testata = new TestataMovimentoContabile(esercizio, DateTime.Today, TipoTestataMovimentoContabileEnum.Manuale, null);
var causale = _daoFactory.GetCausaleContabileDao().GetById(idCausale, false);
decimal importoRipartito = 0;
var i = 0;
var totalePercentualiConti = modello.Conti.Sum(item => item.PercentualeRipartizione.GetValueOrDefault());
foreach (var conto in modello.Conti)
{
i++;
decimal importoMovimento;
if (totalePercentualiConti != 0)
importoMovimento = (importo / totalePercentualiConti) * conto.PercentualeRipartizione.Value;
else
{
importoMovimento = importo;
if (conto.PercentualeRipartizione.Value < 0)
importoMovimento = importoMovimento * -1;
}
if (i == modello.Conti.Count && totalePercentualiConti != 0)
importoMovimento = importo - importoRipartito;
// se si tratta di un accredito devo invertire il segno dell'importo
var segno = "D";
if (tipo == TipoMovimentoEnum.Accredito)
segno = "A";
var movimento = new MovimentoContabile(testata, causale, i, conto.ContoRiferimento, importoMovimento, segno);
importoRipartito += importoMovimento;
movimento.SottoContoRiferimento = conto.SottoContoRiferimento;
if (movimento.SottoContoRiferimento == null)
movimento.Descrizione = modello.DescrizioneVoceFattura;
if (loadRipartizione)
{
foreach (var dettaglioModello in conto.Unita)
{
// Lotti
if (dettaglioModello.LottoRiferimento != null)
{
if (!_lottiSelezionati.ContainsKey(GetKey(movimento)))
_lottiSelezionati.Add(GetKey(movimento), GetLottiDataSource(GetKey(movimento), conto.ContoRiferimento.ID, esercizio.CondominioRiferimento.ID, null, false));
_lottiSelezionati[GetKey(movimento)].Rows.Find(dettaglioModello.LottoRiferimento.ID)["Selezionato"] = true;
}
if (!string.IsNullOrEmpty(movimento.LottiAddebito))
movimento.LottiAddebito = movimento.LottiAddebito.Substring(0, movimento.LottiAddebito.Length - 1);
// Stabili
if (dettaglioModello.PalazzinaRiferimento != null)
{
if (!_stabiliSelezionati.ContainsKey(GetKey(movimento)))
_stabiliSelezionati.Add(GetKey(movimento), GetStabiliDataSource(GetKey(movimento), conto.ContoRiferimento.ID, esercizio.CondominioRiferimento.ID, null, false));
_stabiliSelezionati[GetKey(movimento)].Rows.Find(dettaglioModello.PalazzinaRiferimento.ID)["Selezionato"] = true;
foreach (var gruppo in dettaglioModello.PalazzinaRiferimento.GruppiStabile)
{
if (!_gruppiSelezionati.ContainsKey(GetKey(movimento)))
_gruppiSelezionati.Add(GetKey(movimento), GetGruppiDataSource(GetKey(movimento), conto.ContoRiferimento.ID, esercizio.CondominioRiferimento.ID, null, false));
_gruppiSelezionati[GetKey(movimento)].Rows.Find(gruppo.ID)["Selezionato"] = true;
foreach (var unita in gruppo.UnitaImmobiliari)
{
if (!_unitaSelezionate.ContainsKey(GetKey(movimento)))
_unitaSelezionate.Add(GetKey(movimento), GetUnitaDataSource(GetKey(movimento), conto.ContoRiferimento.ID, esercizio.CondominioRiferimento.ID, false, movimento.Testata.EsercizioRiferimento, false));
var row = _unitaSelezionate[GetKey(movimento)].Rows.Find(unita.ID);
if (row != null)
row["Selezionato"] = true;
}
}
}
// Gruppi
if (dettaglioModello.GruppoStabileRiferimento != null)
{
if (!_gruppiSelezionati.ContainsKey(GetKey(movimento)))
_gruppiSelezionati.Add(GetKey(movimento), GetGruppiDataSource(GetKey(movimento), conto.ContoRiferimento.ID, esercizio.CondominioRiferimento.ID, null, false));
_gruppiSelezionati[GetKey(movimento)].Rows.Find(dettaglioModello.GruppoStabileRiferimento.ID)["Selezionato"] = true;
foreach (var unita in dettaglioModello.GruppoStabileRiferimento.UnitaImmobiliari)
{
if (!_unitaSelezionate.ContainsKey(GetKey(movimento)))
_unitaSelezionate.Add(GetKey(movimento), GetUnitaDataSource(GetKey(movimento), conto.ContoRiferimento.ID, esercizio.CondominioRiferimento.ID, false, esercizio, false));
var row = _unitaSelezionate[GetKey(movimento)].Rows.Find(unita.ID);
if (row != null)
row["Selezionato"] = true;
}
}
// Unità Immobiliari
if (dettaglioModello.UnitaRiferimento != null)
{
if (!_unitaSelezionate.ContainsKey(GetKey(movimento)))
_unitaSelezionate.Add(GetKey(movimento), GetUnitaDataSource(GetKey(movimento), conto.ContoRiferimento.ID, esercizio.CondominioRiferimento.ID, false, esercizio, false));
var row = _unitaSelezionate[GetKey(movimento)].Rows.Find(dettaglioModello.UnitaRiferimento.ID);
if (row != null)
row["Selezionato"] = true;
}
}
}
}
return testata;
}
return null;
}
public Dictionary<DettaglioSpesaDTO, RipartizioneSpeseDTO> SetRipartizioneByModello(DettaglioSpesaDTO dettaglio, int idEsercizio, int idModello, int idCausale, decimal importo, Dictionary<DettaglioSpesaDTO, RipartizioneSpeseDTO> ripartizione, TipoMovimentoEnum tipo)
{
var ripartizioneDettaglioNew = GetServiceClient().GetRipartizioneByModello(idEsercizio, 0, idModello, idCausale, importo, tipo, GetUserInfo());
ripartizione[dettaglio] = ripartizioneDettaglioNew;
if (_isMultiSpesa)
{
var newRipartizione = new Dictionary<DettaglioSpesaDTO, RipartizioneSpeseDTO>(ripartizione.Count);
foreach (var kvp in ripartizione)
{
var riparto = ripartizioneDettaglioNew;
if (kvp.Key != dettaglio)
{
riparto = GetRipartizioneByModello(idEsercizio, null, idModello, idCausale, kvp.Key.ImportoLordo.GetValueOrDefault(), tipo);
kvp.Key.Movimenti = riparto.Testata.Movimenti;
}
newRipartizione.Add(kvp.Key, riparto);
}
ripartizione = newRipartizione;
}
CloseService();
return ripartizione;
}
public RipartizioneSpeseDTO GetRipartizioneByModello(int idEsercizio, TestataMovimentoContabileDTO testata, int idModello, int idCausale, decimal importo, TipoMovimentoEnum tipo)
{
try
{
var idTestata = 0;
if (testata != null)
idTestata = testata.ID;
var result = GetServiceClient().GetRipartizioneByModello(idEsercizio, idTestata, idModello, idCausale, importo, tipo, GetUserInfo());
CloseService();
return result;
}
catch (CommunicationObjectAbortedException ex)
{
_log.DebugFormat("Errore nella chiamata al servizio - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), Login.Instance.CurrentLogin().Azienda);
}
catch (CommunicationObjectFaultedException ex)
{
_log.DebugFormat("Errore nella chiamata al servizio - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), Login.Instance.CurrentLogin().Azienda);
}
catch (IOException ex)
{
_log.DebugFormat("Errore nella chiamata al servizio - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), Login.Instance.CurrentLogin().Azienda);
}
catch (ObjectDisposedException ex)
{
_log.DebugFormat("Errore nella chiamata al servizio - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), Login.Instance.CurrentLogin().Azienda);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella chiamata al servizio - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), Login.Instance.CurrentLogin().Azienda);
throw;
}
return new RipartizioneSpeseDTO();
}
public RipartizioneSpeseDTO GetRipartizioneByModello(int idEsercizio, int idTestataMovimentoContabile, int idModello, int idCausale, decimal importo, TipoMovimentoEnum tipo, UserInfo userinfo)
{
var retryCount = 10;
var success = false;
var windsorRep = new WindsorConfigRepository();
RipartizioneSpeseDTO item = null;
while (retryCount >= 0 && !success)
{
try
{
windsorRep.BeginTransaction(userinfo);
var rep = new RipartizioneSpeseRepository(userinfo, windsorRep);
item = rep.GetRipartizioneByModello(idEsercizio, idTestataMovimentoContabile, idModello, idCausale, importo, tipo);
windsorRep.Commit();
success = true;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella esecuzione della funzione - TENTATIVO:{0} - {1} - esercizio:{2} - testataMovimentoContabile:{3} - modello:{4} - causale:{5} - importo:{6} - tipo:{7} - azienda:{8} - number:{9}", ex, (11 - retryCount), Utility.GetMethodDescription(), idEsercizio, idTestataMovimentoContabile, idModello, idCausale, importo, tipo, 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("Esecuzione della funzione - TENTATIVO:{0} - {1} - esercizio:{2} - testataMovimentoContabile:{3} - modello:{4} - causale:{5} - importo:{6} - tipo:{7} - azienda:{8}", (11 - retryCount), Utility.GetMethodDescription(), idEsercizio, idTestataMovimentoContabile, idModello, idCausale, importo, tipo, userinfo.Azienda);
}
}
if (!success)
windsorRep.Rollback();
return item;
}
