public RipartizioneMovimentoUC(RipartizioneSpeseDTO ripartizione, string key, MovimentoContabileDTO movimentoContabileDTO, EsercizioDTO esercizioDTO, decimal importo, bool readOnly)
{
InitializeComponent();
_ripartizione = ripartizione;
_key = key;
_movimentoContabileDTO = movimentoContabileDTO;
_esercizioDTO = esercizioDTO;
_importo = importo;
_readOnly = readOnly;
inizializza();
}
public RipartizioneMovimentoUI(RipartizioneSpeseDTO ripartizione, string key, MovimentoContabileDTO movimentoContabileDTO, EsercizioDTO esercizioDTO, decimal importo, bool readOnly)
{
InitializeComponent();
if(ripartizione == null)
Close();
_control = new RipartizioneMovimentoUC(ripartizione, key, movimentoContabileDTO, esercizioDTO, importo, readOnly) { Dock = DockStyle.Fill };
tableLayoutPanel1.Controls.Add(_control, 0, 0);
if (readOnly)
btnConferma.Enabled = false;
persistWindowComponent1.UserName = Security.Login.Instance.CurrentLogin().LoginName;
}
public Dictionary<DettaglioSpesaDTO, RipartizioneSpeseDTO> SetRipartizioneByMovimento(DettaglioSpesaDTO dettaglio, MovimentoContabileDTO movimento, EsercizioDTO esercizio, RipartizioneSpeseDTO ripartizioneDettaglio, Dictionary<DettaglioSpesaDTO, RipartizioneSpeseDTO> ripartizione)
{
var ripartizioneDettaglioNew = GetRipartizioneByMovimento(movimento, esercizio, ripartizioneDettaglio);
ripartizione[dettaglio] = ripartizioneDettaglioNew;
//if (_isMultiSpesa)
//{
// Dictionary<DettaglioSpesaDTO, RipartizioneSpeseDTO> newRipartizione = new Dictionary<DettaglioSpesaDTO, RipartizioneSpeseDTO>(ripartizione.Count);
// foreach (KeyValuePair<DettaglioSpesaDTO, RipartizioneSpeseDTO> kvp in ripartizione)
// {
// RipartizioneSpeseDTO riparto = ripartizioneDettaglioNew;
// if (kvp.Key != dettaglio)
// {
// // Duplico il flag di selezione
// if (kvp.Value != null)
// {
// string key = GetKey(movimento);
// if (kvp.Value.UnitaImmobiliari.ContainsKey(key))
// {
// List<UnitaImmobiliareSelectedDTO> listaUnita = kvp.Value.UnitaImmobiliari[key];
// foreach (UnitaImmobiliareSelectedDTO unita in listaUnita)
// {
// unita.Selezionato = getSelezionatoUnita(ripartizioneDettaglioNew.UnitaImmobiliari[key], unita.ID);
// unita.Stato = "U";
// }
// }
// }
// // Calcolo la ripartizione
// MovimentoContabileDTO movimentoClone = cloneMovimento(movimento, dettaglio.ImportoLordo.Value, kvp.Key.ImportoLordo.Value);
// if (movimentoClone.IdConto > 0)
// {
// riparto = GetRipartizioneByMovimento(movimentoClone, esercizio, kvp.Value);
// if (kvp.Value != null)
// {
// foreach (MovimentoContabileDTO movimentoDto in riparto.Testata.Movimenti)
// {
// if (isEqualMovimento(movimento, movimentoDto))
// {
// movimentoDto.Importo = movimentoClone.Importo;
// movimentoDto.IdConto = movimentoClone.IdConto;
// movimentoDto.IdSottoConto = movimentoClone.IdSottoConto;
// }
// }
// }
// }
// else
// {
// ILog _log = LogManager.GetLogger("Sfera");
// log4net.MDC.Set("user", Gipasoft.Security.Login.Instance.CurrentLogin().LoginName);
// log.Warn("ATTENZIONE: Trovato movimento senza conti definito - " + Gipasoft.Library.Utility.GetMethodDescription() + " - dettaglio:" + dettaglio.ID + " - esercizio:" + esercizio.ID);
// }
// }
// newRipartizione.Add(kvp.Key, riparto);
// kvp.Key.Movimenti = riparto.Testata.Movimenti;
// }
// ripartizione = newRipartizione;
//}
return ripartizione;
}
public bool Conferma()
{
var result = true;
btnConferma.Focus();
setValidators(true);
spesaValidationSummary.Validate();
if (spesaValidationSummary.IsValid)
{
// --------------------------------------------
// Controllo Data Registrazione
// --------------------------------------------
var messageDataList = getMovimentoContabileService().IsAllowDataRegistrazione(new List<int>(1) {_condominio.ID}, _esercizio.ID, dataRegistrazione.DateTime);
if(messageDataList.Count > 0)
{
var messageData = "La data di registrazione " + dataRegistrazione.DateTime + " non è ammessa:" + Environment.NewLine;
messageData = messageDataList.Aggregate(messageData, (current, mess) => current + (mess + Environment.NewLine));
CommonMessages.DisplayWarning(messageData);
return false;
}
// --------------------------------------------
// Controllo Data Scadenza se pagamento immediato
// --------------------------------------------
if (_pagamentoImmediato)
{
var messaggiDataPagamento = new List<string>();
foreach (var scadenzaFatturaDTO in _spesa.Scadenze)
{
if (scadenzaFatturaDTO != null)
{
var messageData = getMovimentoContabileService().IsAllowDataPagamento(_condominio.ID, scadenzaFatturaDTO.Scadenza.GetValueOrDefault());
if (!string.IsNullOrEmpty(messageData))
messaggiDataPagamento.Add(messageData);
}
}
if (messaggiDataPagamento.Count > 0)
{
var messageDataStr = messaggiDataPagamento.Aggregate(string.Empty, (current, mess) => current + (mess + Environment.NewLine));
CommonMessages.DisplayWarning(messageDataStr);
return false;
}
}
// --------------------------------------------
// Controllo sul numero fattura
// --------------------------------------------
var messageAuth = _fatturaService.IsAllowNumeroFattura(_spesa);
if (string.IsNullOrEmpty(messageAuth.FatalMessage))
{
var resultNumeroFattura = DialogResult.Yes;
if (!string.IsNullOrEmpty(messageAuth.WarnMessage))
resultNumeroFattura = CommonMessages.DisplayConfirm("ATTENZIONE il controllo sul numero fattura ha dato i seguenti risultati:" + Environment.NewLine + Environment.NewLine + messageAuth.WarnMessage + Environment.NewLine + Environment.NewLine + "Vuoi confermare l'inserimento della spesa?");
if (resultNumeroFattura == DialogResult.Yes)
{
RipartizioneSpeseDTO ripartizione;
if (importoDettaglioSpesa.Value != 0)
{
_spesa.AltreSpese = altreSpeseDettaglio.Value;
_spesa.AltreSpeseEsenti = altreSpeseEsenti.Value;
_spesa.SpeseEsentiRitenuta = speseEsentiRitenuta.Value;
_spesa.AliquotaRitenuta = (decimal?)aliquotaRitenuta.Value;
_spesa.AliquotaCassaProfessionisti = (decimal?)cassaProfessionistiDettaglio.Value;
_spesa.IsRitenutaCalcoloImponibile = ritenutaCalcolataImponibile.Checked;
ripartizione = getCurrentRipartizione();
if (_isInserimento && modelloRipartizione.Value == null && ripartizioneDettaglio.Rows.Count > 1 && (ripartizione == null || string.IsNullOrEmpty(getCurrentRipartizione().NomeModello)))
{
var form = new SalvataggioModelloRegistrazioneContabile((List<ModelloRegistrazioneContabileDTO>)modelliContabiliBindingSource.DataSource, modelloRipartizione.Text, descrizioneDettaglio.Text);
if (form.ShowDialog() != DialogResult.Cancel)
{
if (ripartizione == null)
{
ripartizione = new RipartizioneSpeseDTO
{
Testata = new TestataMovimentoContabileDTO {IdEsercizio = _esercizio.ID}
};
setCurrentRipartizione(ripartizione);
}
ripartizione.NomeModello = form.Nome;
ripartizione.DescrizioneVoceSpesa = form.DescrizioneVoceSpesa;
ripartizione.AssociatoFornitore = form.AssociatoFornitore;
}
form.Dispose();
}
// Se non sono ancora state caricate creo le scadenze
if (scadenze.Rows.Count == 0)
loadScadenzeTab();
}
// Salvo i valori a video nell'oggetto DTO
setDettaglioDataSource((DettaglioSpesaDTO)dettagliSpesa.ActiveTab.Tag, null);
_spesa.IdFornitore = sceltaFornitore.SelectedFornitore.ID;
_spesa.TipoDocumento = tipoDocumento.SelectedItem.DataValue.ToString();
_spesa.DataRegistrazione = dataRegistrazione.DateTime;
if (_spesaRiferimento != null)
_spesa.IdSpesaRiferimento = _spesaRiferimento.ID;
SpesaInfoDTO spesaInfo =null;
try
{
if (_spesa != null)
{
//spesaInfo = _fatturaService.Salva(_spesa, _ripartizione, getMovimentoContabileService().IsMultiSpesa);
var form = new ExecuteLoadDataObjectAsync<SpesaInfoDTO>("Salvataggio della fattura in corso ....." + Environment.NewLine + "Si prega di attendere.");
Func<SpesaInfoDTO> loadDati = () => _fatturaService.Salva(_spesa, _ripartizione, getMovimentoContabileService().IsMultiSpesa);
form.LoadData(loadDati);
form.ShowDialog();
spesaInfo = form.DataSourceObject;
form.Dispose();
}
}
catch (Exception ex)
{
_log.Error("Errore non previsto nell'inserimento della spesa - " + Utility.GetMethodDescription() + " - spesa:" + getIdSpesa().GetValueOrDefault(), ex);
spesaInfo = new SpesaInfoDTO { Message = "Errore imprevisto nell'inserimento della spesa" };
}
if (spesaInfo != null && string.IsNullOrEmpty(spesaInfo.Message))
{
_spesa.ID = spesaInfo.Id;
_spesa.DisplayName = _spesa.Dettagli[0].Descrizione;
if (_speseAccorpate && _isFirstSpesa && _spesaRiferimento == null)
{
_spesaRiferimento = _spesa;
_isFirstSpesa = false;
_fatturaService.SetSpesaRiferimento(_spesaRiferimento.ID, _spesaRiferimento.ID);
}
if (modelloFornitore.Checked)
getModelloContabileService().AssociaFornitore((ModelloRegistrazioneContabileDTO)modelloRipartizione.SelectedItem.ListObject, sceltaFornitore.SelectedFornitore);
// Se è stato richiesto il salvataggio del modello devo ricaricare la cache dei modelli
if (importoDettaglioSpesa.Value != 0)
{
ripartizione = getCurrentRipartizione();
if (!string.IsNullOrEmpty(ripartizione?.NomeModello))
getModelloContabileService().Reload(_esercizio);
}
if (_isInserimento)
CommonMessages.DisplayComplete("La spesa è stata correttamente inserita." + Environment.NewLine + "Sul documento deve essere riportato: " + spesaInfo.IdentificativoArchiviazione);
else
CommonMessages.DisplayComplete("La spesa è stata correttamente aggiornata." + Environment.NewLine + "Sul documento deve essere riportato: " + spesaInfo.IdentificativoArchiviazione);
Dirty = false;
OnConfirm(new ConfirmArgs(_spesa));
if (_formGestione == null || !_formGestione.IsDisposed)
{
if (_isInserimento)
Reload(_condominio, _esercizio);
Dirty = false;
}
}
else
{
if (spesaInfo != null)
CommonMessages.DisplayWarning("Si sono verificati dei problemi nell'aggiornamento della spesa:" + Environment.NewLine + spesaInfo.Message + Environment.NewLine + "Si prega di riprovare.");
result = false;
}
}
}
else
{
CommonMessages.DisplayWarning("Si sono verificati i seguenti errori nel controllo del numero di fattura:" + Environment.NewLine + messageAuth.FatalMessage + Environment.NewLine + "Si prega di riprovare.");
return false;
}
}
else
{
spesaValidationSummary.ShowErrorSummary();
result = false;
}
setValidators(false);
return result;
}
private void afterRowUpdate(UltraGridRow row)
{
var movimento = row.ListObject as MovimentoContabileDTO;
if (movimento != null && isRipartizioneDaCalcolare())
_ripartizione = getMovimentoContabileService().GetRipartizioneByMovimento(movimento, _esercizio, _ripartizione);
setDettaglioResiduo();
if (!_confirmByParent)
btnConferma.Visible = true;
btnRicevuta.Visible = true;
}
private void clearAllFields()
{
try
{
clearDettaglioFields();
_dataContabile = null;
_causale = null;
_ripartizione = null;
movimentoContabileBindingSource.DataSource = _movimentiDare = new List<MovimentoContabileDTO>();
_movimentoAvere = new MovimentoContabileDTO();
salvaModello.Checked = false;
salvaModello.Enabled = true;
sottoContoDTOBindingSource.DataSource = new List<SottoContoDTO>();
sottoContoPatrimoniale.Value = null;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore non previsto nella CLEAR della videata - {0} - movimento:{1}", ex, Utility.GetMethodDescription(), _movimentoAvere.ID);
throw;
}
}
private void backgroundWorkerLoadDatiRunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
_ripartizione = e.Result as RipartizioneSpeseDTO;
if (_esercizio != null && _esercizio.StatoEsercizio == StatoEsercizioEnum.Aperto)
{
btnRiparto.Enabled = true;
btnConferma.Enabled = true;
if(_formGestione != null)
_formGestione.SetEnableEdit(true);
}
}
private void setRipartizioneMovimento(MovimentoContabileDTO movimento)
{
try
{
if (movimento != null)
{
var key = getMovimentoContabileService().GetKey(movimento);
if (_ripartizione == null || !_ripartizione.UnitaImmobiliari.ContainsKey(key))
{
var form = new ExecuteLoadDataObjectAsync<RipartizioneSpeseDTO>("La funzione è in corso di esecuzione ....." + Environment.NewLine + "Si prega di attendere.");
Func<RipartizioneSpeseDTO> loadDati;
if (movimento.ID == 0)
loadDati = () => getMovimentoContabileService().GetRipartizioneByMovimento(movimento, _esercizio, _ripartizione);
else
loadDati = () => getMovimentoContabileService().GetRipartizioneByMovimentoEsistente(movimento, _esercizio, _ripartizione, null);
form.LoadData(loadDati);
form.ShowDialog();
_ripartizione = form.DataSourceObject;
form.Dispose();
if (_testata != null && _ripartizione != null)
_ripartizione.Testata.ID = _testata.ID;
else
{
if(_ripartizione == null)
_log.WarnFormat("DataSourceObject a NULL - {0} - movimento:{1}", Utility.GetMethodDescription(), movimento.ID);
}
}
}
}
catch (Exception ex)
{
var idMovimento = string.Empty;
if (movimento != null)
idMovimento = movimento.ID.ToString();
_log.ErrorFormat("Errore inaspettato nel set della ripartizione - {0} - movimento:{1}", ex, Utility.GetMethodDescription(), idMovimento);
}
}
private string getGruppiAddebito(RipartizioneSpeseDTO ripartizione, string key)
{
string gruppiAddebito = string.Empty;
// ==================================================================
// Controllo se la spesa è stata addebitata solo ad alcune scale
// ==================================================================
var gruppi = ripartizione.Gruppi[key];
var isGruppoPersonalizzato = (from g in gruppi
group g by g.Selezionato).Count() > 1;
if (isGruppoPersonalizzato)
{
for (var i = 0; i < gruppi.Length; i++)
{
if (gruppi[i].Selezionato)
gruppiAddebito += gruppi[i].ID + "&";
}
}
// ==================================================================
// Controllo se la spesa è stata addebitata solo ad alcuni stabili
// ==================================================================
if (!isGruppoPersonalizzato)
{
gruppiAddebito = string.Empty;
var stabili = ripartizione.Stabili[key];
var isStabilePersonalizzato = (from s in stabili
group s by s.Selezionato).Count() > 1;
//bool isStabilePersonalizzato = false;
//for (int i = 0; i < stabili.Length; i++)
//{
// if (!stabili[i].Selezionato)
// isStabilePersonalizzato = true;
//}
if (isStabilePersonalizzato)
{
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
for (var i = 0; i < stabili.Length; i++)
{
if (stabili[i].Selezionato)
{
var palazzina = daoFactory.GetPalazzinaDao().GetById(stabili[i].ID, false);
gruppiAddebito = palazzina.GruppiStabile.Aggregate(gruppiAddebito, (current, gruppo) => current + (gruppo.ID.ToString() + "&"));
}
}
}
else
gruppiAddebito = null;
}
gruppiAddebito = !string.IsNullOrEmpty(gruppiAddebito) ? gruppiAddebito.Substring(0, gruppiAddebito.Length - 1) : null;
return gruppiAddebito;
}
private void clearFlag(RipartizioneSpeseDTO ripartizione, string key)
{
// Lotti
if (ripartizione.Lotti.ContainsKey(key))
{
var listaLotti = ripartizione.Lotti[key];
foreach (var t in listaLotti)
t.Stato = string.Empty;
}
// Stabili
if (ripartizione.Stabili.ContainsKey(key))
{
var listaStabili = ripartizione.Stabili[key];
foreach (var t in listaStabili)
t.Stato = string.Empty;
}
// Gruppi
if (ripartizione.Gruppi.ContainsKey(key))
{
var listaGruppi = ripartizione.Gruppi[key];
foreach (var t in listaGruppi)
t.Stato = string.Empty;
}
// Unità
if (ripartizione.UnitaImmobiliari.ContainsKey(key))
{
var listaUnita = ripartizione.UnitaImmobiliari[key];
foreach (var t in listaUnita)
t.Stato = string.Empty;
}
}
private string getInstanceModificata(RipartizioneSpeseDTO ripartizione, string key)
{
// Lotti
if (ripartizione.Lotti.ContainsKey(key))
{
var listaLotti = ripartizione.Lotti[key];
if (listaLotti.Any(t => t.Stato == "U"))
return "L";
}
// Stabili
if (ripartizione.Stabili.ContainsKey(key))
{
var listaStabili = ripartizione.Stabili[key];
if (listaStabili.Any(t => t.Stato == "U"))
return "S";
}
// Gruppi
if (ripartizione.Gruppi.ContainsKey(key))
{
var listaGruppi = ripartizione.Gruppi[key];
if (listaGruppi.Any(t => t.Stato == "U"))
return "G";
}
// Unità
if (ripartizione.UnitaImmobiliari.ContainsKey(key))
{
BusinessInstanceSelectedDTO[] listaUnita = ripartizione.UnitaImmobiliari[key];
if (listaUnita.Any(t => t.Stato == "U"))
return "U";
}
return string.Empty;
}
public TipoFiltro GetTipoFiltroAttivo(MovimentoContabileDTO movimento, RipartizioneSpeseDTO ripartizione)
{
try
{
if (ripartizione != null)
{
if (movimento != null)
{
if (movimento.IdConto > 0)
{
int? idEsercizio = null;
if (ripartizione.Testata != null && ripartizione.Testata.IdEsercizio != null)
idEsercizio = ripartizione.Testata.IdEsercizio;
var conto = _pianoContiService.GetById(movimento.IdConto.GetValueOrDefault(), idEsercizio);
if (conto.IsSpesePersonali)
return TipoFiltro.UnitaImmobiliare;
}
}
if (movimento != null)
{
var key = GetKey(movimento);
if (ripartizione.Lotti.ContainsKey(key) && ripartizione.Lotti[key].Any(item => !item.Selezionato))
return TipoFiltro.Lotto;
if (ripartizione.Stabili.ContainsKey(key) && ripartizione.Stabili[key].Any(item => !item.Selezionato))
return TipoFiltro.Stabile;
if (ripartizione.Gruppi.ContainsKey(key) && ripartizione.Gruppi[key].Any(item => !item.Selezionato))
return TipoFiltro.Scala;
if (ripartizione.UnitaImmobiliari.ContainsKey(key) && ripartizione.UnitaImmobiliari[key].Any(item => !item.Selezionato))
return TipoFiltro.UnitaImmobiliare;
}
}
return TipoFiltro.Scala;
}
catch (Exception ex)
{
var log = LogManager.GetLogger("Sfera");
log.WarnFormat("Errore inaspettato nella lettura del filtro attivo - {0} - movimento:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), movimento != null ? movimento.ID.ToString(CultureInfo.InvariantCulture) : "<NULL>", Login.Instance.CurrentLogin().Azienda);
return TipoFiltro.Scala;
}
}
public SpesaInfoDTO Salva(RipartizioneSpeseDTO ripartizione, MovimentoContabileDTO movimentoAvere, List<MovimentoContabileDTO> movimentiDare, int? idMovimentoBancario)
{
if (ripartizione.Testata.ID > 0)
ripartizione.Testata.Stato = "U";
if (ripartizione.Testata.ID > 0 && ripartizione.UnitaImmobiliari != null)
{
foreach (var movimento in movimentiDare)
{
var key = GetKey(movimento);
if (movimento.DettaglioRipartizione != null && ripartizione.UnitaImmobiliari.ContainsKey(key))
{
movimento.DettaglioRipartizione.Clear();
foreach (var itemRipartizione in ripartizione.UnitaImmobiliari[key])
{
if (itemRipartizione.Selezionato)
{
movimento.DettaglioRipartizione.Add(new SpeseUnitaDTO
{
ID = 0,
IdMovimentoRiferimento = movimento.ID,
IdUnitaRiferimento = itemRipartizione.ID,
Importo = itemRipartizione.Importo
});
}
}
}
}
}
SpesaInfoDTO result;
try
{
result = GetServiceClient().SalvaMovimento(ripartizione, movimentoAvere, movimentiDare, idMovimentoBancario, GetUserInfo());
}
catch (Exception ex)
{
var log = LogManager.GetLogger("Sfera");
log.ErrorFormat("Errore inaspettato nella funzione - {0} - movimentoAvere:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), movimentoAvere.ID, Login.Instance.CurrentLogin().Azienda);
throw;
}
if (result.StampaEtichettaArchiviazione)
{
var workerStampaEtichetta = new BackgroundWorker();
workerStampaEtichetta.DoWork += workerStampaEtichettaDoWork;
workerStampaEtichetta.RunWorkerAsync(new object[] { result.IdentificativoArchiviazione, result.TrayEtichettatriceAttivazioneOttica });
}
CloseService();
return result;
}
public void SetSelezioneItemRiparto(TipoFiltro tipo, RipartizioneSpeseDTO ripart, BusinessInstanceSelectedDTO item, MovimentoContabileDTO movimento, Dictionary<DettaglioSpesaDTO, RipartizioneSpeseDTO> ripartizione)
{
try
{
if (movimento != null && ripart != null)
{
var key = GetKey(movimento);
// Se key è null o vuota vuol dire che il metdo è stato richiamato nell'evento cell update di una riga nuova: non deve essere fatto nulla
if (!string.IsNullOrEmpty(key))
{
if (item != null)
item.Stato = "U";
// Imposto come selezionati tutti gli altri filtri
switch (tipo)
{
case TipoFiltro.Scala:
if(ripart.Lotti != null && ripart.Lotti.ContainsKey(key))
resetItemFiltro(ripart.Lotti[key]);
if (ripart.Stabili != null && ripart.Stabili.ContainsKey(key))
resetItemFiltro(ripart.Stabili[key]);
break;
case TipoFiltro.Stabile:
if (ripart.Lotti != null && ripart.Lotti.ContainsKey(key))
resetItemFiltro(ripart.Lotti[key]);
if (ripart.Gruppi != null && ripart.Gruppi.ContainsKey(key))
resetItemFiltro(ripart.Gruppi[key]);
break;
case TipoFiltro.Lotto:
if (ripart.Stabili != null && ripart.Stabili.ContainsKey(key))
resetItemFiltro(ripart.Stabili[key]);
if (ripart.Gruppi != null && ripart.Gruppi.ContainsKey(key))
resetItemFiltro(ripart.Gruppi[key]);
break;
}
// Se multispesa tutti i filtri devono corrispondere
try
{
if (_isMultiSpesa && ripartizione != null)
{
foreach (var kvp in ripartizione)
{
try
{
kvp.Value.Gruppi = ripart.Gruppi;
kvp.Value.Lotti = ripart.Lotti;
kvp.Value.Stabili = ripart.Stabili;
kvp.Value.UnitaImmobiliari = ripart.UnitaImmobiliari;
}
catch (Exception ex)
{
var log = LogManager.GetLogger("Sfera");
log.Error("Errore inaspettato nella - MULTISPESA SINGOLO - " + Utility.GetMethodDescription() + " - tipo:" + tipo + " - azienda:" + Login.Instance.CurrentLogin().Azienda, ex);
throw;
}
}
}
}
catch (Exception ex)
{
var log = LogManager.GetLogger("Sfera");
log.Error("Errore inaspettato nella - MULTISPESA - " + Utility.GetMethodDescription() + " - tipo:" + tipo + " - azienda:" + Login.Instance.CurrentLogin().Azienda, ex);
throw;
}
}
}
}
catch (Exception ex)
{
var log = LogManager.GetLogger("Sfera");
log.Error("Errore inaspettato nella funzione - " + Utility.GetMethodDescription() + " - tipo:" + tipo + " - azienda:" + Login.Instance.CurrentLogin().Azienda, ex);
}
}
public ModelloRegistrazioneContabile SalvaModelloRipartizioneContabile(RipartizioneSpeseDTO ripartizione, IMovimentiContainer containerMovimenti, List<MovimentoContabileDTO> movimentiEconomici, decimal importo)
{
// Salvataggio modello
if ( !string.IsNullOrEmpty(ripartizione?.NomeModello))
{
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
var ripartizioneSpeseService = _windsorRepository.GetContainer(_info.Azienda).Resolve<IRipartizioneSpeseService>();
var esercizio = daoFactory.GetEsercizioDao().GetById(ripartizione.Testata.IdEsercizio.GetValueOrDefault(), false);
foreach (var movimento in movimentiEconomici)
{
if (ripartizione.UnitaImmobiliari != null)
{
var key = ripartizioneSpeseService.GetKey(movimento);
if (ripartizione.Lotti.ContainsKey(key) && getListaModificata(ripartizione.Lotti[key]))
ripartizioneSpeseService.SetLottiDataSource(key, ripartizione.Lotti[key]);
if (ripartizione.Stabili.ContainsKey(key) && getListaModificata(ripartizione.Stabili[key]))
ripartizioneSpeseService.SetStabiliDataSource(key, ripartizione.Stabili[key]);
if (ripartizione.Gruppi.ContainsKey(key) && getListaModificata(ripartizione.Gruppi[key]))
ripartizioneSpeseService.SetGruppiDataSource(key, ripartizione.Gruppi[key]);
if(ripartizione.UnitaImmobiliari.ContainsKey(key))
ripartizioneSpeseService.SetUnitaDataSource(key, ripartizione.UnitaImmobiliari[key]);
}
}
ISet<MovimentoContabile> movimenti = new HashSet<MovimentoContabile>();
foreach (var movimento in containerMovimenti.Movimenti.Where(movimento => movimento.IsEconomico()))
{
movimenti.Add(movimento);
}
var modello = ripartizioneSpeseService.CreateModelloRipartizione(esercizio.CondominioRiferimento.ID, movimenti, importo, ripartizione.NomeModello, ripartizione.DescrizioneVoceSpesa);
daoFactory.GetModelloRegistrazioneContabileDao().SaveOrUpdate(modello);
return modello;
}
return null;
}
private string getStabiliAddebito(RipartizioneSpeseDTO ripartizione, string key)
{
string stabiliAddebito = string.Empty;
// ==================================================================
// Controllo se la spesa è stata addebitata solo ad alcuni stabili
// ==================================================================
var stabili = ripartizione.Stabili[key];
var isStabilePersonalizzato = false;
foreach (var t in stabili)
{
if (!t.Selezionato)
isStabilePersonalizzato = true;
else
stabiliAddebito += t.ID + "&";
}
// ==================================================================
// Controllo se la spesa è stata addebitata solo ad alcuni lotti
// ==================================================================
if (!isStabilePersonalizzato)
{
var lotti = ripartizione.Stabili[key];
var isLottoPersonalizzato = false;
foreach (var t in lotti)
{
if (!t.Selezionato)
isLottoPersonalizzato = true;
}
if (isLottoPersonalizzato)
{
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
for (var i = 0; i < lotti.Length; i++)
{
if (lotti[i].Selezionato)
{
var esercizio = daoFactory.GetEsercizioDao().GetById(ripartizione.Testata.IdEsercizio.GetValueOrDefault(), false);
stabiliAddebito = esercizio.CondominioRiferimento.Palazzine.Aggregate(stabiliAddebito, (current, stabile) => current + (stabile.ID.ToString() + "&"));
}
}
}
else
stabiliAddebito = null;
}
stabiliAddebito = !string.IsNullOrEmpty(stabiliAddebito) ? stabiliAddebito.Substring(0, stabiliAddebito.Length - 1) : null;
return stabiliAddebito;
}
private void btnRipartoClick(object sender, EventArgs e)
{
if (ripartizioneDettaglio.ActiveRow != null)
{
var movimento = (MovimentoContabileDTO) ripartizioneDettaglio.ActiveRow.ListObject;
setRipartizioneMovimento(movimento);
var conto = getConto(ripartizioneDettaglio.ActiveRow.Cells["IdConto"]);
if (conto != null)
{
var readOnly = false;
if (ParentForm != null)
{
var updatableStandardForm = ParentForm as UpdatableStandardForm;
if (updatableStandardForm != null)
readOnly = !(updatableStandardForm).IsEditingMode;
}
var ripartizioneSave = ObjectCopier.CloneWcf(_ripartizione);
if(ripartizioneSave != null)
{
var form = getRipartizioneMovimentoUIService().GetRegistrazioneMovimento(ripartizioneSave, getMovimentoContabileService().GetKey(movimento), movimento, _esercizio, movimento.Importo.GetValueOrDefault(), readOnly);
if (form.ShowDialog() == DialogResult.OK)
{
_ripartizione = getRipartizioneMovimentoUIService().GetRipartizione();
if (getRipartizioneMovimentoUIService().IsDirty)
modelloRipartizione.Value = null;
}
form.Dispose();
}
else
{
_log.WarnFormat("ATTENZIONE: Ripartizione a NULL - {0}", Utility.GetMethodDescription());
}
}
}
else
CommonMessages.DisplayWarning("Per entrare nel riparto occorre scegliere un movimento.");
}
public RipartizioneSpeseDTO GetRipartizioneByMovimento(MovimentoContabileDTO movimento, int idEsercizio, RipartizioneSpeseDTO ripartizione)
{
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
var esercizio = daoFactory.GetEsercizioDao().Find(idEsercizio, false);
if(esercizio == null)
return new RipartizioneSpeseDTO();
var ripartizioneSpeseService = _windsorRepository.GetContainer(_info.Azienda).Resolve<IRipartizioneSpeseService>();
try
{
var key = ripartizioneSpeseService.GetKey(movimento);
string listaModificata;
var defaultSelezionato = true;
if (ripartizione != null)
{
listaModificata = getInstanceModificata(ripartizione, key);
clearFlag(ripartizione, key);
switch (listaModificata)
{
case "L":
ripartizioneSpeseService.SetLottiDataSource(key, ripartizione.Lotti[key]);
defaultSelezionato = false;
break;
case "S":
ripartizioneSpeseService.SetStabiliDataSource(key, ripartizione.Stabili[key]);
defaultSelezionato = false;
break;
case "G":
ripartizioneSpeseService.SetGruppiDataSource(key, ripartizione.Gruppi[key]);
defaultSelezionato = false;
break;
case "U":
ripartizioneSpeseService.SetUnitaDataSource(key, ripartizione.UnitaImmobiliari[key]);
defaultSelezionato = true;
break;
default:
if(ripartizione.UnitaImmobiliari.ContainsKey(key))
ripartizioneSpeseService.SetUnitaDataSource(key, ripartizione.UnitaImmobiliari[key]);
break;
}
}
else
{
ripartizione = new RipartizioneSpeseDTO
{
Testata = new TestataMovimentoContabileDTO
{
DataRegistrazione = DateTime.Today,
IdEsercizio = idEsercizio,
IsAbilitataArchiviazioneOttica = false
}
};
ripartizione.Testata.IsAbilitataArchiviazioneOttica = esercizio.CondominioRiferimento.IsAbilitataArchiviazioneOtticaPassivi ?? esercizio.CondominioRiferimento.Azienda.IsAbilitataArchiviazioneOtticaPassivi;
listaModificata = "X";
}
if (!ripartizione.UnitaImmobiliari.ContainsKey(key) || listaModificata != string.Empty)
{
if (movimento.IdConto == null)
{
_log.WarnFormat("ATTENZIONE: Trovato movimento con conto a null - {0} - movimento:{1} - esercizio:{2}", Library.Utility.GetMethodDescription(), movimento.ID, idEsercizio);
}
else
{
ripartizione.UnitaImmobiliari[key] = getListaUnitaDto(ripartizioneSpeseService.GetUnitaDataSource(key, movimento.IdConto, esercizio.CondominioRiferimento.ID, defaultSelezionato, esercizio, true), daoFactory.GetContoDao().GetById(movimento.IdConto.Value, false));
ripartizione.Lotti[key] = getListaDto(ripartizioneSpeseService.GetLottiDataSource(key, movimento.IdConto, esercizio.CondominioRiferimento.ID, null, defaultSelezionato));
ripartizione.Stabili[key] = getListaDto(ripartizioneSpeseService.GetStabiliDataSource(key, movimento.IdConto, esercizio.CondominioRiferimento.ID, null, defaultSelezionato));
ripartizione.Gruppi[key] = getListaDto(ripartizioneSpeseService.GetGruppiDataSource(key, movimento.IdConto, esercizio.CondominioRiferimento.ID, null, defaultSelezionato));
}
}
return ripartizione;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel caricamento delle ripartizioni spese - {0} - movimento:{1} - esercizio:{2}", ex, Library.Utility.GetMethodDescription(), movimento.ID, idEsercizio);
throw;
}
}
private RipartizioneSpeseDTO getRipartizione()
{
try
{
var ripartizione = new RipartizioneSpeseDTO { Testata = _testata };
if (ripartizione.Testata == null && _esercizio != null)
ripartizione.Testata = new TestataMovimentoContabileDTO { IdEsercizio = _esercizio.ID };
return ripartizione;
}
catch (Exception ex)
{
var idMovimento = string.Empty;
if (_movimentoAvere != null)
idMovimento = _movimentoAvere.ID.ToString();
var idEsercizio = string.Empty;
if (_esercizio != null)
idEsercizio = _esercizio.ID.ToString();
_log.Error("Errore inaspettato durante il get della ripartizione - " + Utility.GetMethodDescription() + " - movimento:" + idMovimento + " - esercizio:" + idEsercizio, ex);
throw;
}
}
private string getLottiAddebito(RipartizioneSpeseDTO ripartizione, string key)
{
var lottiAddebito = string.Empty;
// ==================================================================
// Controllo se la spesa è stata addebitata solo ad alcuni lotti
// ==================================================================
var lotti = ripartizione.Lotti[key];
var isLottoPersonalizzato = false;
foreach (var t in lotti)
{
if (!t.Selezionato)
isLottoPersonalizzato = true;
else
lottiAddebito += t.ID + "&";
}
if (isLottoPersonalizzato && !string.IsNullOrEmpty(lottiAddebito))
lottiAddebito = lottiAddebito.Substring(0, lottiAddebito.Length - 1);
else
lottiAddebito = null;
return lottiAddebito;
}
public int? ConfermaMovimento()
{
int? result = null;
if (_movimentoAvere != null)
{
try
{
movimentoValidationSummary.Validate();
if (movimentoValidationSummary.IsValid)
{
if (salvaModello.Checked)
{
try
{
var form = new SalvataggioModelloRegistrazioneContabile((List<ModelloRegistrazioneContabileDTO>)modelliContabiliBindingSource.DataSource, modelloRipartizione.Text);
if (form.ShowDialog() == DialogResult.Cancel)
return null;
if (_ripartizione == null)
_ripartizione = getRipartizione();
_ripartizione.NomeModello = form.Nome;
form.Dispose();
}
catch (Exception ex)
{
_log.ErrorFormat("Errore non previsto nel salvataggio del modello - {0} - movimento:{1}", ex, Utility.GetMethodDescription(), _movimentoAvere.ID);
}
}
_movimentoAvere.Importo = getImportoMovimento();
try
{
if (causale.SelectedItem != null && causale.SelectedItem.ListObject != null)
_movimentoAvere.Causale = (CausaleContabileDTO)causale.SelectedItem.ListObject;
else
{
_log.ErrorFormat("Causale non presente - {0} - movimento:{1}", Utility.GetMethodDescription(), _movimentoAvere.ID);
return null;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore non previsto nella impostazione della causale - {0} - movimento:{1}", ex, Utility.GetMethodDescription(), _movimentoAvere.ID);
throw;
}
try
{
if (contoPatrimoniale.Value != null)
_movimentoAvere.IdConto = (int)contoPatrimoniale.Value;
else
{
_log.ErrorFormat("Conto non presente - {0} - movimento:{1}", Utility.GetMethodDescription(), _movimentoAvere.ID);
return null;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore non previsto nella impostazione del conto patrimoniale - {0} - movimento:{1}", ex, Utility.GetMethodDescription(), _movimentoAvere.ID);
throw;
}
if (sottoContoPatrimoniale.Value != null)
_movimentoAvere.IdSottoConto = (int) sottoContoPatrimoniale.Value;
if (_ripartizione == null)
_ripartizione = getRipartizione();
if (_ripartizione.Testata != null)
{
try
{
var idEsercizio = esercizi.Value as int?;
var condominio = sceltaCondominioCombo1.CondominioSelected;
if (condominio.Esercizi.Any(item => item.ID == idEsercizio.GetValueOrDefault()))
{
_ripartizione.Testata.IsAbilitataArchiviazioneOttica = archiviazioneOttica.Checked;
_ripartizione.Testata.DataRegistrazione = dataRegistrazione.DateTime;
_ripartizione.Testata.Note = noteDettaglio.Text;
_ripartizione.Testata.IdEsercizio = esercizi.Value as int?;
if (modelloRipartizione.Value != null)
_ripartizione.Testata.IdModelloRipartizione = (int)modelloRipartizione.Value;
_ripartizione.Testata.DataInizioCompetenza = null;
_ripartizione.Testata.DataFineCompetenza = null;
if (dataInizioCompetenza.Value != null)
_ripartizione.Testata.DataInizioCompetenza = dataInizioCompetenza.DateTime;
if (dataFineCompetenza.Value != null)
_ripartizione.Testata.DataFineCompetenza = dataFineCompetenza.DateTime;
}
else
{
_log.FatalFormat("ATTENZIONE: Esercizio del movimento contabile non presente nel condominio selezionato - {0} - movimento:{1} - esercizio:{2} - condominio:{3} - azienda:{4}", Utility.GetMethodDescription(), _movimentoAvere?.ID.ToString(), idEsercizio, sceltaCondominioCombo1.CondominioSelected.ID, Login.Instance.CurrentLogin().Azienda);
CommonMessages.DisplayWarning("Il movimento non può essere aggiornato, si prega di riprovare");
ParentForm?.Close();
return null;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore non previsto nella impostazione dei dati di testata - {0} - movimento:{1}", ex, Utility.GetMethodDescription(), _movimentoAvere.ID);
throw;
}
}
else
{
_log.ErrorFormat("TESTATA non presente - {0} - movimento:{1}", Utility.GetMethodDescription(), _movimentoAvere.ID);
return null;
}
_ripartizione.Descrizione = descrizioneDettaglio.Text;
try
{
if (sceltaFornitoreCombo1.Visible && sceltaFornitoreCombo1.SelectedFornitore != null)
_movimentoAvere.IdFornitore = sceltaFornitoreCombo1.SelectedFornitore.ID;
else if (sceltaFornitoreSottocontoCombo.Visible && sceltaFornitoreSottocontoCombo.SelectedFornitore != null)
_movimentoAvere.IdFornitore = sceltaFornitoreSottocontoCombo.SelectedFornitore.ID;
else
_movimentoAvere.IdFornitore = null;
foreach (var movimento in _movimentiDare)
movimento.IdFornitore = _movimentoAvere.IdFornitore;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore non previsto nella impostazione dei dati del fornitore - {0} - movimento:{1}", ex, Utility.GetMethodDescription(), _movimentoAvere.ID);
throw;
}
SpesaInfoDTO info;
try
{
// Controllo aggiuntivo per bugid#8602
if ((_ripartizione.Testata.ID == 0 || _ripartizione.Testata.Stato == "I") && !_isInserimento)
{
_log.FatalFormat("ATTENZIONE: Possibilità di movimento doppio - {0} - movimento:{1} - azienda:{2}", Utility.GetMethodDescription(), _movimentoAvere?.ID.ToString() ?? "<NULL>", Login.Instance.CurrentLogin().Azienda);
CommonMessages.DisplayWarning("Il movimento non può essere aggiornato, si prega di riprovare");
ParentForm?.Close();
return null;
}
else
{
info = getMovimentoContabileService().Salva(_ripartizione, _movimentoAvere, _movimentiDare, _idMovimentoBancario);
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore non previsto nell'inserimento del movimento economico - {0} - movimento:{1}", ex, Utility.GetMethodDescription(), _movimentoAvere.ID);
info = new SpesaInfoDTO {Message = "Errore imprevisto nell'inserimento del movimento"};
}
if (string.IsNullOrEmpty(info.Message))
{
try
{
_movimentoAvere.ID = info.Id;
result = info.Id;
CommonMessages.DisplayComplete("Il movimento contabile è stato correttamente inserito." + Environment.NewLine + "Sul documento deve essere riportato: " + info.IdentificativoArchiviazione);
OnAfterUpdate(_ripartizione.Testata != null ? new AfterUpdateArgs(_ripartizione.Testata.ID) : new AfterUpdateArgs(0));
_movimentoResult = _movimentoAvere;
if (salvaModello.Checked)
{
try
{
getModelloContabileService().Reload(_esercizio);
modelliContabiliBindingSource.DataSource = getModelloContabileService().GetByEsercizio(_esercizio);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore non previsto nel CARICAMENTO DEL DATASOURCE DEL MODELLO - {0} - movimento:{1}", ex, Utility.GetMethodDescription(), _movimentoAvere.ID);
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore non previsto nel FEEDBACK della conferma del movimento - {0} - movimento:{1}", ex, Utility.GetMethodDescription(), _movimentoAvere.ID);
throw;
}
clearAllFields();
}
else
CommonMessages.DisplayWarning("Si sono verificati dei problemi nell'aggiornamento del movimento:" + Environment.NewLine + info.Message + Environment.NewLine + "Si prega di riprovare.");
}
else
movimentoValidationSummary.ShowErrorSummary();
}
catch (Exception ex)
{
_log.ErrorFormat("Errore non previsto nella conferma del movimento - {0} - movimento:{1}", ex, Utility.GetMethodDescription(), _movimentoAvere.ID);
}
}
return result;
}
public RipartizioneSpeseDTO GetRipartizioneByMovimentiEsistenti(IList<MovimentoContabileDTO> movimentoDto, int idEsercizio, RipartizioneSpeseDTO ripartizione)
{
return movimentoDto.Aggregate(ripartizione, (current, movimentoContabileDTO) => GetRipartizioneByMovimentoEsistente(movimentoContabileDTO, idEsercizio, current));
}
private void modelloRipartizioneSelectionChanged(object sender, EventArgs e)
{
try
{
// Se non ho scelto la causale non posso applicare il modello
if (causale.Value == null)
{
modelloRipartizione.SelectionChanged -= modelloRipartizioneSelectionChanged;
modelloRipartizione.Value = null;
modelloRipartizione.SelectionChanged += modelloRipartizioneSelectionChanged;
}
else
_causale = (CausaleContabileDTO)causale.SelectedItem.ListObject;
if (modelloRipartizione.Value != null && modelloRipartizione.Value != DBNull.Value)
{
TestataMovimentoContabileDTO testata = null;
if (_ripartizione != null)
testata = _ripartizione.Testata;
_ripartizione = getMovimentoContabileService().GetRipartizioneByModello(_esercizio.ID, testata, (int)modelloRipartizione.Value, _causale.ID, getImportoMovimento(), _tipoMovimento);
_testata = _ripartizione.Testata;
// -------------------------------------------------------------------------
// Se siamo in inserimento prendo tutti i movimenti ...
// ... altrimenti devo scartare quelli "avere"
// ------------------------------------------------------------------------
_movimentiDare = _isInserimento ? _ripartizione.Testata.Movimenti : getMovimentoContabileService().GetMovimentiLista(_ripartizione.Testata);
movimentoContabileBindingSource.DataSource = _movimentiDare;
// Gruppo soggetti
if(ripartizioneDettaglio.Rows.Count > 0)
ripartizioneDettaglio.ActiveRow = ripartizioneDettaglio.Rows[0];
foreach (var row in ripartizioneDettaglio.Rows)
setSottoContoValueList(row);
if (!_confirmByParent)
btnConferma.Visible = true;
btnRicevuta.Visible = true;
salvaModello.Enabled = false;
salvaModello.Checked = false;
setDettaglioResiduo();
}
else
{
if (_ripartizione != null && _ripartizione.Testata != null)
_ripartizione.Testata.IdModelloRipartizione = null;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella scelta del modello - {0} - modello:{1} - testata:{2} - esercizio:{3} - formGestione:{4}", ex, Utility.GetMethodDescription(), modelloRipartizione.Value, _testata != null ? _testata.ID.ToString() : "<NULL>", _esercizio != null ? _esercizio.ID.ToString() : "<NULL>", _formGestione != null ? _formGestione.Name : "<NULL>");
}
}
public RipartizioneSpeseDTO GetRipartizioneByMovimentoEsistente(MovimentoContabileDTO movimentoDto, int idEsercizio, RipartizioneSpeseDTO ripartizione, int? idContoDetrazione = null)
{
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
var esercizio = daoFactory.GetEsercizioDao().GetById(idEsercizio, false);
var ripartizioneSpeseService = _windsorRepository.GetContainer(_info.Azienda).Resolve<IRipartizioneSpeseService>();
var repTestata = new TestataMovimentoContabileRepository(_info, _windsorRepository, null);
IRipartizioneSpesa movimento = null;
if (movimentoDto.Stato == "RIPARTIZIONE")
movimento = daoFactory.GetRipartizioneSpesaDao().Find(movimentoDto.ID, false);
else
movimento = daoFactory.GetMovimentoContabileDao().Find(movimentoDto.ID, false);
var movimentoContabile = movimento as MovimentoContabile;
if(movimento != null)
{
try
{
var key = ripartizioneSpeseService.GetKey(movimentoDto);
if (ripartizione == null)
ripartizione = new RipartizioneSpeseDTO();
if (movimentoContabile != null)
{
key = ripartizioneSpeseService.GetKey(movimentoContabile);
if (movimentoContabile.Testata != null)
ripartizione.Testata = repTestata.GetByDomainEntity(movimentoContabile.Testata);
}
else if (movimentoDto.Stato != "RIPARTIZIONE")
{
_log.ErrorFormat("Trovato movimento contabile senza testata associata - {0} - id:{1}", Library.Utility.GetMethodDescription(), movimento.ID);
}
// -----------------------------------------------
// Recupero eventuali filtri di selezione
// -----------------------------------------------
// Gruppi
int[] gruppiSelezionati = null;
if (!string.IsNullOrEmpty(movimento.GruppiAddebito))
{
var gruppiAddebito = movimento.GruppiAddebito.Split('&');
gruppiSelezionati = new int[gruppiAddebito.Length];
for (var i = 0; i < gruppiAddebito.Length; i++)
{
if (!string.IsNullOrEmpty(gruppiAddebito[i]))
gruppiSelezionati[i] = int.Parse(gruppiAddebito[i]);
}
}
// Lotti
int[] lottiSelezionati = null;
if (!string.IsNullOrEmpty(movimento.LottiAddebito))
{
string[] lottiAddebito = movimento.LottiAddebito.Split('&');
lottiSelezionati = new int[lottiAddebito.Length];
for (var i = 0; i < lottiAddebito.Length; i++)
{
if (!string.IsNullOrEmpty(lottiAddebito[i]))
lottiSelezionati[i] = int.Parse(lottiAddebito[i]);
}
}
// Stabili
int[] stabiliSelezionati = null;
if (!string.IsNullOrEmpty(movimento.StabiliAddebito))
{
var stabiliAddebito = movimento.StabiliAddebito.Split('&');
stabiliSelezionati = new int[stabiliAddebito.Length];
for (var i = 0; i < stabiliAddebito.Length; i++)
{
if (!string.IsNullOrEmpty(stabiliAddebito[i]))
stabiliSelezionati[i] = int.Parse(stabiliAddebito[i]);
}
}
if (movimentoContabile == null || movimentoContabile.Testata != null)
{
var conto = daoFactory.GetContoDao().Find(movimentoDto.IdConto.GetValueOrDefault(), false);
if (conto != null)
{
Conto contoDetrazione = null;
if (idContoDetrazione != null)
{
contoDetrazione = daoFactory.GetContoDao().Find(idContoDetrazione.GetValueOrDefault(), false);
conto = contoDetrazione;
}
ripartizione.UnitaImmobiliari[key] = getListaUnitaDto(ripartizioneSpeseService.GetUnitaDataSourceByMovimento(key, movimento, contoDetrazione), conto);
ripartizione.Lotti[key] = getListaDto(ripartizioneSpeseService.GetLottiDataSource(key, movimentoDto.IdConto, esercizio.CondominioRiferimento.ID, lottiSelezionati));
ripartizione.Stabili[key] = getListaDto(ripartizioneSpeseService.GetStabiliDataSource(key, movimentoDto.IdConto, esercizio.CondominioRiferimento.ID, stabiliSelezionati));
ripartizione.Gruppi[key] = getListaDto(ripartizioneSpeseService.GetGruppiDataSource(key, movimentoDto.IdConto, esercizio.CondominioRiferimento.ID, gruppiSelezionati));
}
}
return ripartizione;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel caricamento delle ripartizioni spese - {0}", ex, Library.Utility.GetMethodDescription());
throw;
}
}
return ripartizione;
}
public Form GetRegistrazioneMovimento(RipartizioneSpeseDTO ripartizione, string key, MovimentoContabileDTO movimentoContabileDTO, EsercizioDTO esercizioDTO, decimal importo, bool readOnly)
{
_form = new RipartizioneMovimentoUI(ripartizione, key, movimentoContabileDTO, esercizioDTO, importo, readOnly);
return _form;
}
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;
}
}
private void setCurrentRipartizione(RipartizioneSpeseDTO ripartizione)
{
_ripartizione[(DettaglioSpesaDTO)dettagliSpesa.SelectedTab.Tag] = ripartizione;
}
public SpesaInfoDTO SalvaMovimento(RipartizioneSpeseDTO ripartizione, MovimentoContabileDTO movimentoAvere, List<MovimentoContabileDTO> movimentiDare, int? idMovimentoBancario)
{
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
var movimentoContabileService = _windsorRepository.GetContainer(_info.Azienda).Resolve<IMovimentiContabiliService>();
var ripartizioneSpeseService = _windsorRepository.GetContainer(_info.Azienda).Resolve<IRipartizioneSpeseService>();
var protocolloService = _windsorRepository.GetContainer(_info.Azienda).Resolve<IProtocolloService>();
var archiviazioneService = _windsorRepository.GetContainer(_info.Azienda).Resolve<IArchiviazioneOtticaService>();
var persistenceContextService = _windsorRepository.GetContainer(_info.Azienda).Resolve<Data.IPersistenceContext>();
var index = 0;
movimentoAvere.NumeroRiga = index+1;
movimentoAvere.Descrizione = ripartizione.Descrizione;
if (movimentoAvere.Importo > 0)
movimentoAvere.Segno = "A";
else
{
movimentoAvere.Segno = "D";
movimentoAvere.Importo = movimentoAvere.Importo * -1;
}
int? idEsercizio = null;
try
{
var esercizio = daoFactory.GetEsercizioDao().GetById(ripartizione.Testata.IdEsercizio.GetValueOrDefault(), true);
if (esercizio.Stato == StatoEsercizioEnum.Aperto)
{
idEsercizio = esercizio.ID;
var numeroRegistrazione = esercizio.ProgressivoRegistrazioneContabile;
ripartizione.Testata.Movimenti = new MovimentoContabileDTO[movimentiDare.Count + 1];
ripartizione.Testata.Movimenti[0] = movimentoAvere;
numeroRegistrazione++;
movimentoAvere.NumeroRegistrazione = numeroRegistrazione;
// Salvo eventuali valori del movimento patrimoniale originale
if(movimentoAvere.ID > 0)
{
var movimento = daoFactory.GetMovimentoContabileDao().Find(movimentoAvere.ID, false);
if (movimento?.EvasioneBancaria != null)
movimentoAvere.IdEvasione = movimento.EvasioneBancaria.ID;
}
if (!(ripartizione.Testata.IdModelloRipartizione > 0))
{
foreach (var movimentoEconomico in movimentiDare)
{
index++;
numeroRegistrazione++;
if (movimentoEconomico.Importo < 0)
{
movimentoEconomico.Importo = movimentoEconomico.Importo*-1;
movimentoEconomico.Segno = "A";
}
else
movimentoEconomico.Segno = "D";
movimentoEconomico.IsMovimentoEconomico = true;
movimentoEconomico.NumeroRegistrazione = numeroRegistrazione;
movimentoEconomico.Causale = movimentoAvere.Causale;
movimentoEconomico.IdFornitore = movimentoAvere.IdFornitore;
if (string.IsNullOrEmpty(movimentoEconomico.Descrizione) && !esercizio.CondominioRiferimento.DescrizioneSpeseAutomatica)
movimentoEconomico.Descrizione = ripartizione.Descrizione;
movimentoEconomico.IdTestata = ripartizione.Testata.ID;
ripartizione.Testata.Movimenti[index] = movimentoEconomico;
// ---------------------------------------------------------------------
// Aggiorno addebiti per lotto, stabile o scala
// ---------------------------------------------------------------------
var spesePersonali = false;
if (movimentoEconomico.ID > 0)
{
var movimento = daoFactory.GetMovimentoContabileDao().Find(movimentoEconomico.ID, false);
if (movimento != null)
{
movimentoEconomico.LottiAddebito = movimento.LottiAddebito;
movimentoEconomico.StabiliAddebito = movimento.StabiliAddebito;
movimentoEconomico.GruppiAddebito = movimento.GruppiAddebito;
spesePersonali = movimento.ContoRiferimento.IsSpesePersonali;
}
}
// ---------------------------------------------------------------------
// Verifico se è stata eseguita una ripartizione personalizzata
// ---------------------------------------------------------------------
var key = ripartizioneSpeseService.GetKey(movimentoEconomico);
movimentoEconomico.IsRipartoPersonalizzato = false;
// Lasciare la valorizzazione di NumeroRiga DOPO il GetKey altrimenti la chiave NON viene trovata per i movimenti con più di 1 conto economico
movimentoEconomico.NumeroRiga = index + 1;
if (ripartizione.UnitaImmobiliari != null && ripartizione.UnitaImmobiliari.ContainsKey(key))
{
movimentoEconomico.LottiAddebito = getLottiAddebito(ripartizione, key);
movimentoEconomico.StabiliAddebito = getStabiliAddebito(ripartizione, key);
movimentoEconomico.GruppiAddebito = getGruppiAddebito(ripartizione, key);
var unita = ripartizione.UnitaImmobiliari[key];
var isPersonalizzato = unita.Count(item => item.Selezionato) < unita.Length;
// Considero il movimento come ripartito personalmente se non sono presenti specifici riparti per lotto, stabile o scala e non si tratta di un conto di spese personali
if (isPersonalizzato && !spesePersonali && string.IsNullOrEmpty(movimentoEconomico.LottiAddebito) && string.IsNullOrEmpty(movimentoEconomico.StabiliAddebito) && string.IsNullOrEmpty(movimentoEconomico.GruppiAddebito))
movimentoEconomico.IsRipartoPersonalizzato = true;
var conto = daoFactory.GetContoDao().GetById(movimentoEconomico.IdConto.Value, false);
if (conto.IsSpesePersonali || movimentoEconomico.IsRipartoPersonalizzato)
{
movimentoEconomico.DettaglioRipartizione = new SpeseUnitaDTO[unita.Length];
// -----------------------------------------------------------
// Per le unità ricalcolo gli importi
// -----------------------------------------------------------
var instanceModificata = getInstanceModificata(ripartizione, key);
if (!string.IsNullOrEmpty(instanceModificata) && instanceModificata != "U")
GetRipartizioneByMovimento(movimentoEconomico, esercizio.ID, ripartizione);
else
{
movimentoEconomico.DettaglioRipartizione = new SpeseUnitaDTO[movimentoEconomico.DettaglioRipartizione.Length];
var unitaSelected = ripartizione.UnitaImmobiliari[key];
for (var i = 0; i < unitaSelected.Length; i++)
{
if (unitaSelected[i].Selezionato)
{
var spesaUnitaDto = new SpeseUnitaDTO { ID = 0, IdMovimentoRiferimento = movimentoEconomico.ID, Importo = unitaSelected[i].Importo };
if (unitaSelected[i].IdSoggettoCondominio > 0)
spesaUnitaDto.IdSoggetto = unitaSelected[i].IdSoggettoCondominio;
else
spesaUnitaDto.IdUnitaRiferimento = unitaSelected[i].ID;
movimentoEconomico.DettaglioRipartizione[i] = spesaUnitaDto;
}
}
}
}
}
}
}
// -------------------------------------------
// Elimino vecchia testata
// -------------------------------------------
int? oldProtocollo = null;
int? oldAnnoArchiviazione = null;
var oldTipoTestata = TipoTestataMovimentoContabileEnum.Undefined;
AddebitoCompetenza addebito = null;
var testataOld = daoFactory.GetTestataMovimentoContabileDao().Find(ripartizione.Testata.ID, false);
if (testataOld != null)
{
if (testataOld.AddebitoCompetenze.Count > 0)
addebito = Library.IesiGenericCollections<AddebitoCompetenza>.GetByIndex(testataOld.AddebitoCompetenze, 0);
oldProtocollo = testataOld.NumeroProtocollo;
oldAnnoArchiviazione = testataOld.AnnoArchiviazioneOttica;
testataOld.EsercizioRiferimento = null;
// ------------------------------------------------------------------------
// Nel caso si tratti di un movimento generato automaticamente dalla procedura solleciti
// elimino la relazione tra sollecito e movimento contabile.
// Solo per le vecchie versioni di addebito competenze solleciti
// ------------------------------------------------------------------------
if (testataOld.Tipo == TipoTestataMovimentoContabileEnum.Automatica)
{
oldTipoTestata = testataOld.Tipo;
// per impostare correttamente la descrizione della testata
movimentoAvere.Descrizione = testataOld.Descrizione;
var solleciti = daoFactory.GetSollecitoDao().GetByTestataMovimentoContabile(testataOld.ID);
foreach (var sollecito in solleciti)
sollecito.MovimentoEconomico = null;
ripartizione.Testata.Tipo = testataOld.Tipo;
}
daoFactory.GetTestataMovimentoContabileDao().Delete(testataOld);
ripartizione.Testata.ID = 0;
foreach (var movDto in ripartizione.Testata.Movimenti)
{
if (movDto != null)
movDto.ID = 0;
}
}
// -------------------------------------------
// Creo nuova testata
// -------------------------------------------
var rep = new TestataMovimentoContabileRepository(_info, _windsorRepository, null);
var testata = rep.ManageDomainEntity(ripartizione.Testata);
if (testata == null || movimentoAvere == null)
{
if (testata == null)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio (UPDATE) del movimento - TESTATA NULL - {0} - esercizio:{1} - azienda:{2}", Library.Utility.GetMethodDescription(), idEsercizio.GetValueOrDefault(), _info.Azienda);
persistenceContextService.RollbackAndCloseSession(Security.Login.Instance.CurrentLogin().LoginName);
persistenceContextService.BeginTransaction(Security.Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new SpesaInfoDTO { Id = 0, NumeroProtocollo = 0, IdentificativoArchiviazione = null, StampaEtichettaArchiviazione = false, Message = "Errore inaspettato nel salvataggio del movimento, si prega di riprovare." };
}
if (movimentoAvere == null)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio (UPDATE) del movimento - MOVIMENTO AVERE NULL - {0} - esercizio:{1} - azienda:{2}", Library.Utility.GetMethodDescription(), idEsercizio.GetValueOrDefault(), _info.Azienda);
persistenceContextService.RollbackAndCloseSession(Security.Login.Instance.CurrentLogin().LoginName);
persistenceContextService.BeginTransaction(Security.Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new SpesaInfoDTO { Id = 0, NumeroProtocollo = 0, IdentificativoArchiviazione = null, StampaEtichettaArchiviazione = false, Message = "Errore inaspettato nel salvataggio del movimento, si prega di riprovare." };
}
}
testata.Descrizione = movimentoAvere.Descrizione;
if (oldProtocollo != null)
testata.NumeroProtocollo = oldProtocollo;
if (oldAnnoArchiviazione != null)
testata.AnnoArchiviazioneOttica = oldAnnoArchiviazione;
if (oldTipoTestata != TipoTestataMovimentoContabileEnum.Undefined)
testata.Tipo = oldTipoTestata;
// Aggiorno eventuali addebiti di competenze esistenti
if (addebito != null)
{
addebito.TestataMovimento = testata;
IList<MovimentoContabile> movimentiEconomici = testata.Movimenti.Where(item => item.IsEconomico()).ToList();
IList<DettaglioAddebitoCompetenza> dettagliAddebito = addebito.Dettaglio.ToList();
if (movimentiEconomici.Count == dettagliAddebito.Count)
{
for (var i = 0; i < dettagliAddebito.Count; i++)
dettagliAddebito[i].MovimentoContabile = movimentiEconomici[i];
}
else
{
throw new InvalidDataException("Non è possibile aggiornare direttamente un movimento contabile generato da un addebito di competenze");
//foreach (var dettaglioAddebito in addebito.Dettaglio)
// dettaglioAddebito.MovimentoContabile = null;
}
}
// ======================================================================================
// Evasione Movimenti
// ======================================================================================
if (idMovimentoBancario != null)
{
IList<MovimentoContabile> movimentiContabili = (from movimento in testata.Movimenti where !movimento.IsEconomico() select movimento).ToList();
IList<int> idMovimentiBancari = new List<int> {idMovimentoBancario.GetValueOrDefault()};
movimentoContabileService.EvadiMovimento($"Evasione automatica registrazione movimento contabile del {ripartizione.Testata.DataRegistrazione.GetValueOrDefault():d}", movimentiContabili, idMovimentiBancari, null, null);
}
// =====================================================================================================
// Se presente applico il modello di ripartizione, altrimenti ricalcolo valori o l'intera ripartizione
// =====================================================================================================
if (ripartizione.Testata.IdModelloRipartizione > 0)
{
var tipo = TipoMovimentoEnum.Spesa;
if (movimentoAvere.Segno == "D")
tipo = TipoMovimentoEnum.Accredito;
// NON VIENE PIù RICALCOLATA LE RIPARTIZIONE, SARA' CALCOLATA IN FASE DI BILANCIO
ripartizioneSpeseService.ApplyModello(testata, ripartizione.Testata.IdModelloRipartizione.Value, movimentoAvere.Importo.Value, tipo, false);
// Ripristino le descrizioni precedenti se presenti
foreach (var dto in movimentiDare)
{
if (!string.IsNullOrEmpty(dto.Descrizione))
{
var movimento = (from item in testata.Movimenti
where item.NumeroRiga == dto.NumeroRiga
select item).SingleOrDefault();
if (movimento != null)
movimento.Descrizione = dto.Descrizione;
}
}
}
else
{
// Salvataggio modello
testata.ModelloRipartizione = SalvaModelloRipartizioneContabile(ripartizione, testata, movimentiDare, movimentoAvere.Importo.Value);
}
// =====================================================================================================
// Salvataggio progressivo registrazione
// =====================================================================================================
esercizio.ProgressivoRegistrazioneContabile = numeroRegistrazione;
// =====================================================================================================
// Registrazione dell'eventuale arrotondamento
// =====================================================================================================
if (testata.Movimenti.FirstOrDefault() != null)
movimentoContabileService.SetMovimentoArrotondamento(null, testata, testata.Movimenti.FirstOrDefault().Causale, null);
// ======================================================================================
// Recupero il numero di protocollo e l'identificativo di archiviazione
// ======================================================================================
int protocollo;
if (testata.NumeroProtocollo.GetValueOrDefault() == 0)
{
{
var progressivo = protocolloService.GetProgressivo(TipoProtocollo.Fattura,
esercizio.DataApertura.GetValueOrDefault().Year,
testata.EsercizioRiferimento.CondominioRiferimento);
if (progressivo.Progressivo != null)
{
protocollo = progressivo.Progressivo.Value;
testata.NumeroProtocollo = protocollo;
testata.AnnoArchiviazioneOttica = esercizio.DataApertura.GetValueOrDefault().Year;
}
else
return new SpesaInfoDTO
{
Id = 0,
IdentificativoArchiviazione = null,
NumeroProtocollo = 0,
StampaEtichettaArchiviazione = false,
Message = progressivo.Message
};
}
}
else
{
protocollo = testata.NumeroProtocollo.Value;
}
var identificativoArchiviazione = archiviazioneService.GetIdentificativoArchiviazione(testata);
var movimentoPatrimoniale = (from item in testata.Movimenti
where item.NumeroRiga == movimentoAvere.NumeroRiga
select item).FirstOrDefault();
var idMovimentoPatrimoniale = 0;
if (movimentoPatrimoniale != null)
idMovimentoPatrimoniale = movimentoPatrimoniale.ID;
var impostazioni = daoFactory.GetImpostazioniAziendaDao().GetByAzienda(esercizio.CondominioRiferimento.Azienda.ID);
if (impostazioni == null)
{
impostazioni = new ImpostazioniAzienda(daoFactory.GetAziendaDao().GetById(esercizio.CondominioRiferimento.Azienda.ID, false));
daoFactory.GetImpostazioniAziendaDao().SaveOrUpdate(impostazioni);
}
var stampaEtichetta = false;
var etichettatrice = string.Empty;
var tipoEichetta = "Testo";
int? trayEtichettatriceAttivazioneOttica = null;
if (impostazioni != null)
{
stampaEtichetta = impostazioni.UtilizzoEtichettatriceArchiviazioneOtticaMovimenti && testata.IsAbilitataArchiviazioneOttica;
etichettatrice = impostazioni.EtichettatriceArchiviazioneOttica;
tipoEichetta = impostazioni.TipoEtichettaArchiviazioneOttica;
trayEtichettatriceAttivazioneOttica = impostazioni.TrayEtichettatriceAttivazioneOttica;
}
return new SpesaInfoDTO
{
Id = idMovimentoPatrimoniale,
NumeroProtocollo = testata.NumeroProtocollo.Value,
IdentificativoArchiviazione = identificativoArchiviazione,
StampaEtichettaArchiviazione = stampaEtichetta,
EtichettatriceArchiviazione = etichettatrice,
TipoEtichettaArchiviazione = tipoEichetta,
TrayEtichettatriceAttivazioneOttica = trayEtichettatriceAttivazioneOttica
};
}
return new SpesaInfoDTO
{
Id = 0,
NumeroProtocollo = 0,
IdentificativoArchiviazione = null,
StampaEtichettaArchiviazione = false,
Message = "La registrazione non è possibile perchè relativo ad un esercizio chiuso."
};
}
catch (Exception ex)
{
var message = ex.ToString().StartsWith("NHibernate.StaleObjectStateException") ? "Un altro utente ha confermato un movimento." : "Errore inaspettato nell'attribuzione del numero di registrazione, probabilmente determinato da un conflitto di aggiornamento";
_log.ErrorFormat("Errore inaspettato nel salvataggio (UPDATE) del movimento - {0} - idMovimentoAvere:{1} - esercizio:{2} - azienda:{3}", ex, Library.Utility.GetMethodDescription(), movimentoAvere.ID, idEsercizio.GetValueOrDefault(), _info.Azienda);
persistenceContextService.RollbackAndCloseSession(Security.Login.Instance.CurrentLogin().LoginName);
persistenceContextService.BeginTransaction(Security.Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new SpesaInfoDTO { Id = 0, NumeroProtocollo = 0, IdentificativoArchiviazione = null, StampaEtichettaArchiviazione = false, Message = message };
}
}
public SpesaInfoDTO Salva(SpesaDTO spesaDto, IDictionary<DettaglioSpesaDTO, RipartizioneSpeseDTO> listaRipartizione, bool isMultiIva)
{
try
{
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
var movimentoContabileService = _windsorRepository.GetContainer(_info.Azienda).Resolve<IMovimentiContabiliService>();
var ripartizioneSpeseService = _windsorRepository.GetContainer(_info.Azienda).Resolve<IRipartizioneSpeseService>();
var protocolloService = _windsorRepository.GetContainer(_info.Azienda).Resolve<IProtocolloService>();
var ripartizioneSpesa = new RipartizioneSpeseRepository(_info, _windsorRepository);
// ------------------------------------------------------------
// Verifico se il fornitore è presente
// ------------------------------------------------------------
var fornitore = daoFactory.GetFornitoreDao().Find(spesaDto.IdFornitore.GetValueOrDefault(), false);
if (fornitore == null)
{
return new SpesaInfoDTO { Id = 0, IdentificativoArchiviazione = null, NumeroProtocollo = 0, StampaEtichettaArchiviazione = false, Message = "Il fornitore non è più presente in archivio." };
}
// ------------------------------------------------------------
// Prima di ogni modifica recupero i movimenti secondari
// ------------------------------------------------------------
IList<MovimentoContabile> movimentiSecondari = null;
if (spesaDto.ID > 0)
{
var spesa = daoFactory.GetSpesaDao().Find(spesaDto.ID, false);
if(spesa != null)
movimentiSecondari = ripartizioneSpeseService.GetMovimentiSecondari(spesa);
}
// ------------------------------------------------------------
// Creo la ripartizione per ogni movimento
// ------------------------------------------------------------
foreach (var dettaglioDto in spesaDto.Dettagli)
{
RipartizioneSpeseDTO ripartizione = null;
var dettaglio = ripartizioneSpesa.GetDettaglioDto(listaRipartizione, dettaglioDto.NumeroRiga.GetValueOrDefault());
if (dettaglio != null)
{
if (listaRipartizione.ContainsKey(dettaglio))
ripartizione = listaRipartizione[dettaglio];
}
if (ripartizione == null || ripartizione.UnitaImmobiliari == null)
{
var oldRipartizione = ripartizione;
ripartizione = new RipartizioneSpeseDTO();
if(oldRipartizione != null)
{
ripartizione.Descrizione = oldRipartizione.Descrizione;
ripartizione.DescrizioneVoceSpesa = oldRipartizione.DescrizioneVoceSpesa;
ripartizione.NomeModello = oldRipartizione.NomeModello;
}
}
foreach (var movimentoDto in dettaglioDto.Movimenti)
{
if (movimentoDto.ID > 0)
{
var movimento = daoFactory.GetMovimentoContabileDao().Find(movimentoDto.ID, false);
if (movimento?.MovimentoStorno != null)
{
try
{
movimentoDto.IdMovimentoStorno = movimento.MovimentoStorno.ID;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella lettura dell'id del movimento di storno - {0} - spesa:{1} - movimento:{2}", ex, Utility.GetMethodDescription(), spesaDto.ID, movimento.ID);
}
finally
{
movimento.MovimentoStorno = null;
}
}
}
movimentoDto.ID = 0;
if(dettaglioDto.IdModelloRipartizione == null)
ripartizioneSpesa.GetRipartizioneByMovimento(movimentoDto, spesaDto.IdEsercizio.GetValueOrDefault(), ripartizione);
}
}
// --------------------------------
// Aggiungo le ripartizioni tra le diverse unità immobiliari
// --------------------------------
ripartizioneSpesa.AddMovimentiRipartizione(listaRipartizione, spesaDto);
// --------------------------------
// Salvataggio della spesa
// --------------------------------
if(spesaDto.StatoSpesa == StatoSpesaEnum.Undefined)
spesaDto.StatoSpesa = StatoSpesaEnum.Inserita;
var resultSpesa = ManageDomainEntity(spesaDto, isMultiIva);
if (resultSpesa.Spesa != null)
{
var spesa = resultSpesa.Spesa;
// ripartizione di default
// TODO: Dato che la ripartizione ora viene ricalcolata quando serve (stampa riparto bilancio ecc....)
// probabilmente NON è più necessaria la chiamata a questo metodo
//ripartizioneSpesa.AddDefaultRipartizione(listaRipartizione, spesa);
// --------------------------------
// Movimenti contabili secondari
// --------------------------------
// Eliminazione della vecchia testata
if (spesaDto.IdTestata > 0)
{
var testata = daoFactory.GetTestataMovimentoContabileDao().Find(spesaDto.IdTestata, false);
// bugid#4168
if(testata != null)
deleteTestata(testata, daoFactory);
}
// Creazione dei nuovi movimenti contabili
movimentoContabileService.SetMovimentiInserimentoSpesa(spesa, null, spesaDto.DataRegistrazione);
// --------------------------------
// Modello registrazione contabile
// --------------------------------
if (listaRipartizione.Count > 0)
{
foreach (var dettaglio in spesa.Dettagli)
{
var kvpRipartizione = getDettaglioDto(listaRipartizione, dettaglio.NumeroRiga.GetValueOrDefault());
if (kvpRipartizione != null)
{
var listaMovimenti = new List<MovimentoContabileDTO>(kvpRipartizione.GetValueOrDefault().Key.Movimenti.Length);
listaMovimenti.AddRange(kvpRipartizione.GetValueOrDefault().Key.Movimenti);
var modello = ripartizioneSpesa.SalvaModelloRipartizioneContabile(kvpRipartizione.GetValueOrDefault().Value, dettaglio, listaMovimenti, dettaglio.ImportoLordo.GetValueOrDefault());
if (modello != null)
{
if (kvpRipartizione.GetValueOrDefault().Value.AssociatoFornitore)
{
var modelloContabileFornitore = new ModelloContabileFornitore(spesa.FornitoreRiferimento, modello, null);
daoFactory.GetModelloContabileFornitoreDao().SaveOrUpdate(modelloContabileFornitore);
}
dettaglio.ModelloRipartizione = modello;
}
}
}
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Aggiorno eventuali movimenti secondari collegati.
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
if (movimentiSecondari != null)
ripartizioneSpeseService.UpdateMovimentiSecondari(spesa, movimentiSecondari);
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Aggiorno i documenti
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
if (spesaDto.IdDocumenti.Count > 0)
{
foreach (var idDoc in spesaDto.IdDocumenti)
{
var documento = daoFactory.GetDocumentoDao().Find(idDoc, false);
if(documento != null)
documento.SpesaRiferimento = spesa;
}
}
// ======================================================================================
// Registro gli eventuali pagamenti immediati
// ======================================================================================
var pagamentoService = _windsorRepository.GetContainer(_info.Azienda).Resolve<IPagamentoService>();
pagamentoService.CreatePagamentiImmediati(spesa.ID, spesaDto.Scadenze, null);
// ======================================================================================
// Recupero il numero di protocollo e l'identificativo di archiviazione
// ======================================================================================
if (spesa.NumeroProtocollo == null)
{
var progressivo = protocolloService.GetProgressivo(TipoProtocollo.Fattura, spesa.EsercizioRiferimento.DataApertura.GetValueOrDefault().Year, spesa.EsercizioRiferimento.CondominioRiferimento);
if (progressivo.Progressivo != null)
{
spesa.NumeroProtocollo = progressivo.Progressivo;
spesa.AnnoArchiviazioneOttica = spesa.EsercizioRiferimento.DataApertura.GetValueOrDefault().Year;
}
else
return new SpesaInfoDTO { Id = 0, IdentificativoArchiviazione = null, NumeroProtocollo = 0, StampaEtichettaArchiviazione = false, Message = progressivo.Message };
}
var identificativoArchiviazione = getArchiviazioneOtticaService().GetIdentificativoArchiviazione(spesa);
var impostazioni = daoFactory.GetImpostazioniAziendaDao().GetByAzienda(spesa.EsercizioRiferimento.CondominioRiferimento.Azienda.ID);
if (impostazioni == null)
{
impostazioni = new ImpostazioniAzienda(daoFactory.GetAziendaDao().GetById(spesa.EsercizioRiferimento.CondominioRiferimento.Azienda.ID, false));
daoFactory.GetImpostazioniAziendaDao().SaveOrUpdate(impostazioni);
}
var stampaEtichetta = impostazioni.UtilizzoEtichettatriceArchiviazioneOtticaFatture && spesa.IsAbilitataArchiviazioneOttica && spesaDto.ID == 0;
var etichettatrice = impostazioni.EtichettatriceArchiviazioneOttica;
var tipoEtichetta = impostazioni.TipoEtichettaArchiviazioneOttica;
var trayEtichettatriceAttivazioneOttica = impostazioni.TrayEtichettatriceAttivazioneOttica;
// ======================================================================================
// Aggiorno eventuali movimenti per interessi e sanzioni pagati in ritardo
// ======================================================================================
movimentoContabileService.SetMovimentiInteressiSanzioni(spesa);
return new SpesaInfoDTO { Id = spesa.ID, NumeroProtocollo = spesa.NumeroProtocollo.GetValueOrDefault(), IdentificativoArchiviazione = identificativoArchiviazione, StampaEtichettaArchiviazione = stampaEtichetta, EtichettatriceArchiviazione = etichettatrice, TipoEtichettaArchiviazione = tipoEtichetta, TrayEtichettatriceAttivazioneOttica = trayEtichettatriceAttivazioneOttica };
}
return new SpesaInfoDTO { Id = 0, NumeroProtocollo = 0, IdentificativoArchiviazione = null, StampaEtichettaArchiviazione = false, EtichettatriceArchiviazione = string.Empty, TipoEtichettaArchiviazione = "Testo", Message = resultSpesa.Message };
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel salvataggio della spesa - {0} - numeroDocumento:{1} - dataDocumento:{2} - dataRegistrazione:{3}", ex, Utility.GetMethodDescription(), spesaDto.NumeroDocumento, spesaDto.DataDocumento, spesaDto.DataRegistrazione);
throw;
}
}
public RipartizioneSpeseDTO GetRipartizioneByMovimento(MovimentoContabileDTO movimento, EsercizioDTO esercizio, RipartizioneSpeseDTO ripartizioneDettaglio)
{
try
{
if (movimento.IdConto > 0 && esercizio != null)
{
var result = GetServiceClient().GetRipartizioneByMovimento(movimento, esercizio.ID, ripartizioneDettaglio, GetUserInfo());
CloseService();
return result;
}
return null;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella lettura della ripartizione per movimento - {0} - movimento:{1} - esercizio:{2}", ex, Utility.GetMethodDescription(), movimento != null ? movimento.ID.ToString(CultureInfo.InvariantCulture) : "<NULL>", esercizio != null ? esercizio.ID.ToString(CultureInfo.InvariantCulture) : "<NULL>");
throw;
}
}
