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 void LoadData(CondominioDTO condominio, EsercizioDTO esercizio, decimal importo, ContoDTO contoPatrimoniale, int? idBancaCondominio, int idCondomino, int? idMovimentoBancario, DateTime dataRegistrazione)
{
_gestioneVersamenti = new GestioneVersamentiPersonaUC(condominio, esercizio, importo, contoPatrimoniale, idBancaCondominio, idCondomino, idMovimentoBancario, dataRegistrazione);
MainStandardForm_Fill_Panel.Controls.Add(_gestioneVersamenti);
_gestioneVersamenti.Dock = DockStyle.Fill;
_gestioneVersamenti.AfterUpdate += gestioneVersamentiAfterUpdate;
}
public RipartoContiUnitaUI(EsercizioDTO esercizio, ContoDTO conto, int idUnita)
{
InitializeComponent();
inizializza();
_esercizio = esercizio;
_conto = conto;
_unitaImmobiliare = _unitaImmobiliareService.GetByID(idUnita);
}
public DettaglioConto(ContoDTO conto, EsercizioDTO esercizio)
{
InitializeComponent();
if (!DesignMode)
{
inizializza();
_conto = conto;
_esercizio = esercizio;
BusinessClass = new[] { (BaseDTOOfint)_conto };
Text += @" Id: " + _conto.ID + @" - " + _conto.Descrizione;
}
}
public SpesaInfoDTO AddebitoCompetenze(int idEsercizio, DateTime data, string descrizione, ContoDTO conto, SottoContoDTO sottoConto, IList<ImportiDTO> importi)
{
int? idSottoConto = null;
if (sottoConto != null)
idSottoConto = sottoConto.ID;
var result = GetServiceClient().AddebitoCompetenze(idEsercizio, data, descrizione, conto.ID, idSottoConto, new List<ImportiDTO>(importi), GetUserInfo());
if (result.StampaEtichettaArchiviazione)
{
var workerStampaEtichetta = new BackgroundWorker();
workerStampaEtichetta.DoWork += workerStampaEtichettaDoWork;
workerStampaEtichetta.RunWorkerAsync(new object[] { result.IdentificativoArchiviazione, result.TrayEtichettatriceAttivazioneOttica });
}
CloseService();
return result;
}
public MovimentoContabileEconomicoUI(CausaleContabileDTO causale, EsercizioDTO esercizio, decimal importo, ContoDTO conto, int? idContoBancario, DateTime? dataContabile, string descrizione, Sfera.Enums.TipoMovimentoEnum incassoSpesa, int? idMovimentoBancario) : base(false)
{
InitializeComponent();
_movimentoControl = new MovimentoContabileEconomicoUC(causale, esercizio, conto, idContoBancario, dataContabile, descrizione, importo, incassoSpesa, idMovimentoBancario);
_movimentoControl.SetConfirmByParent(false);
MainStandardForm_Fill_Panel.Controls.Add(_movimentoControl);
_movimentoControl.AutoScroll = true;
_movimentoControl.Dock = DockStyle.Fill;
_movimentoControl.Location = new Point(0, 0);
_movimentoControl.Name = "movimentoContabileUIControl";
_movimentoControl.Size = new Size(987, 557);
_movimentoControl.TabIndex = 0;
_movimentoControl.AfterUpdate += movimentoControlAfterUpdate;
_movimentoControl.FormClose += movimentoControlFormClose;
}
public GestioneVersamentiUC(CondominioDTO condominio, EsercizioDTO esercizio, decimal importoVersamento, ContoDTO contoPatrimonialeVersamento, int idCondomino, int? idMovimentoBancario)
{
_condominio = condominio;
_esercizio = esercizio;
_contoPatrimonialeVersamento = contoPatrimonialeVersamento;
_idCondomino = idCondomino;
_idMovimentoBancario = idMovimentoBancario;
InitializeComponent();
inizializza();
sceltaCondominioCombo.Enabled = false;
importo.Value = importoVersamento;
importo.Enabled = false;
_importoIniziale = importoVersamento > 0;
}
public GestioneVersamentiPersonaUC(CondominioDTO condominio, EsercizioDTO esercizio, decimal importoVersamento, ContoDTO contoPatrimonialeVersamento, int? idBancaCondominio, int idCondomino, int? idMovimentoBancario, DateTime dataRegistrazione)
{
_condominio = condominio;
_esercizio = esercizio;
_contoPatrimonialeVersamento = contoPatrimonialeVersamento;
_contoCorrenteVersamento = idBancaCondominio;
_idCondomino = idCondomino;
_idMovimentoBancario = idMovimentoBancario;
InitializeComponent();
inizializza();
sceltaCondominioCombo.Enabled = false;
importo.Value = importoVersamento;
importo.Enabled = false;
_importoIniziale = importoVersamento > 0;
_dataVersamento = dataRegistrazione;
dataVersamento.DateTime = dataRegistrazione;
}
public virtual List<MillesimoDTO> GetMillesimiByContoLottoStabileScala(ContoDTO conto, int? idLotto, int? idStabile, int? idGruppo, EsercizioDTO esercizio)
{
throw new NotImplementedException("Implementare il metodo per il recupero del piano dei conti per esercizio");
}
public void SetPeriodoCompetenzaContabile(EsercizioDTO esercizio, ContoDTO conto, TipoPeriodoCompetenzaContabile tipoPeriodo)
{
if (conto != null)
{
conto.TipoCompetenza = tipoPeriodo;
if (esercizio != null)
{
var periodo = GetServiceClient().GetPeriodoCompetenzaConto(esercizio.ID, conto.DataInizioCompetenza, conto.DataFineCompetenza, tipoPeriodo, GetUserInfo());
conto.DataInizioCompetenza = periodo.DataInizioCompetenza;
conto.DataFineCompetenza = periodo.DataFineCompetenza;
}
}
}
private List<SottoContoDTO> convertFornitoriToSottoconti(ContoDTO conto)
{
var sottoConti = new List<SottoContoDTO>();
foreach (var fornitore in _fornitoreService.GetAll(true))
{
var sottoConto = new SottoContoDTO
{
ID = fornitore.ID * -1,
Descrizione = fornitore.DisplayName,
DescrizioneCompleta = fornitore.DisplayName,
Codice = conto.Codice + "." + fornitore.ID.ToString(CultureInfo.InvariantCulture).PadLeft(7, '0'),
DescrizioneContoRiferimento = conto.Descrizione,
IdContoRiferimento = conto.ID
};
sottoConti.Add(sottoConto);
}
return sottoConti;
}
public List<SottoContoDTO> GetSottoContiDataSource(ContoDTO conto, int? idEsercizio)
{
if (conto != null)
{
var sottoConti = conto.Codice == GetCodiceContoFornitori() || conto.Codice == GetCodiceContoRitenuta() ? convertFornitoriToSottoconti(conto) : conto.SottoConti;
if (!sottoConti.Any())
{
conto = GetById(conto.ID, idEsercizio);
sottoConti = conto.SottoConti;
}
if (sottoConti.Count == 0 || sottoConti[0].ID > 0)
sottoConti.Insert(0, new SottoContoDTO { ID = 0, Descrizione = " ", DisplayName = " " });
return sottoConti;
}
return new List<SottoContoDTO>();
}
protected override bool Save()
{
var resultSave = false;
try
{
_conto = getPianoContiService().Save(_conto, _esercizio);
Library.CommonMessages.DisplayComplete("Il conto è stato correttamente salvato.");
resultSave = base.Save();
}
catch (Exception ex)
{
_log.Error("Errore nel salvataggio di un singolo conto - " + Gipasoft.Library.Utility.GetMethodDescription() + " - conto:" + _conto.ID, ex);
var result = Library.CommonMessages.DisplayConfirmCancel("Durante l'aggiornamento del piano dei conti si sono verificati degli errori dovuti a una aggiornamento non corente" + Environment.NewLine + "Vuoi ricaricare i conti per provare a ripetere la modifica?");
if (result == DialogResult.Yes)
loadData();
}
return resultSave;
}
public ContoDTO GetContoBancario(Esercizio esercizio)
{
//esercizio = _daoFactory.GetEsercizioDao().Find(esercizio.ID, false);
if (esercizio != null)
{
var contoBancario = esercizio.Conti.FirstOrDefault(item => item.Codice == GetCodiceContoBancario());
if (contoBancario == null)
return null;
var contoDto = new ContoDTO
{
ID = contoBancario.ID,
IdContatore = null,
Codice = contoBancario.Codice,
IdCondominio = esercizio.CondominioRiferimento.ID,
DisplayName = contoBancario.Codice + " - " + contoBancario.Descrizione,
Descrizione = contoBancario.Descrizione,
DescrizioneBilancio = contoBancario.DescrizioneBilancio,
IsSpesePersonali = contoBancario.IsSpesePersonali,
Note = contoBancario.Note,
Ordine = contoBancario.Ordine,
PercentualeProprieta = contoBancario.PercentualeProprieta,
PresenteBilancio = contoBancario.PresenteBilancio,
Tipo = contoBancario.Tipo,
TipoCompetenza = contoBancario.TipoCompetenza,
Version = contoBancario.Version,
CustomField = contoBancario.CustomField,
DataFineCompetenza = contoBancario.DataFineCompetenza,
DataInizioCompetenza = contoBancario.DataInizioCompetenza,
DescrizioneCompleta = contoBancario.Codice + " - " + contoBancario.Descrizione,
UtilizzabileRegistrazioneSpese = contoBancario.UtilizzabileRegistrazioneSpese,
UtilizzabileVersamentoCondomini = contoBancario.UtilizzabileVersamentoCondomini
};
foreach (var sottoconto in contoBancario.SottoConti)
{
contoDto.SottoConti.Add(new SottoContoDTO
{
ID = sottoconto.ID,
Descrizione = string.Format("{0} - {1}", sottoconto.Codice, sottoconto.GetDescrizione(esercizio, null, null)),
DescrizioneCompleta = string.Format("{0} - {1}", sottoconto.Codice, sottoconto.GetDescrizione(esercizio, null, null)),
PercentualeProprieta = sottoconto.PercentualeProprieta
});
}
foreach (var banca in esercizio.CondominioRiferimento.DatiBancari)
{
if (banca.DataValidita == null || banca.DataValidita > esercizio.DataApertura)
{
contoDto.SottoConti.Add(new SottoContoDTO
{
ID = banca.ID * -1,
Descrizione = string.Format("c/c: {0}", banca.ContoCorrente),
DescrizioneCompleta = string.Format("{0}.{1} - c/c {2}", contoDto.Codice, banca.ID.ToString().PadLeft(6, '0'), banca.ContoCorrente),
DescrizioneContoRiferimento = contoBancario.Descrizione,
IdContoRiferimento = contoBancario.ID,
DisplayName = string.Format("{0} - {1} c/c: {2}", banca.Abi, banca.Cab, banca.ContoCorrente)
});
}
}
return contoDto;
}
return null;
}
private void loadData()
{
try
{
if (_conto != null && _esercizio != null)
_conto = getPianoContiWCFService().GetById(_conto.ID, _esercizio.ID);
try
{
if(_conto != null)
{
contoDTOBindingSource.DataSource = _conto;
SetDirty(false);
}
}
catch (Exception ex)
{
var idConto = "NULL";
if (_conto != null)
idConto = _conto.ID.ToString();
_log.Error("Errore nel caricamento dei dati - SET DATA SOURCE - " + Gipasoft.Library.Utility.GetMethodDescription() + " - conto:" + idConto, ex);
throw;
}
}
catch (Exception ex)
{
var idConto = "NULL";
if (_conto != null)
idConto = _conto.ID.ToString();
_log.Error("Errore nel caricamento dei dati - " + Gipasoft.Library.Utility.GetMethodDescription() + " - conto:" + idConto, ex);
throw;
}
}
private void updateConto(ContoDTO dto, out Conto item)
{
item = null;
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
try
{
item = daoFactory.GetContoDao().GetById(dto.ID, false);
item.Codice = dto.Codice;
item.PercentualeProprieta = dto.PercentualeProprieta;
item.Descrizione = dto.Descrizione;
item.DescrizioneBilancio = dto.DescrizioneBilancio;
if (item.CondominioRiferimento.ID != dto.IdCondominio)
item.CondominioRiferimento = daoFactory.GetCondominioDao().GetById(dto.IdCondominio, false);
if (!(item.EsercizioRiferimento == null && dto.IdEsercizio == null))
{
if (item.EsercizioRiferimento != null && dto.IdEsercizio == null)
item.EsercizioRiferimento = null;
else if (item.EsercizioRiferimento == null && dto.IdEsercizio != null)
item.EsercizioRiferimento = daoFactory.GetEsercizioDao().GetById(dto.IdEsercizio.Value, false);
else if (item.EsercizioRiferimento != null && item.EsercizioRiferimento.ID != dto.IdEsercizio)
item.EsercizioRiferimento = daoFactory.GetEsercizioDao().GetById(dto.IdEsercizio.GetValueOrDefault(), false);
}
if (dto.IdContatore != null)
{
var contatore = daoFactory.GetContatoreDao().Find(dto.IdContatore.GetValueOrDefault(), false);
if (contatore != null)
item.ContatoreRiferimento = contatore;
}
item.PercentualeProprieta = dto.PercentualeProprieta;
item.Ordine = dto.Ordine;
item.UtilizzabileRegistrazioneSpese = dto.UtilizzabileRegistrazioneSpese;
item.UtilizzabileVersamentoCondomini = dto.UtilizzabileVersamentoCondomini;
item.UtilizzabilePagamentoFornitori = dto.UtilizzabilePagamentoFornitori;
item.IsTransitorio = dto.IsTransitorio;
item.IsTransitorio = dto.IsAccantonamentoFondi;
item.IsMillesimiProprieta = dto.IsMillesimiProprieta;
item.IsLiquido = dto.IsLiquido;
item.IsArrotondamento = dto.IsArrotondamento;
if (!string.IsNullOrEmpty(dto.TipoLiquidita))
{
TipoLiquidita tipoLiquidita;
if (Enum.TryParse(dto.TipoLiquidita, true, out tipoLiquidita))
item.TipoLiquidita = tipoLiquidita;
}
item.PresenteBilancio = dto.PresenteBilancio == null || dto.PresenteBilancio.Value;
if (dto.TipoCompetenza != TipoPeriodoCompetenzaContabile.Undefined)
item.TipoCompetenza = dto.TipoCompetenza;
item.IsSpesePersonali = dto.IsSpesePersonali;
item.IsRipartoLetture = dto.IsRipartoLetture;
item.DataInizioCompetenza = dto.DataInizioCompetenza;
item.DataFineCompetenza = dto.DataFineCompetenza;
item.Note = dto.Note;
// =====================================
// Aggiorno il codice dei sottoconti
// =====================================
const int index = 0;
foreach (var sottoConto in item.SottoConti)
{
if (!string.IsNullOrEmpty(sottoConto.Codice))
{
if (sottoConto.Codice.Contains('.'))
sottoConto.Codice = item.Codice + sottoConto.Codice.Substring(sottoConto.Codice.IndexOf('.'));
}
else
sottoConto.Codice = item.Codice + "." + index.ToString().PadLeft(3, '0');
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel salvataggio del conto contabile - {0} - id:{1}", ex, Utility.GetMethodDescription(), dto.ID);
throw;
}
}
private bool insertConto(ContoDTO dto, out Conto item)
{
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
try
{
item = new Conto(daoFactory.GetCondominioDao().GetById(dto.IdCondominio, false), dto.Tipo, TipoPeriodoCompetenzaContabile.Esercizio, dto.Descrizione, true, dto.UtilizzabileRegistrazioneSpese, dto.UtilizzabileVersamentoCondomini)
{
Codice = dto.Codice,
DescrizioneBilancio = dto.DescrizioneBilancio,
UtilizzabilePagamentoFornitori = dto.UtilizzabilePagamentoFornitori,
CondominioRiferimento = daoFactory.GetCondominioDao().GetById(dto.IdCondominio, false),
DettaglioMovimentiContabili = dto.DettaglioMovimentiContabili
};
if (dto.IdContatore != null)
{
var contatore = daoFactory.GetContatoreDao().Find(dto.IdContatore.GetValueOrDefault(), false);
if (contatore != null)
item.ContatoreRiferimento = contatore;
}
if (!(item.EsercizioRiferimento == null && dto.IdEsercizio == null))
{
if (item.EsercizioRiferimento != null && dto.IdEsercizio == null)
item.EsercizioRiferimento = null;
else if (item.EsercizioRiferimento == null && dto.IdEsercizio != null)
item.EsercizioRiferimento = daoFactory.GetEsercizioDao().GetById(dto.IdEsercizio.Value, false);
else if (item.EsercizioRiferimento != null && item.EsercizioRiferimento.ID != dto.IdEsercizio)
item.EsercizioRiferimento = daoFactory.GetEsercizioDao().GetById(dto.IdEsercizio.GetValueOrDefault(), false);
}
item.Ordine = dto.Ordine;
item.PercentualeProprieta = dto.PercentualeProprieta;
item.IsSpesePersonali = dto.IsSpesePersonali;
item.IsRipartoLetture = dto.IsRipartoLetture;
item.IsTransitorio = dto.IsTransitorio;
item.IsAccantonamentoFondi = dto.IsAccantonamentoFondi;
item.IsMillesimiProprieta = dto.IsMillesimiProprieta;
item.IsLiquido = dto.IsLiquido;
item.IsArrotondamento = dto.IsArrotondamento;
item.PresenteBilancio = dto.PresenteBilancio == null || dto.PresenteBilancio.Value;
if (!string.IsNullOrEmpty(dto.TipoLiquidita))
{
TipoLiquidita tipoLiquidita;
if (Enum.TryParse(dto.TipoLiquidita, true, out tipoLiquidita))
item.TipoLiquidita = tipoLiquidita;
}
if(dto.TipoCompetenza != TipoPeriodoCompetenzaContabile.Undefined)
item.TipoCompetenza = dto.TipoCompetenza;
item.DataInizioCompetenza = dto.DataInizioCompetenza;
item.DataFineCompetenza = dto.DataFineCompetenza;
item.Note = dto.Note;
// --------------------------------------------------------
// Sotto Conti
// --------------------------------------------------------
item.SottoConti.Clear();
foreach (var sottocontoDTO in dto.SottoConti)
{
sottocontoDTO.IdContoRiferimento = item.ID;
int? idSottoconto = sottocontoDTO.ID;
if ((sottocontoDTO.Stato == "U") || (sottocontoDTO.Stato == "I"))
idSottoconto = manageSottoconto(sottocontoDTO).ID;
var sottoconto = daoFactory.GetSottoContoDao().GetById(idSottoconto.Value, false);
item.SottoConti.Add(sottoconto);
sottoconto.ContoRiferimento = item;
// Aggiorno il codice dei sottoconti
// ------------------------------------
const int index = 0;
if (string.IsNullOrEmpty(sottoconto.Codice))
sottoconto.Codice = item.Codice + "." + index.ToString().PadLeft(3, '0');
}
daoFactory.GetContoDao().SaveOrUpdate(item);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel inserimento del conto contabile - {0} - id:{1}", ex, Utility.GetMethodDescription(), dto.ID);
throw;
}
return true;
}
private Conto manageConto(ContoDTO dto)
{
Conto item = null;
// Controllo sullo stato U, I
switch (dto.Stato.ToUpper())
{
case "U":
updateConto(dto, out item);
if (item == null)
throw new Exception("Il dato sul database è più recente di quello utilizzato");
break;
case "I":
var result = insertConto(dto, out item);
if (!result)
throw new Exception("Impossibile scrivere sul database");
break;
}
return item;
}
private ContoDTO setPianoContiDto(PianoConti conto)
{
var dto = new ContoDTO
{
Codice = conto.Codice,
Ordine = conto.Ordine,
Tipo = conto.Tipo,
Descrizione = conto.Descrizione,
DescrizioneBilancio = conto.DescrizioneBilancio,
DescrizioneCompleta = conto.Codice + " - " + conto.Descrizione,
PercentualeProprieta = conto.PercentualeProprieta,
CustomField = conto.CustomField,
Ripartizione = conto.Ripartizione,
PresenteBilancio = conto.PresenteBilancio,
IsSpesePersonali = conto.IsSpesePersonali,
IsRipartoLetture = conto.IsRipartoLetture,
IsLiquido = conto.IsLiquido,
IsArrotondamento = conto.IsArrotondamento,
TipoLiquidita = conto.TipoLiquidita.ToString(),
UtilizzabileRegistrazioneSpese = conto.UtilizzabileRegistrazioneSpese,
UtilizzabileVersamentoCondomini = conto.UtilizzabileVersamentoCondomini,
UtilizzabilePagamentoFornitori = conto.UtilizzabilePagamentoFornitori,
DettaglioMovimentiContabili = conto.DettaglioMovimentiContabili,
IsDeleteAllow = conto.Azienda != null
};
if (string.IsNullOrEmpty(dto.DescrizioneBilancio))
dto.DescrizioneBilancio = dto.Descrizione;
//--------------------------------------------------------
// Sottoconti
//--------------------------------------------------------
var sottoConti = new List<SottoContoDTO>(conto.SottoConti.Count);
sottoConti.AddRange(conto.SottoConti.OrderBy(item => item.Descrizione).Select(setPianoContiSottoContoDto));
dto.SottoConti = sottoConti;
dto.ID = conto.ID;
dto.Version = conto.Version;
return dto;
}
private ContoDTO setContoDto(Conto conto, int? idEsercizio, bool gestione, IEnumerable<FornitoreListaDTO> fornitori, bool codiceContabile)
{
if (conto != null)
{
var dto = new ContoDTO
{
Codice = conto.Codice,
Ordine = conto.Ordine,
Tipo = conto.Tipo,
Descrizione = conto.Descrizione,
DescrizioneBilancio = conto.DescrizioneBilancio,
DescrizioneCompleta = conto.Codice + " - " + conto.Descrizione,
PercentualeProprieta = conto.PercentualeProprieta,
IdCondominio = conto.CondominioRiferimento.ID,
CustomField = conto.CustomField,
Ripartizione = conto.Ripartizione,
PresenteBilancio = conto.PresenteBilancio,
IsSpesePersonali = conto.IsSpesePersonali,
IsRipartoLetture = conto.IsRipartoLetture,
TipoCompetenza = conto.TipoCompetenza,
DataInizioCompetenza = conto.DataInizioCompetenza,
DataFineCompetenza = conto.DataFineCompetenza,
UtilizzabileRegistrazioneSpese = conto.UtilizzabileRegistrazioneSpese,
UtilizzabileVersamentoCondomini = conto.UtilizzabileVersamentoCondomini,
UtilizzabilePagamentoFornitori = conto.UtilizzabilePagamentoFornitori,
IsTransitorio = conto.IsTransitorio,
IsAccantonamentoFondi = conto.IsAccantonamentoFondi,
IsMillesimiProprieta = conto.IsMillesimiProprieta,
DettaglioMovimentiContabili = conto.DettaglioMovimentiContabili,
IsLiquido = conto.IsLiquido,
IsArrotondamento = conto.IsArrotondamento,
TipoLiquidita = conto.TipoLiquidita.ToString(),
Note = conto.Note
};
if (string.IsNullOrEmpty(conto.Deleted) || conto.Deleted != "Y")
dto.Deleted = false;
else
dto.Deleted = true;
if (conto.ContatoreRiferimento != null)
{
try
{
dto.IdContatore = conto.ContatoreRiferimento.ID;
}
catch (Exception ex)
{
_log.WarnFormat("Errore nella lettura del contatore legato al conto - {0} - id:{1}", ex, Utility.GetMethodDescription(), dto.ID);
dto.IdContatore = null;
}
}
else
dto.IdContatore = null;
if (string.IsNullOrEmpty(dto.DescrizioneBilancio))
dto.DescrizioneBilancio = dto.Descrizione;
if (conto.EsercizioRiferimento != null)
{
try
{
dto.IdEsercizio = conto.EsercizioRiferimento.ID;
}
catch (Exception ex)
{
_log.WarnFormat("Errore nella lettura dell'esercizio legato al conto - {0} - id:{1}", ex, Utility.GetMethodDescription(), dto.ID);
dto.IdEsercizio = null;
}
}
//--------------------------------------------------------
// Sottoconti
//--------------------------------------------------------
var sottoConti = new List<SottoContoDTO>(conto.SottoConti.Count);
sottoConti.AddRange(from sottoConto in conto.SottoConti.OrderBy(item => item.GetDescrizione(null, conto.CondominioRiferimento, null)) where string.IsNullOrEmpty(sottoConto.Deleted) select setSottoContoDto(sottoConto, gestione));
dto.SottoConti = sottoConti;
var pianoContiService = _windsorRepository.GetContainer(_info.Azienda).Resolve<IPianoContiService>();
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
var dataApertura = DateTime.MinValue;
if(idEsercizio > 0)
{
var esercizio = daoFactory.GetEsercizioDao().Find(idEsercizio.Value, false);
if(esercizio != null)
dataApertura = esercizio.DataApertura.GetValueOrDefault();
}
// Aggiungo i conti correnti bancari come sottoconti del conto banca
if (!gestione && conto.Codice == pianoContiService.GetCodiceContoBancario())
{
foreach (var banca in conto.CondominioRiferimento.DatiBancari)
{
if (banca.DataValidita == null || banca.DataValidita > dataApertura)
{
string displayName;
if (!codiceContabile)
{
displayName = $"{banca.Abi} - {banca.Cab} - c/c: {banca.ContoCorrente}";
if (banca.DataValidita != null)
displayName += $" - fino al {banca.DataValidita.GetValueOrDefault():d}";
}
else
{
displayName = $"B{banca.ID}";
}
var sottoconto = new SottoContoDTO
{
ID = banca.ID*-1,
Codice = !codiceContabile
? $"F{banca.ID}"
: $"{conto.Codice}.{banca.ID.ToString(CultureInfo.InvariantCulture).PadLeft(7, '0')}",
Descrizione = "c/c: " + banca.ContoCorrente,
DescrizioneContoRiferimento = conto.Descrizione,
IdContoRiferimento = conto.ID,
DisplayName = displayName,
IsNotValid = banca.DataValidita != null,
FrequentlyAccessed = banca.Principale.GetValueOrDefault()
};
sottoconto.DescrizioneCompleta = sottoconto.Descrizione;
dto.SottoConti.Add(sottoconto);
}
}
}
// Aggiungo i fornitori come sottoconti del conto fornitori
if (!gestione && conto.Codice == pianoContiService.GetCodiceContoFornitori() && fornitori != null)
{
foreach (var fornitore in fornitori)
{
var sottoconto = new SottoContoDTO
{
ID = fornitore.ID*-1,
Codice = !codiceContabile
? $"F{fornitore.ID}"
: $"{conto.Codice}.{fornitore.ID.ToString(CultureInfo.InvariantCulture).PadLeft(7, '0')}",
Descrizione = fornitore.DisplayName,
DescrizioneContoRiferimento = conto.Descrizione,
IdContoRiferimento = conto.ID,
DisplayName = !codiceContabile ? fornitore.DisplayName : $"F{fornitore.ID}"
};
sottoconto.DescrizioneCompleta = sottoconto.Descrizione;
dto.SottoConti.Add(sottoconto);
}
}
dto.ID = conto.ID;
dto.Version = conto.Version;
return dto;
}
return null;
}
public virtual string DeletePianoConti(ContoDTO conto)
{
var result = GetServiceClient().DeletePianoConti(conto.ID, GetUserInfo());
CloseService();
return result;
}
public string ConfermaCalcoloInteresse(EsercizioDTO esercizio, List<RiepilogoRataSoggettoDTO> rate, ContoDTO contoAddebitoProprietario, ContoDTO contoAddebitoConduttore, ContoDTO contoAccredito, string descrizioneMovimentoAddebito, string descrizioneMovimentoAccredito, DateTime dataRegistrazione)
{
var result = GetServiceClient().ConfermaCalcoloInteresseMora(esercizio.ID, rate, contoAddebitoProprietario.ID, contoAddebitoConduttore.ID, contoAccredito.ID, descrizioneMovimentoAddebito, descrizioneMovimentoAccredito, dataRegistrazione, GetUserInfo());
CloseService();
return result;
}
public int? ManageContoDomainEntity(ContoDTO conto)
{
try
{
return manageConto(conto).ID;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella gestione dei conti - {0} - id:{1}", ex, Utility.GetMethodDescription(), conto.ID);
throw;
}
}
public MovimentoContabileEconomicoUC(TestataMovimentoContabileDTO testata, EsercizioDTO esercizio, UpdatableStandardForm formGestione)
{
try
{
InitializeComponent();
_esercizio = esercizio;
_testata = testata;
_formGestione = formGestione;
inizializza();
if (_esercizio == null && testata.IdEsercizio != null && testata.IdEsercizio > 0)
_esercizio = getEsercizioService().GetById(testata.IdEsercizio.Value);
_movimentiDare = getMovimentoContabileService().GetMovimentiLista(_testata);
if (testata.Tipo == TipoTestataMovimentoContabileEnum.Automatica)
{
groupDettaglioMovimento.Visible = false;
groupDettaglioMovimento.Enabled = false;
if (!_confirmByParent)
btnConferma.Visible = true;
btnRicevuta.Visible = true;
}
else
{
groupDettaglioMovimento.Visible = true;
groupDettaglioMovimento.Enabled = true;
}
_movimentoAvere = getMovimentoContabileService().GetMovimentoSingolo(_testata);
if (_movimentoAvere != null)
{
_causale = _movimentoAvere.Causale;
int? idEsercizio = null;
if (_esercizio != null)
idEsercizio = _esercizio.ID;
_conto = getPianoContiService().GetById(_movimentoAvere.IdConto.GetValueOrDefault(), idEsercizio);
// Se il sottoconto è presente ed ha valore negativo trattasi di conto corrente bancario bugid#3754
if (_movimentoAvere.IdSottoConto != null)
{
if (_movimentoAvere.IdSottoConto.GetValueOrDefault() < 0)
_idContoBancario = _movimentoAvere.IdSottoConto.GetValueOrDefault()*-1;
}
_importo = _movimentoAvere.Importo.GetValueOrDefault();
descrizioneDettaglio.Value = _movimentoAvere.Descrizione;
noteDettaglio.Value = _testata.Note;
}
numeroProtocollo.Value = testata.NumeroProtocollo;
archiviazioneOttica.Checked = testata.IsAbilitataArchiviazioneOttica;
dataRegistrazione.DateTime = testata.DataRegistrazione.GetValueOrDefault();
dataInizioCompetenza.Value = null;
dataFineCompetenza.Value = null;
if (testata.DataInizioCompetenza != null)
dataInizioCompetenza.DateTime = testata.DataInizioCompetenza.GetValueOrDefault();
if (testata.DataFineCompetenza != null)
dataFineCompetenza.DateTime = testata.DataFineCompetenza.GetValueOrDefault();
sceltaEsercizioGroupBox.Enabled = false;
sceltaCondominioCombo1.Enabled = false;
esercizi.Enabled = false;
btnRiparto.Enabled = false;
btnConferma.Enabled = false;
backgroundWorkerLoadDati.RunWorkerAsync(_movimentiDare);
}
catch (Exception ex)
{
var idStr = "<NULL>";
if (testata != null)
idStr = testata.ID.ToString();
var idEsercizioStr = "<NULL>";
if (esercizio != null)
idEsercizioStr = esercizio.ID.ToString();
var nomeForm = "<NULL>";
if (formGestione != null)
nomeForm = formGestione.Name;
_log.ErrorFormat("Errore insaspettato nel costruttore - {0} - testata:{1} - esercizio:{2} - formGestione:{3}", ex, Utility.GetMethodDescription(), idStr, idEsercizioStr, nomeForm);
throw;
}
}
public Form GetInserimentoMovimentoContabile(CausaleContabileDTO causale, EsercizioDTO esercizio, decimal importo, ContoDTO conto, int? idContoBancario, DateTime? dataContabile, string descrizione, Sfera.Enums.TipoMovimentoEnum incassoSpesa, int? idMovimentoBancario)
{
_control = new MovimentoContabileEconomicoUI(causale, esercizio, importo, conto, idContoBancario, dataContabile, descrizione, incassoSpesa, idMovimentoBancario);
_control.SetCustomEdit();
return _control;
}
public ContoDTO Save(ContoDTO conto, EsercizioDTO esercizio)
{
var contoDTO = new ContoDTO
{
ID = conto.ID,
Codice = conto.Codice,
Descrizione = conto.Descrizione,
DescrizioneBilancio = conto.DescrizioneBilancio,
IdCondominio = conto.IdCondominio,
IdEsercizio = conto.IdEsercizio,
Ordine = conto.Ordine,
PercentualeProprieta = conto.PercentualeProprieta,
Version = conto.Version,
CustomField = true,
TipoCompetenza = conto.TipoCompetenza,
Tipo = TipoContoEconomicoEnum.Economico,
IsMillesimiProprieta =conto.IsMillesimiProprieta,
IsSpesePersonali = conto.IsSpesePersonali,
DataInizioCompetenza = conto.DataInizioCompetenza,
DataFineCompetenza = conto.DataFineCompetenza,
DescrizioneCompleta = conto.DescrizioneCompleta,
PresenteBilancio = conto.PresenteBilancio,
Ripartizione = conto.Ripartizione,
UtilizzabileRegistrazioneSpese = conto.UtilizzabileRegistrazioneSpese,
UtilizzabileVersamentoCondomini = conto.UtilizzabileVersamentoCondomini,
UtilizzabilePagamentoFornitori = conto.UtilizzabilePagamentoFornitori,
Note = conto.Note,
Stato = "U"
};
var idConto = GetServiceClient().SetConto(contoDTO, GetUserInfo()).GetValueOrDefault();
return GetById(idConto, esercizio.ID);
}
private List<MillesimoDTO> getMillesimi(ContoDTO conto)
{
var service = ResolveComponent<IPianoContiService>("pianocontiService.wcf");
return service.GetMillesimiByContoLottoStabileScala(conto, (int?)lotti.Value, (int?)stabili.Value, (int?)scale.Value, _esercizio);
}
public virtual string RipristinaConto(ContoDTO conto, EsercizioDTO esercizio)
{
// =======================================================
// Elimino dalla cache i conti che sto per aggiornare
// =======================================================
if (esercizio != null)
{
var cache = CacheFactory.GetCacheManager();
var contiCache = (Dictionary<int, List<ContoDTO>>)cache.GetData("PianoConti");
if (contiCache != null)
{
if (contiCache.ContainsKey(esercizio.ID))
contiCache.Remove(esercizio.ID);
cache.Remove("PianoConti");
cache.Add("PianoConti", contiCache);
}
var result = GetServiceClient().RipristinaConto(conto.ID, GetUserInfo());
CloseService();
return result;
}
_log.WarnFormat("Ripristina conto con esericizo NULL - {0} - conto:{1}", Utility.GetMethodDescription(), conto != null ? conto.ID.ToString(CultureInfo.InvariantCulture) : "<NULL>", Login.Instance.CurrentLogin().Azienda);
return "In questo momento non è possibile ripristinare il conto." + Environment.NewLine + "Si prega di riprovare più tardi";
}
public DataTable AddDataToPivot(EsercizioDTO esercizio, DataTable tb, IList<RataSoggettoDTO> rate, DateTime data, decimal importo, ContoDTO conto, IList<SoggettoCondominioDTO> soggetti, TipoAccorpamentoRateEnum tipo)
{
var dateColumn = new List<DataColumn>();
List<ImportiDTO> riparto = null;
if (conto != null)
riparto = GetServiceClient().GetRipartoImporto(esercizio.ID, conto.ID, importo, data, GetUserInfo());
// Se non sono presenti righe devo caricare tutte le righe per i condomini presenti
if (tb.Rows.Count == 0)
{
if(soggetti == null || !soggetti.Any())
soggetti = GetPartecipanti(esercizio.ID, tipo);
if (soggetti != null)
{
foreach (var soggetto in soggetti)
{
var row = tb.NewRow();
row["IdSoggetto"] = soggetto.ID;
row["Nominativo"] = soggetto.DisplayNominativo;
row["DescrizioneUnitaImmobiliare"] = soggetto.DescrizioneUnitaImmobiliare;
row["OrdineUnitaImmobiliare"] = soggetto.OrdineUnitaImmobiliare;
// Data
dateColumn = addColumnByData(data, tb, dateColumn);
decimal importoRata = importo;
if (riparto != null)
{
var importoItem = riparto.SingleOrDefault(item => item.Id == soggetto.ID);
importoRata = importoItem?.Importo ?? 0;
}
row["Decimal_Data_" + data.ToShortDateString()] = importoRata;
row["Stato_" + data.ToShortDateString()] = StatoRataEnum.Inserita.ToString();
row["NumeroSolleciti_" + data.ToShortDateString()] = 0;
row["Alert_" + data.ToShortDateString()] = false;
tb.Rows.Add(row);
// Aggiorno lista rate editabili
var rata = (rate.Where(item => item.DataScadenza == data && item.IdSoggettoCondominio == soggetto.ID)).FirstOrDefault();
if (rata == null)
{
var rataDto = new RataSoggettoDTO
{
ID = 0,
DataScadenza = data,
DescrizioneSoggettoCondominio = soggetto.DisplayNominativo,
DescrizioneUnitaImmobiliare = soggetto.DescrizioneUnitaImmobiliare,
IdEsercizio = esercizio.ID,
IdSoggettoCondominio = soggetto.ID,
StatoRata = StatoRataEnum.Inserita,
IdUnitaImmobiliare = soggetto.IdUnitaImmobiliare,
OrdineUnitaImmobiliare = soggetto.OrdineUnitaImmobiliare,
TipoSoggettoCondominio = soggetto.Tipo,
Importo = importoRata
};
rate.Add(rataDto);
}
}
}
}
else
{
dateColumn.AddRange(tb.Columns.Cast<DataColumn>().Where(column => column.ColumnName.StartsWith("Decimal_Data_")));
addColumnByData(data, tb, dateColumn);
foreach (DataRow row in tb.Rows)
{
var importoRata = importo;
if (riparto != null)
{
var importoItem = (from item in riparto
where item.Id == (int)row["IdSoggetto"]
select item).SingleOrDefault();
importoRata = importoItem?.Importo ?? 0;
}
row["Decimal_Data_" + data.ToShortDateString()] = importoRata;
// Aggiorno lista rate editabili
var rata = (from item in rate
where item.DataScadenza == data
&& item.IdSoggettoCondominio == (int)row["IdSoggetto"]
select item).FirstOrDefault();
if (rata == null)
{
var descrizioneUnitaImmobiliare = string.Empty;
var nominativo = string.Empty;
if (row["DescrizioneUnitaImmobiliare"] != null && row["DescrizioneUnitaImmobiliare"] != DBNull.Value)
descrizioneUnitaImmobiliare = (string)row["DescrizioneUnitaImmobiliare"];
if (row["Nominativo"] != null && row["Nominativo"] != DBNull.Value)
nominativo = (string)row["Nominativo"];
var rataDto = new RataSoggettoDTO
{
ID = 0,
DataScadenza = data,
DescrizioneSoggettoCondominio = nominativo,
DescrizioneUnitaImmobiliare = descrizioneUnitaImmobiliare,
IdEsercizio = esercizio.ID,
IdSoggettoCondominio = (int)row["IdSoggetto"],
StatoRata = StatoRataEnum.Inserita,
OrdineUnitaImmobiliare = (int)row["OrdineUnitaImmobiliare"],
TipoSoggettoCondominio = TipoSoggetto.Soggetto,
Importo = importoRata
};
rate.Add(rataDto);
}
}
}
CloseService();
return tb;
}
public override List<MillesimoDTO> GetMillesimiByContoLottoStabileScala(ContoDTO conto, int? idLotto, int? idStabile, int? idGruppo, EsercizioDTO esercizio)
{
int? idEsercizio = null;
if (esercizio != null)
idEsercizio = esercizio.ID;
var idConti = new List<int> { conto.ID };
var filter = new MillesimiFilter
{
CodiceCondominio = conto.IdCondominio,
IdConti = idConti,
CodiceLotto = idLotto,
CodiceScala = idGruppo,
CodiceStabile = idStabile,
IdEsercizio = idEsercizio
};
try
{
var result = GetServiceClient().GetMillesimiByFilter(filter, 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);
}
return new List<MillesimoDTO>();
}
