private string updateDettaglio(DettaglioSpesaDTO dto, DettaglioSpesa dtoMultiIva, out DettaglioSpesa item)
{
var message = string.Empty;
item = null;
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
try
{
item = daoFactory.GetDettaglioSpesaDao().GetById(dto.ID, false);
// Condizione necessaria per il controllo del fatto che sul DB ho una versione uguale o più vecchia
if (dto.Version == item.Version)
{
item.AliquotaIva = dto.AliquotaIva;
item.ImportoIva = dto.ImportoIva;
item.ImportoLordo = dto.ImportoLordo - item.SpesaRiferimento.AltreSpese.GetValueOrDefault();
item.Note = dto.Note;
item.NumeroRiga = dto.NumeroRiga;
item.SoggettoRitenutaAcconto = dto.SoggettoRitenutaAcconto;
item.Descrizione = dto.Descrizione;
item.ModelloRipartizione = dto.IdModelloRipartizione != null ? daoFactory.GetModelloRegistrazioneContabileDao().GetById(dto.IdModelloRipartizione.Value, false) : null;
// ------------------------------------------
// Movimenti contabili
// ------------------------------------------
item.Movimenti.Clear();
for (int i = 0; i < dto.Movimenti.Length; i++)
{
dto.Movimenti[i].IdDettaglio = item.ID;
// Se non è valorizzata alcun sottoconto e nessuna descrizione uso la descrione presente sul dettaglio
if (dto.Movimenti[i].IdSottoConto == null && (dto.Movimenti[i].Descrizione == null || dto.Movimenti[i].Descrizione.Trim() == string.Empty))
dto.Movimenti[i].Descrizione = item.Descrizione;
int? id = dto.Movimenti[i].ID;
if (id.GetValueOrDefault() > 0)
{
var movimentoCheck = daoFactory.GetMovimentoContabileDao().Find(id.GetValueOrDefault(), false);
if (movimentoCheck == null)
dto.Movimenti[i].ID = 0;
}
if ((dto.Movimenti[i].Stato == "U") || (dto.Movimenti[i].Stato == "I"))
{
var result = getMovimentoRepository().ManageDomainEntity(dto.Movimenti[i]);
if (result.Movimento != null)
id = result.Movimento.ID;
else
return result.Message;
}
var movimento = daoFactory.GetMovimentoContabileDao().GetById(id.Value, false);
item.Movimenti.Add(movimento);
movimento.DettaglioRiferimento = item;
if (dtoMultiIva != null)
{
var movimentoPrincipale = IesiGenericCollections<MovimentoContabile>.GetByIndex(dtoMultiIva.Movimenti, i);
if (movimentoPrincipale != null && movimentoPrincipale.ContoRiferimento != null && movimentoPrincipale.ContoRiferimento.ID == movimento.ContoRiferimento.ID)
movimento.MovimentoPrincipaleMultiIva = movimentoPrincipale;
}
}
}
else
{
// Eccezione: Sul db c'è qualche cosa di più nuovo.
_log.Error("Errore nel salvataggio del dettaglio Spesa id:" + dto.ID + " - il dato sul db è più recente di quello che si vuole salvare");
message = "Errore nel salvataggio del dettaglio Spesa id:" + dto.ID + " - il dato sul db è più recente di quello che si vuole salvare";
}
}
catch (Exception ex)
{
_log.Error("Errore nel salvataggio del dettaglio Spesa: " + Utility.GetMethodDescription() + " - id:" + dto.ID, ex);
throw;
}
return message;
}
private string insertDettaglio(DettaglioSpesaDTO dto, DettaglioSpesa dettaglioMultiIva, out DettaglioSpesa item)
{
string message = string.Empty;
item = null;
try
{
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
item = new DettaglioSpesa(daoFactory.GetSpesaDao().GetById(dto.IdSpesaRiferimento, false),dto.NumeroRiga) {AliquotaIva = dto.AliquotaIva, ImportoIva = dto.ImportoIva};
item.ImportoLordo = dto.ImportoLordo - item.SpesaRiferimento.AltreSpese.GetValueOrDefault();
item.Note = dto.Note;
item.SoggettoRitenutaAcconto = dto.SoggettoRitenutaAcconto;
item.Descrizione = dto.Descrizione;
if(dto.IdModelloRipartizione != null)
item.ModelloRipartizione = daoFactory.GetModelloRegistrazioneContabileDao().GetById(dto.IdModelloRipartizione.Value, false);
daoFactory.GetDettaglioSpesaDao().SaveOrUpdate(item);
// ------------------------------------------
// Movimenti contabili
// ------------------------------------------
item.Movimenti.Clear();
for (var i = 0; i < dto.Movimenti.Length; i++)
{
try
{
dto.Movimenti[i].IdDettaglio = item.ID;
// Se non è valorizzata alcun sottoconto e nessuna descrizione uso la descrione presente sul dettaglio
if (dto.Movimenti[i].IdSottoConto == null && (dto.Movimenti[i].Descrizione == null || dto.Movimenti[i].Descrizione.Trim() == string.Empty))
dto.Movimenti[i].Descrizione = item.Descrizione;
int? id = dto.Movimenti[i].ID;
if ((dto.Movimenti[i].Stato == "U") || (dto.Movimenti[i].Stato == "I"))
{
// Se è presente modello recupero eventuali ripartizioni personalizzate
if (item.ModelloRipartizione != null)
{
var contiModelloRegistrazioneContabile = item.ModelloRipartizione.Conti.ToList()[i];
if (contiModelloRegistrazioneContabile != null)
{
var listaUnita = contiModelloRegistrazioneContabile.Unita.Where(unita => unita.UnitaRiferimento != null).ToList();
if (listaUnita.Count > 0)
{
dto.Movimenti[i].DettaglioRipartizione = new SpeseUnitaDTO[listaUnita.Count];
for (var j = 0; j < listaUnita.Count; j++)
{
dto.Movimenti[i].DettaglioRipartizione[j] = new SpeseUnitaDTO { IdUnitaRiferimento = listaUnita.ToList()[j].UnitaRiferimento.ID };
if (contiModelloRegistrazioneContabile.ContoRiferimento.IsSpesePersonali && listaUnita.Count == 1)
dto.Movimenti[i].DettaglioRipartizione[j].Importo = dto.Movimenti[i].Importo;
}
if (dto.Movimenti[i].DettaglioRipartizione.Length > 0)
dto.Movimenti[i].IsRipartoPersonalizzato = true;
}
}
}
var resultMovimento = getMovimentoRepository().ManageDomainEntity(dto.Movimenti[i]);
if (resultMovimento.Movimento != null)
id = resultMovimento.Movimento.ID;
else
return resultMovimento.Message;
}
var movimento = daoFactory.GetMovimentoContabileDao().GetById(id.Value, false);
if (dettaglioMultiIva != null)
{
var movimentoPrincipale = IesiGenericCollections<MovimentoContabile>.GetByIndex(dettaglioMultiIva.Movimenti, i);
if (movimentoPrincipale != null && movimentoPrincipale.ContoRiferimento != null && movimentoPrincipale.ContoRiferimento.ID == movimento.ContoRiferimento.ID)
movimento.MovimentoPrincipaleMultiIva = movimentoPrincipale;
}
item.Movimenti.Add(movimento);
movimento.DettaglioRiferimento = item;
if (item.ModelloRipartizione != null)
{
movimento.LottiAddebito = getAddebito("L", item.ModelloRipartizione, i);
movimento.StabiliAddebito = getAddebito("S", item.ModelloRipartizione, i);
movimento.GruppiAddebito = getAddebito("G", item.ModelloRipartizione, i);
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nell'inserimento del dettaglio Spesa - SINGOLO MOVIMENTO - {0} - movimento:{1} - spesa:{2}", ex, Utility.GetMethodDescription(), dto.Movimenti[i].ID, dto.IdSpesaRiferimento);
throw;
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nell'inserimento del dettaglio Spesa - {0} - spesa:{1} - modello:{2}", ex, Utility.GetMethodDescription(), dto.IdSpesaRiferimento, dto.IdModelloRipartizione);
message = "Errore nell'inserimento del dettaglio Spesa: " + Utility.GetMethodDescription();
}
return message;
}
public MovimentoContabile SetMovimentiStornoScadenza(DettaglioSpesa dettaglioSpesa, ScadenzaFattura scadenza, decimal importo, Esercizio esercizio, DateTime dataRegistrazione)
{
try
{
var message = IsAllowDataRegistrazione(new List<int> { scadenza.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
if (message.Count == 0)
{
var numeroRiga = 0;
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("SS");
// ================================================
// Testata
// ================================================
var testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null);
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
// ================================================
// Debiti VS Fornitori
// ================================================
numeroRiga++;
var segno = "D";
if (importo < 0)
{
segno = "A";
importo = importo * -1;
}
var movimentoPatrimoniale = new MovimentoContabile(testata, scadenza.SpesaRiferimento.FornitoreRiferimento, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(scadenza.SpesaRiferimento.EsercizioRiferimento.ID, scadenza.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoFornitori()), importo, segno)
{
Descrizione = "Storno Fatt. n." + scadenza.SpesaRiferimento.NumeroDocumento + " del " + scadenza.SpesaRiferimento.DataDocumento.GetValueOrDefault().ToShortDateString()
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);
// ================================================
// Conto Economico
// ================================================
var importoTotale = 0m;
numeroRiga++;
if (scadenza.SpesaRiferimento.TipoDocumento != "FATBILAPP")
{
var movimenti = new List<MovimentoContabile>();
// Se è una FATTURA ......
if (scadenza.SpesaRiferimento.Dettagli.Count > 0)
{
importoTotale = scadenza.SpesaRiferimento.Dettagli.Sum(item => item.Movimenti.Sum(item2 => item2.GetImportoConSegno().GetValueOrDefault()));
foreach (var dettaglio in scadenza.SpesaRiferimento.Dettagli)
movimenti.AddRange(dettaglio.Movimenti);
}
// .... oppure una BOLLETTA
else if (scadenza.SpesaRiferimento.MovimentiBollette.Count > 0)
{
importoTotale = scadenza.SpesaRiferimento.MovimentiBollette.Sum(item => item.GetImportoConSegno().GetValueOrDefault());
movimenti.AddRange(scadenza.SpesaRiferimento.MovimentiBollette);
}
foreach (var movimento in movimenti)
{
var movimentoEconomico = new MovimentoContabile(testata, causale, numeroRiga, movimento.ContoRiferimento, (importo * movimento.GetImportoConSegno()) / importoTotale, invertiSegno(movimento.Segno))
{
SottoContoRiferimento = movimento.SottoContoRiferimento,
Descrizione = movimento.GetDescrizione(),
IsRipartoPersonalizzato = movimento.IsRipartoPersonalizzato,
LottiAddebito = movimento.LottiAddebito,
StabiliAddebito = movimento.StabiliAddebito,
GruppiAddebito = movimento.GruppiAddebito,
FornitoreRiferimento = movimento.FornitoreRiferimento,
DettaglioRiferimento = dettaglioSpesa
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoEconomico);
// Se è presente una ripartizione personalizzata o una spesa personale deve salvare anche il riparto.
foreach (var itemRiparto in movimento.DettaglioRipartizione)
{
var importoRiparto = (itemRiparto.Importo.GetValueOrDefault()*movimentoEconomico.Importo.GetValueOrDefault()/movimento.Importo.GetValueOrDefault()) * -1;
var spesaUnita = itemRiparto.MovimentoRiferimento.ContoRiferimento.IsSpesePersonali ? new SpeseUnita(importoRiparto, null, itemRiparto.SoggettoCondominio, movimentoEconomico) : new SpeseUnita(importoRiparto, itemRiparto.UnitaRiferimento, null, movimentoEconomico);
_daoFactory.GetSpeseUnitaDao().SaveOrUpdate(spesaUnita);
}
movimento.MovimentoStorno = movimentoEconomico;
}
}
// Se si tratta di fattura da Bilancio di Apertura lo storno avviene esclusivamente dal conto Bancario
else
{
var movimentoEconomico = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoBancario()), importo, invertiSegno(movimentoPatrimoniale.Segno))
{
ContoCorrenteBancario = esercizio.CondominioRiferimento.DatiBancariPrincipale,
Descrizione = movimentoPatrimoniale.Descrizione
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoEconomico);
}
return movimentoPatrimoniale;
}
var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", dataRegistrazione));
_log.ErrorFormat("Data di registrazione non valida - {0} - data:{1} - scadenza:{2} - importo:{3}", ex, Utility.GetMethodDescription(), dataRegistrazione, scadenza.ID, importo);
throw ex;
}
catch (Exception ex)
{
_log.Fatal("Errore inaspettato nella funzione - " + Utility.GetMethodDescription() + " - data:" + dataRegistrazione + " - scadenza:" + scadenza.ID + " - importo:" + importo, ex);
throw;
}
}
private DettaglioSpesaDTO setDettaglioDto(DettaglioSpesa dettaglio, bool includeDettaglioMovimenti, bool detrazione = false)
{
try
{
var dto = new DettaglioSpesaDTO
{
ID = dettaglio.ID,
AliquotaIva = dettaglio.AliquotaIva,
Descrizione = dettaglio.Descrizione,
IdSpesaRiferimento = dettaglio.SpesaRiferimento.ID,
Imponibile = dettaglio.Imponibile,
ImportoIva = dettaglio.ImportoIva,
ImportoLordo = dettaglio.ImportoLordo,
Note = dettaglio.Note,
NumeroRiga = dettaglio.NumeroRiga,
SoggettoRitenutaAcconto = dettaglio.SoggettoRitenutaAcconto,
Version = dettaglio.Version
};
if (dettaglio.ModelloRipartizione != null)
dto.IdModelloRipartizione = dettaglio.ModelloRipartizione.ID;
// ------------------------------------------
// Movimenti contabili
// ------------------------------------------
var indexMovimento = 0;
dto.Movimenti = new MovimentoContabileDTO[dettaglio.Movimenti.Count];
foreach (var movimento in dettaglio.Movimenti)
{
var movimentoDto = getMovimentoRepository().GetByDomainEntity(movimento, includeDettaglioMovimenti, true, detrazione);
movimentoDto.Segno = "D";
dto.Movimenti[indexMovimento] = movimentoDto;
indexMovimento++;
}
return dto;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella creazione dell'istanza DTO per un dettaglio di una spesa - {0} - dettaglio:{1}", ex, Utility.GetMethodDescription(), dettaglio.ID);
throw;
}
}
public void ReloadRipartizioneByDettaglio(DettaglioSpesa dettaglio)
{
foreach (var movimento in dettaglio.Movimenti)
ReloadRipartizioneByMovimento(movimento);
}
public string StornoNoteAccredito(int idNota, IList<StornoScadenzaDTO> scadenze, DettaglioSpesa dettaglioSpesa, Esercizio esercizio, DateTime dataRegistrazione)
{
try
{
var message = string.Empty;
var nota = _daoFactory.GetSpesaDao().GetById(idNota, false);
Disposizione disposizione = null;
if (nota.Riscossioni.Count > 0)
{
var riscossione = IesiGenericCollections<Riscossione>.GetByIndex(nota.Riscossioni, 0);
if (riscossione.Pagamenti.Count > 0)
disposizione = IesiGenericCollections<Pagamento>.GetByIndex(riscossione.Pagamenti, 0).DisposizioneRiferimento;
}
if (disposizione == null)
{
disposizione = new Disposizione($"Storno da nota accredito n.{nota.NumeroDocumento} del:{nota.DataDocumento.GetValueOrDefault():d}", dataRegistrazione, nota.EsercizioRiferimento.CondominioRiferimento.Azienda, null);
_daoFactory.GetDisposizioneDao().SaveOrUpdate(disposizione);
}
//==============================================================
// Controlli
//==============================================================
IList<ScadenzaFattura> scadenzeFattura = new List<ScadenzaFattura>();
foreach (var scadenzaImporto in scadenze)
{
var scadenza = _daoFactory.GetScadenzaFatturaDao().GetById(scadenzaImporto.Id, false);
scadenzeFattura.Add(scadenza);
if (scadenza.Stato != StatoSpesaEnum.Pagata && scadenza.Stato != StatoSpesaEnum.ParzialmentePagata && scadenzaImporto.Importo > scadenza.Importo.GetValueOrDefault() - scadenza.ImportoPagato)
message += $"L'importo {scadenzaImporto.Importo:c} è superiore al residuo da pagare: {(scadenza.Importo.GetValueOrDefault() - scadenza.ImportoPagato):c}{Environment.NewLine}";
}
//==============================================================
// Verifico se devo impostare automaticamente la detrazione
//==============================================================
try
{
if (scadenzeFattura.All(item => item.SpesaRiferimento.Detrazione.GetValueOrDefault() == 36))
nota.Detrazione = 36;
else if (scadenzeFattura.All(item => item.SpesaRiferimento.Detrazione.GetValueOrDefault() == 55))
nota.Detrazione = 55;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella impostazione automatica della detrazione per una nota di accredito - {0} - idNota:{1}", ex, Utility.GetMethodDescription(), idNota);
}
//==============================================================
// Cancellazione riscossioni esistenti
//==============================================================
IList<Riscossione> riscossioni = nota.Riscossioni.ToList();
nota.Riscossioni.Clear();
nota.TestateMovimenti.Clear();
var movimentiToDelete = new List<int>();
foreach (var riscossione in riscossioni)
{
riscossione.ScadenzaRiferimento = null;
riscossione.SpesaRiferimento = null;
// Memorizzazione dei movimenti da cancellare, la cancellazione NON viene eseguita ora
// per evitare problemi nella successione degli script eseguiti sul database da NHibernate
if (riscossione.MovimentoContabile != null)
movimentiToDelete.Add(riscossione.MovimentoContabile.ID);
riscossione.MovimentoContabile = null;
riscossione.Pagamenti.Clear();
_daoFactory.GetRiscossioneDao().Delete(riscossione);
}
IList<Pagamento> pagamenti = disposizione.Pagamenti.ToList();
disposizione.Pagamenti.Clear();
foreach (var pagamento in pagamenti)
{
pagamento.DisposizioneRiferimento = null;
if (pagamento.ScadenzaRiferimento != null)
pagamento.ScadenzaRiferimento.Pagamenti.Remove(pagamento);
pagamento.ScadenzaRiferimento = null;
if (pagamento.NotaStorno != null)
pagamento.NotaStorno.Pagamenti.Remove(pagamento);
pagamento.NotaStorno = null;
pagamento.File = null;
pagamento.MovimentoContabile = null;
pagamento.MovimentoContabileStorno = null;
_daoFactory.GetPagamentoDao().Delete(pagamento);
}
//==============================================================
// Esecuzione
//==============================================================
if (string.IsNullOrEmpty(message))
{
foreach (var scadenzaImporto in scadenze)
{
var scadenza = _daoFactory.GetScadenzaFatturaDao().GetById(scadenzaImporto.Id, false);
var pagamento = new Pagamento(scadenza, disposizione, scadenzaImporto.Importo, dataRegistrazione, TipoPagamentoFatturaEnum.Storno)
{
RitenutaAcconto = new Ritenuta(scadenzaImporto.ImportoRitenuta) { Stato = StatoRitenutaEnum.Stornata },
Stato = StatoSpesaEnum.Pagata
};
_daoFactory.GetPagamentoDao().SaveOrUpdate(pagamento);
var riscossione = new Riscossione(nota, scadenzaImporto.Importo);
_daoFactory.GetRiscossioneDao().SaveOrUpdate(riscossione);
riscossione.ImportoRitenuta = (scadenza.ImportoRitenuta * scadenzaImporto.Importo) / scadenza.Importo;
riscossione.DataRitenuta = dataRegistrazione;
riscossione.Pagamenti.Add(pagamento);
riscossione.ScadenzaRiferimento = scadenza;
pagamento.NotaStorno = riscossione;
riscossione.MovimentoContabile = _movimentiContabilitaService.SetMovimentiStornoScadenza(dettaglioSpesa, scadenza, scadenzaImporto.Importo + scadenzaImporto.ImportoRitenuta, esercizio, dataRegistrazione);
riscossione.MovimentoContabile.Testata.SpesaRiferimento = nota;
nota.TestateMovimenti.Add(riscossione.MovimentoContabile.Testata);
scadenza.SetStato();
if (scadenza.Stato == StatoSpesaEnum.Pagata)
scadenza.Stato = StatoSpesaEnum.Stornata;
}
// Cancellazione dei movimenti precedentemente individuati, la cancellazione viene eseguita solo ora
// per evitare problemi nella successione degli script eseguiti sul database da NHibernate
foreach (var idMovimentoContabile in movimentiToDelete)
_movimentiContabilitaService.DeleteMovimento(idMovimentoContabile);
}
return message;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nello storno di una fattura - {0} - idNota:{1}", ex, Utility.GetMethodDescription(), idNota);
throw;
}
}
/// <summary>
/// Crea un movimento contabile valido.
/// E' relativo al conto economico connesso alla registrazione di una spesa
/// </summary>
public MovimentoContabile(TestataMovimentoContabile testata, DettaglioSpesa dettaglio, CausaleContabile causale, int? numeroRiga, Conto conto, decimal? importo, string segno)
{
Causale = causale;
DettaglioRiferimento = dettaglio;
NumeroRiga = numeroRiga;
ContoRiferimento = conto;
Testata = testata;
Importo = importo;
Segno = segno;
Stato = StatoMovimentoContabileEnum.Inserito;
IsVisibileGestione = true;
if (Testata != null)
{
Testata.Movimenti.Add(this);
setNumeroRegistrazione();
}
if (DettaglioRiferimento != null)
DettaglioRiferimento.Movimenti.Add(this);
}
public DettaglioSpesaDTO GetDettaglioByDomainEntity(DettaglioSpesa dettaglio)
{
try
{
return setDettaglioDto(dettaglio, false);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella gestione dei dettagli delle Fatture/Spese - {0} - id:{1}", ex, Utility.GetMethodDescription(), dettaglio.ID);
throw;
}
}
public SpesaInfoDTO SalvaFiscale(SpesaFiscaleDTO dto)
{
try
{
var message = string.Empty;
var fornitore = _daoFactory.GetFornitoreDao().GetById(dto.IdFornitore, false);
var esercizio = _daoFactory.GetEsercizioDao().Find(dto.IdEsercizio, false);
if (esercizio == null)
throw new InvalidDataException("L'esercizio selezionato non è più presente in archivio.");
GestioneCondomini.Domain.Spesa spesa;
if (dto.ID == 0)
{
spesa = new GestioneCondomini.Domain.Spesa(fornitore, esercizio, null);
var protocollo = _protocolloService.GetProgressivo(TipoProtocollo.Fattura, esercizio.DataApertura.GetValueOrDefault().Year, esercizio.CondominioRiferimento);
if (protocollo.Progressivo != null)
{
spesa.NumeroProtocollo = protocollo.Progressivo;
_daoFactory.GetSpesaDao().SaveOrUpdate(spesa);
}
else
message = protocollo.Message + Environment.NewLine;
}
else
{
spesa = _daoFactory.GetSpesaDao().GetById(dto.ID, false);
spesa.FornitoreRiferimento = fornitore;
spesa.EsercizioRiferimento = esercizio;
}
var info = new SpesaInfoDTO();
if (string.IsNullOrEmpty(message))
{
spesa.ImportoRitenuta = dto.Scadenze.Sum(item => item.ImportoRitenuta);
spesa.AltreSpese = dto.AltreSpese;
spesa.AltreSpeseEsenti = dto.SpeseEsenti;
spesa.SpeseEsentiRitenuta = dto.SpeseEsentiRitenuta;
spesa.CassaProfessionisti = dto.CassaProfessionisti;
spesa.DataDocumento = dto.DataDocumento;
spesa.NumeroDocumento = dto.NumeroDocumento;
spesa.AliquotaRitenuta = dto.AliquotaRitenuta;
spesa.IsAbilitataArchiviazioneOttica = dto.IsAbilitataArchiviazioneOttica;
spesa.IsRitenutaCalcoloImponibile = dto.IsRitenutaCalcoloImponibile;
spesa.Stato = StatoSpesaEnum.Pagata;
spesa.TipoDocumento = dto.TipoDocumento;
spesa.Detrazione = dto.Detrazione;
spesa.EsenteRegimeMinimo = dto.EsenteRegimeMinimo;
// ----------------------------------------------------
// Dettagli
// ----------------------------------------------------
spesa.Dettagli.Clear();
var index = 0;
foreach (var dtoDettaglio in dto.Dettagli)
{
index++;
DettaglioSpesa dettaglio;
if (dtoDettaglio.ID == 0)
dettaglio = new DettaglioSpesa(spesa, index);
else
{
dettaglio = _daoFactory.GetDettaglioSpesaDao().GetById(dtoDettaglio.ID, false);
dettaglio.NumeroRiga = index;
spesa.Dettagli.Add(dettaglio);
}
dettaglio.AliquotaIva = dtoDettaglio.AliquotaIva;
dettaglio.Descrizione = dtoDettaglio.Descrizione;
dettaglio.ImportoIva = dtoDettaglio.ImportoIva;
dettaglio.ImportoLordo = dtoDettaglio.ImportoLordo;
dettaglio.SoggettoRitenutaAcconto = dtoDettaglio.SoggettoRitenutaAcconto;
}
// ----------------------------------------------------
// Scadenze / Pagamenti
// ----------------------------------------------------
// Pulizia movimenti, scadenze e pagamenti presenti
foreach (var scadenza in spesa.Scadenze)
{
foreach (var pagamento in scadenza.Pagamenti)
_daoFactory.GetPagamentoDao().Delete(pagamento);
_daoFactory.GetScadenzaFatturaDao().Delete(scadenza);
}
spesa.Scadenze.Clear();
foreach (var scadenzaDto in dto.Scadenze)
{
var scadenzaNew = new ScadenzaFattura(spesa, scadenzaDto.DataPagamento, scadenzaDto.Importo) { Stato = StatoSpesaEnum.Pagata };
var pagamentoNew = new Pagamento(scadenzaNew, null, scadenzaNew.Importo, scadenzaNew.Scadenza, TipoPagamentoFatturaEnum.Immediato) { Stato = StatoSpesaEnum.Pagata };
scadenzaNew.Pagamenti.Add(pagamentoNew);
_daoFactory.GetScadenzaFatturaDao().SaveOrUpdate(scadenzaNew);
// -----------------------------------------------------
// Ritenuta
// -----------------------------------------------------
// ritenuta PAGATA dal vecchio amministratore i dati, compresi interessi e sanzioni servono per il modello 770
var ritenuta = new Ritenuta(scadenzaDto.ImportoRitenuta);
if (!scadenzaDto.RitenutaNONPagata)
{
ritenuta.Stato = StatoRitenutaEnum.PagataAltroAmministratore;
ritenuta.DataPagamentoRitenuta = scadenzaDto.DataPagamentoRitenuta;
ritenuta.ImportoInteressi = scadenzaDto.ImportoInteressi;
ritenuta.ImportoSanzione = scadenzaDto.ImportoSanzioni;
}
// ritenuta NON Pagata inserita come da pagare
else
{
ritenuta.Stato = StatoRitenutaEnum.Inserita;
ritenuta.DataPagamentoRitenuta = null;
_daoFactory.GetSpesaDao().SaveOrUpdate(spesa);
_movimentoContabileService.SetMovimentiRitenutaPagataAltroAmministratore(spesa, scadenzaDto.DataPagamento.GetValueOrDefault());
}
pagamentoNew.RitenutaAcconto = ritenuta;
}
info = new SpesaInfoDTO
{
Id = spesa.ID,
NumeroProtocollo = spesa.NumeroProtocollo.GetValueOrDefault(),
};
if (spesa.IsAbilitataArchiviazioneOttica)
{
var impostazioni = _daoFactory.GetImpostazioniAziendaDao().GetByAzienda(spesa.EsercizioRiferimento.CondominioRiferimento.Azienda.ID);
info.IdentificativoArchiviazione = _archiviazioneService.GetIdentificativoArchiviazione(spesa);
info.StampaEtichettaArchiviazione = impostazioni.UtilizzoEtichettatriceArchiviazioneOtticaFatture && spesa.EsercizioRiferimento.CondominioRiferimento.IsAbilitataArchiviazioneOtticaPassivi.GetValueOrDefault();
info.EtichettatriceArchiviazione = impostazioni.EtichettatriceArchiviazioneOttica;
info.TipoEtichettaArchiviazione = impostazioni.TipoEtichettaArchiviazioneOttica;
}
spesa.Stato = StatoSpesaEnum.PagataAltroAmministratore;
}
else
info.Message = message;
return info;
}
catch (Exception ex)
{
_log.Fatal("Errore inaspettato nel salvataggio della spesa FISCALE - " + Utility.GetMethodDescription() + " - spesa:" + dto.ID, ex);
throw;
}
}
public BilancioAperturaMessage SetBilancioApertura(TestataMovimentoContabileGestioneDTO testata)
{
try
{
var fatalMessage = string.Empty;
var warnMessage = string.Empty;
//==============================================
// Controllo esercizio
//==============================================
if (testata.CodiceEsercizio == 0)
{
_log.ErrorFormat("Non è definito alcun esercizio - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage("Non è definito alcun esercizio", string.Empty, false);
}
var esercizio = _daoFactory.GetEsercizioDao().Find(testata.CodiceEsercizio, false);
if(esercizio == null)
{
_log.ErrorFormat("L'esercizio non è stato trovato - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage($"L'esercizio '{testata.CodiceEsercizio}' non è stato trovato.", string.Empty, false);
}
if(esercizio.Gestione == GestioneEsercizioEnum.Straordinario)
{
_log.ErrorFormat("L'esercizio deve essere un esercizio ordinario - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage("L'esercizio deve essere un esercizio ordinario", string.Empty, false);
}
//==============================================
// Controllo Saldi Condomini
//==============================================
var saldiCondomini = _daoFactory.GetSaldoSoggettoDao().GetByEsercizioStabileScala(esercizio, null, null);
var contoCreditiCondomini = _daoFactory.GetContoDao().GetAllByCodice(esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoVersamentiCondomini()).FirstOrDefault(item => item.EsercizioRiferimento == null);
if (contoCreditiCondomini != null)
{
var movimentiVersamentiCondomini = testata.Movimenti.Where(item => item.IdConto == contoCreditiCondomini.ID).ToList();
if (movimentiVersamentiCondomini.Count > 1)
{
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage($"Non può essere presente più di un movimento per il conto {contoCreditiCondomini.Codice} - {contoCreditiCondomini.Descrizione}", string.Empty, false);
}
if (movimentiVersamentiCondomini.Count == 1)
{
var importoCreditiCondomini = movimentiVersamentiCondomini.Sum(item => item.ImportoDare.GetValueOrDefault() - item.ImportoAvere.GetValueOrDefault());
if (importoCreditiCondomini > 0)
{
if (saldiCondomini.Count == 0)
{
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage("Prima di registrare il bilancio di apertura occorre inserire i saldi iniziali dei singoli condomini", string.Empty, true);
}
var totaleSaldiCondomini = saldiCondomini.Sum(item => item.Importo);
if (importoCreditiCondomini != totaleSaldiCondomini)
{
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage($"L'importo del conto crediti v/condomini: {importoCreditiCondomini:c} non corrisponde con la somma dei saldi dei singoli condomini: {totaleSaldiCondomini:c}", string.Empty, true);
}
}
}
}
//==============================================
// Controllo data registrazione
//==============================================
if (testata.DataRegistrazione == null || !Conversione.IsSqlSmallDateTime(testata.DataRegistrazione.GetValueOrDefault()))
{
_log.ErrorFormat("Non è definita la data di registrazione - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage("Non è definita la data di registrazione", string.Empty, false);
}
if(testata.DataRegistrazione.GetValueOrDefault() < esercizio.DataApertura.GetValueOrDefault())
{
_log.DebugFormat("La data di registrazione è inferiore alla data di apertura dell'esercizio - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage("La data di registrazione è inferiore alla data di apertura dell'esercizio", string.Empty, false);
}
//==============================================
// Controllo correttezza importi
//==============================================
if (testata.Movimenti == null)
{
_log.FatalFormat("I movimenti sono a null - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage("I movimenti sono a null", string.Empty, false);
}
if (testata.Movimenti.Sum(mov => mov.ImportoDare.GetValueOrDefault()) != testata.Movimenti.Sum(mov => mov.ImportoAvere.GetValueOrDefault()))
fatalMessage = $"Il totale Dare:{testata.Movimenti.Sum(mov => mov.ImportoDare.GetValueOrDefault()):c} non corrisponde col totale Avere:{testata.Movimenti.Sum(mov => mov.ImportoAvere.GetValueOrDefault()):c}.{Environment.NewLine}";
else
{
var listaDettagli = new Dictionary<int, DettaglioSpesa>();
// ==============================================================================================================
// Se il bilancio di apertura NON è registrato nel primo esercizio occorre registrare solo i movimenti contabili
// ==============================================================================================================
if (IsRequiredDatiFatturaBilancioApertura(esercizio.ID))
{
// ===============================================
// Controllo movimenti
// ===============================================
foreach (var dto in testata.Movimenti)
{
if (dto.Stato == "U")
{
var messageControllo = IsAllowUpdateMovimentoBilancioApertura(dto.ID, dto.IdSpesa);
if (string.IsNullOrEmpty(messageControllo))
{
// ------------------------------------------------------------------------------------
// Se il conto non è Fornitori e Ritenuta devo cancellare l'eventuale spesa associata
// ------------------------------------------------------------------------------------
var conto = _daoFactory.GetContoDao().GetById(dto.IdConto.GetValueOrDefault(), false);
if (conto.Codice == _pianoContiService.GetCodiceContoFornitori() || conto.Codice == _pianoContiService.GetCodiceContoRitenuta())
dto.IdSpesa = 0;
else
{
if (dto.IdSpesa > 0)
{
var messageDeleteSpesa = IsAllowDelete(dto.IdSpesa);
if (!string.IsNullOrEmpty(messageDeleteSpesa.FatalMessage))
return new BilancioAperturaMessage(messageDeleteSpesa.FatalMessage, string.Empty, false);
else
{
var movimento = _daoFactory.GetMovimentoContabileDao().Find(dto.ID, false);
if(movimento != null)
{
movimento.Spesa = null;
movimento.Testata.Movimenti.Remove(movimento);
movimento.Testata = null;
_daoFactory.GetMovimentoContabileDao().Delete(movimento);
}
Delete(dto.IdSpesa);
dto.ID = 0;
dto.IdSpesa = 0;
dto.IdFornitore = 0;
dto.NumeroDocumento = null;
dto.DataDocumento = null;
dto.ImportoFattura = null;
dto.ImportoIva = null;
dto.ImportoRitenuta = null;
dto.InteressiRitenuta = null;
dto.SanzioniRitenuta = null;
dto.AliquotaRitenuta = null;
dto.AltreSpese = null;
dto.AltreSpeseEsenti = null;
dto.DataPagamento = null;
dto.DataVersamentoRitenuta = null;
}
}
}
}
else
{
fatalMessage += messageControllo + Environment.NewLine;
_log.WarnFormat("{0} - {1} - testata:{2}", fatalMessage, Utility.GetMethodDescription(), testata.ID);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage(fatalMessage, string.Empty, false);
}
}
}
var index = 0;
// ===============================================
// Elaborazione di tutti i movimenti
// ===============================================
foreach (var movimento in testata.Movimenti)
{
try
{
if (movimento.Stato == "U")
{
if (movimento.IdConto == null)
{
_log.FatalFormat("I movimenti sono a null - 2 - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage($"Non è presente il conto per la riga:{movimento.NumeroRiga.GetValueOrDefault()}", string.Empty, false);
}
index++;
if (movimento.ID == 0)
movimento.ID = index*-1;
// ----------------------------------------------------------
// Se è presente il fornitore devo gestire la fattura
// ----------------------------------------------------------
var conto = _daoFactory.GetContoDao().GetById(movimento.IdConto.GetValueOrDefault(), false);
if (movimento.IdFornitore > 0 && (conto.Codice == _pianoContiService.GetCodiceContoFornitori() || conto.Codice == _pianoContiService.GetCodiceContoRitenuta()))
{
var fornitore = _daoFactory.GetFornitoreDao().GetById(movimento.IdFornitore.GetValueOrDefault(), false);
// ----------------------------------
// Importi
// ----------------------------------
decimal importo;
decimal? importoRitenuta = null;
try
{
if (movimento.ImportoAvere.GetValueOrDefault() > 0)
{
importo = movimento.ImportoAvere.GetValueOrDefault() - movimento.AltreSpeseEsenti.GetValueOrDefault();
importoRitenuta = movimento.ImportoRitenuta;
}
else
{
importo = (movimento.ImportoDare.GetValueOrDefault() - movimento.AltreSpeseEsenti.GetValueOrDefault()) * -1;
if(movimento.ImportoRitenuta != null)
importoRitenuta = movimento.ImportoRitenuta.GetValueOrDefault()*-1;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - IMPORTI - {0} - idTestata:{1}", ex, Utility.GetMethodDescription(), testata.ID);
throw;
}
// ----------------------------------
// Spesa
// ----------------------------------
GestioneCondomini.Domain.Spesa spesa;
try
{
if (movimento.ID > 0)
{
var mov = _daoFactory.GetMovimentoContabileDao().Find(movimento.ID, false);
if (mov != null)
{
if (mov.Spesa != null)
spesa = mov.Spesa;
else
{
if (mov.DettaglioRiferimento?.SpesaRiferimento == null)
{
var messageSpesa = getNewSpesa(fornitore, esercizio, testata, movimento, out spesa);
if (!string.IsNullOrEmpty(messageSpesa))
{
fatalMessage += messageSpesa + Environment.NewLine;
_log.ErrorFormat("Errore nella generazione della spesa - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage(fatalMessage, string.Empty, false);
}
}
else
spesa = mov.DettaglioRiferimento.SpesaRiferimento;
}
}
else
{
int? idMov = null;
if (mov != null)
idMov = mov.ID;
_log.ErrorFormat("Non è stato trovato il movimento contabile - {0} - id:{1}", Utility.GetMethodDescription(), idMov);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage("Non è stato trovato il movimento contabile", string.Empty, false);
}
if (spesa != null)
spesa.FornitoreRiferimento = fornitore;
}
else
{
spesa = new GestioneCondomini.Domain.Spesa(fornitore, esercizio, null);
try
{
if (_protocolloService == null)
{
_log.ErrorFormat("Errore di inizializzazione del protocollo service - {0} - idEsercizio:{1} - idTestata:{2}", Utility.GetMethodDescription(), testata.CodiceEsercizio, testata.ID);
fatalMessage = "Errore di inizializzazione del protocollo service.";
}
if (movimento.DataDocumento == null)
{
_log.ErrorFormat("La data del documento è null - {0} - documento:{1} - movimento:{2} - esercizio:{3} - testata:{4}", Utility.GetMethodDescription(), movimento.NumeroDocumento, movimento.ID, testata.CodiceEsercizio, testata.ID);
fatalMessage = "La data del documento è null.";
}
if (esercizio.CondominioRiferimento == null)
{
_log.FatalFormat("Il Condominio è null - {0} - documento:{1} - movimento:{2} - esercizio:{3} - testata:{4}", Utility.GetMethodDescription(), movimento.NumeroDocumento, movimento.ID, testata.CodiceEsercizio, testata.ID);
fatalMessage = "Il Condominio è null.";
}
var protocollo = _protocolloService.GetProgressivo(TipoProtocollo.Fattura, esercizio.DataApertura.GetValueOrDefault().Year, esercizio.CondominioRiferimento);
if (protocollo.Progressivo != null)
spesa.NumeroProtocollo = protocollo.Progressivo;
else
return new BilancioAperturaMessage(protocollo.Message, string.Empty, false);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel recuperare il progressivo - {0} - data:{1:d} - condominio:{2} - movimento:{3} - esercizio:{4} - testata:{5}", ex, Utility.GetMethodDescription(), movimento.DataDocumento.GetValueOrDefault(), esercizio.CondominioRiferimento.ID, movimento.ID, testata.CodiceEsercizio, testata.ID);
fatalMessage = "Errore inaspettato nel recuperare il progressivo.";
}
_daoFactory.GetSpesaDao().SaveOrUpdate(spesa);
}
if (spesa != null)
{
spesa.TipoDocumento = "FATBILAPP";
spesa.ImportoRitenuta = importoRitenuta;
spesa.AltreSpeseEsenti = movimento.AltreSpeseEsenti;
spesa.AltreSpese = movimento.AltreSpese;
spesa.IsRitenutaCalcoloImponibile = spesa.FornitoreRiferimento.IsRitenutaCalcolataImponibile;
if(movimento.AliquotaRitenuta != null)
spesa.AliquotaRitenuta = movimento.AliquotaRitenuta.GetValueOrDefault()/100;
else
spesa.AliquotaRitenuta = null;
spesa.NumeroDocumento = movimento.NumeroDocumento;
spesa.DataDocumento = movimento.DataDocumento;
spesa.Stato = conto.Codice == _pianoContiService.GetCodiceContoFornitori() ? StatoSpesaEnum.Inserita : StatoSpesaEnum.Pagata;
movimento.IdSpesa = spesa.ID;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - SPESA - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID);
throw;
}
// ----------------------------------
// Dettaglio Spesa
// ----------------------------------
DettaglioSpesa dettaglio = null;
try
{
if (conto.Codice == _pianoContiService.GetCodiceContoFornitori() || conto.Codice == _pianoContiService.GetCodiceContoRitenuta())
{
if (movimento.ID > 0 && _daoFactory.GetMovimentoContabileDao().GetById(movimento.ID, false).DettaglioRiferimento != null)
dettaglio = _daoFactory.GetMovimentoContabileDao().GetById(movimento.ID, false).DettaglioRiferimento;
else
{
dettaglio = new DettaglioSpesa(spesa, 1);
_daoFactory.GetDettaglioSpesaDao().SaveOrUpdate(dettaglio);
}
dettaglio.Descrizione = movimento.Descrizione;
dettaglio.ImportoLordo = conto.Codice == _pianoContiService.GetCodiceContoFornitori() ? importo - movimento.AltreSpese.GetValueOrDefault() : movimento.ImportoFattura;
dettaglio.ImportoIva = movimento.ImportoIva;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - DETTAGLIO SPESA - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID);
throw;
}
// ------------------------------------------------------
// Scadenza - SOLO se non di tratta di nota di accredito
// ------------------------------------------------------
ScadenzaFattura scadenza = null;
try
{
if (spesa != null && movimento.ImportoDare.GetValueOrDefault() == 0)
{
if (movimento.ID > 0)
scadenza = IesiGenericCollections<ScadenzaFattura>.GetByIndex(spesa.Scadenze, 0);
if (scadenza == null)
{
scadenza = new ScadenzaFattura(spesa, esercizio.DataApertura, importo - spesa.ImportoRitenuta.GetValueOrDefault())
{
Stato = conto.Codice == _pianoContiService.GetCodiceContoFornitori() ? StatoSpesaEnum.Inserita : StatoSpesaEnum.Pagata
};
_daoFactory.GetScadenzaFatturaDao().SaveOrUpdate(scadenza);
}
if (conto.Codice == _pianoContiService.GetCodiceContoFornitori())
{
scadenza.Importo = importo + spesa.AltreSpeseEsenti.GetValueOrDefault() - spesa.ImportoRitenuta.GetValueOrDefault();
scadenza.ImportoRitenuta = spesa.ImportoRitenuta;
if (movimento.DataPagamento != null)
scadenza.Scadenza = movimento.DataPagamento.GetValueOrDefault();
}
else
{
scadenza.Importo = 0;
scadenza.ImportoRitenuta = importoRitenuta;
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - SCADENZA - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID);
throw;
}
// =================================================================================
// RITENUTE
// ----------------------------------
// Pagamento
// ----------------------------------
try
{
// Inserimento pagamento fattura per ritenuta in bilancio di apertura da pagare
if (scadenza != null && conto.Codice == _pianoContiService.GetCodiceContoRitenuta())
{
Pagamento pagamento;
if (scadenza.Pagamenti.Count > 0)
{
pagamento = scadenza.Pagamenti.First();
pagamento.Data = movimento.DataPagamento.GetValueOrDefault();
pagamento.RitenutaAcconto.Importo = scadenza.ImportoRitenuta;
pagamento.RitenutaAcconto.ImportoInteressi = movimento.InteressiRitenuta;
pagamento.RitenutaAcconto.ImportoSanzione = movimento.SanzioniRitenuta;
pagamento.Importo = spesa.ImportoLordo - pagamento.RitenutaAcconto.Importo.GetValueOrDefault();
pagamento.Stato = StatoSpesaEnum.Pagata;
// Se il pagamento è già presente devo annullare la ritenuta eventualmente già versata
// TODO: Verificare se è necessario controllare che non si tratti di un versamento CBI
if (pagamento.RitenutaAcconto != null && pagamento.RitenutaAcconto.TestataRiferimento != null)
{
var messageDeleteRitenuta = _ritenutaService.DeletePagamentoRitenuta(pagamento.RitenutaAcconto.TestataRiferimento.ID);
if (!string.IsNullOrEmpty(messageDeleteRitenuta))
fatalMessage += messageDeleteRitenuta + Environment.NewLine;
}
}
else
{
pagamento = new Pagamento(scadenza, null, spesa.ImportoLordo, movimento.DataPagamento.GetValueOrDefault(), TipoPagamentoFatturaEnum.AltroAmministratore)
{
RitenutaAcconto = new Ritenuta(scadenza.ImportoRitenuta)
{
ImportoInteressi = movimento.InteressiRitenuta,
ImportoSanzione = movimento.SanzioniRitenuta,
Stato = StatoRitenutaEnum.Inserita
},
Stato = StatoSpesaEnum.Pagata
};
_daoFactory.GetPagamentoDao().SaveOrUpdate(pagamento);
}
// -------------------------------------------------------------------------------------------
// Se presente la data di versamento della ritenuta la ritenuta inserita è già stata versata
// -------------------------------------------------------------------------------------------
if (string.IsNullOrEmpty(fatalMessage) && movimento.DataVersamentoRitenuta != null)
{
var contoRitenuta = _daoFactory.GetContoDao().GetByCodice(scadenza.SpesaRiferimento.EsercizioRiferimento.ID, scadenza.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoBancario());
_ritenutaService.PagamentoRitenuta(pagamento, movimento.DataVersamentoRitenuta.GetValueOrDefault(), contoRitenuta, null, testata.Descrizione, null, null, null);
}
}
if (dettaglio != null)
listaDettagli.Add(movimento.ID, dettaglio);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - PAGAMENTO - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID);
throw;
}
// =================================================================================
// FATTURE
// ---------------------------------------------------------------------------------
// Inserimento pagamento fattura per fattura in bilancio di apertura ma già pagata
// ---------------------------------------------------------------------------------
try
{
if (spesa != null && string.IsNullOrEmpty(fatalMessage) && conto.Codice == _pianoContiService.GetCodiceContoFornitori() && movimento.DataPagamento != null)
{
if (spesa.ID > 0 && scadenza?.Pagamenti != null && scadenza.Pagamenti.Count > 0)
{
var messageAnnullamentoPagamenti = _pagamentoService.IsAllowAnnullamentoPagamentiSpesa(spesa.ID);
if (string.IsNullOrEmpty(messageAnnullamentoPagamenti.FatalMessage))
_pagamentoService.AnnullamentoPagamentiSpesa(spesa.ID);
else
fatalMessage += messageAnnullamentoPagamenti.FatalMessage + Environment.NewLine;
}
if (string.IsNullOrEmpty(fatalMessage))
{
var idScadenza = 0;
decimal? importoScadenza = spesa.ImportoLordo;
var dataScadenza = movimento.DataPagamento;
var statoScadenza = StatoSpesaEnum.Inserita;
if (scadenza != null)
{
idScadenza = scadenza.ID;
importoScadenza = scadenza.Importo;
dataScadenza = scadenza.Scadenza;
statoScadenza = scadenza.Stato;
}
int? idSottoConto = null;
var datiBancari = esercizio.CondominioRiferimento.DatiBancariPrincipale;
if (datiBancari != null)
idSottoConto = datiBancari.ID*-1;
var scadenze = new List<ScadenzaFatturaDTO>(1)
{
new ScadenzaFatturaDTO
{
ID = idScadenza,
IdContoPagamentoScadenza = _pianoContiService.GetContoBancario(esercizio).ID,
DataPagamentoRitenuta = null,
DataPagamentoScadenza = movimento.DataPagamento.GetValueOrDefault(),
IdSottoContoPagamentoScadenza = idSottoConto,
IdSpesa = spesa.ID,
Importo = importoScadenza,
ImportoRitenuta = movimento.ImportoRitenuta,
Scadenza = dataScadenza,
StatoScadenza = statoScadenza,
Stato = "U"
}
};
var messagePagamenti = _pagamentoService.CreatePagamentiImmediati(spesa.ID, scadenze, null);
if (!string.IsNullOrEmpty(messagePagamenti))
fatalMessage += messagePagamenti + Environment.NewLine;
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - PAGAMENTO 2 - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID);
throw;
}
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - SINGOLO MOVIMENTO - {0} - movimento:{1} - testata:{2}", ex, Utility.GetMethodDescription(), movimento.ID, testata.ID);
throw;
}
}
}
try
{
if(string.IsNullOrEmpty(fatalMessage))
{
var result = _movimentoContabileService.SetBilancioApertura(testata);
fatalMessage += result.Message;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - MOVIMENTI CONTABILI - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID);
throw;
}
try
{
if(string.IsNullOrEmpty(fatalMessage))
{
foreach (var dto in testata.Movimenti)
{
try
{
if (dto.IdMovimentoRiferimento > 0 && listaDettagli.ContainsKey(dto.ID))
_daoFactory.GetMovimentoContabileDao().GetById(dto.IdMovimentoRiferimento, false).DettaglioRiferimento = listaDettagli[dto.ID];
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - IMPOSTAZIONE DETTAGLIO RIFERIMENTO (SINGOLO DETTAGLIO) - {0} - id:{1} - testata:{2}", ex, Utility.GetMethodDescription(), dto.ID, testata.ID);
throw;
}
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - IMPOSTAZIONE DETTAGLIO RIFERIMENTO - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID);
throw;
}
// =============================================================================================
// Esercizi Precedenti: Se chiusi occorre eliminare le registrazioni di chiusura - bugid#2472
// =============================================================================================
var eserciziPrecedenti =
esercizio.CondominioRiferimento.Esercizi.Where(
item =>
item.Stato == StatoEsercizioEnum.Chiuso &&
item.Gestione == GestioneEsercizioEnum.Ordinario &&
item.DataApertura.GetValueOrDefault() < esercizio.DataApertura.GetValueOrDefault()).ToList();
foreach (var esercizioPrecedente in eserciziPrecedenti)
_movimentoContabileService.EliminazioneOperazioniAperturaChiusura(esercizioPrecedente);
}
if (!string.IsNullOrEmpty(fatalMessage))
{
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
}
return new BilancioAperturaMessage(fatalMessage, warnMessage, false);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID);
throw;
}
}
public void ApplyModello(DettaglioSpesa dettaglio, int idModello, TipoMovimentoEnum tipo)
{
try
{
if (dettaglio.Movimenti.Count > 0)
{
_gruppiSelezionati.Clear();
_lottiSelezionati.Clear();
_stabiliSelezionati.Clear();
_unitaSelezionate.Clear();
var modello = _daoFactory.GetModelloRegistrazioneContabileDao().GetById(idModello, true);
var testata = IesiGenericCollections<MovimentoContabile>.GetByIndex(dettaglio.Movimenti, 0).Testata;
var oldMovimenti = new Dictionary<int, MovimentoContabile>();
var i = 0;
foreach (var mov in dettaglio.Movimenti)
{
i++;
oldMovimenti.Add(i, mov);
if (mov.Testata != null)
{
mov.Testata.Movimenti.Remove(mov);
mov.Testata = null;
}
if (mov.ContoRiferimento != null)
{
mov.ContoRiferimento.Movimenti.Remove(mov);
mov.ContoRiferimento = null;
}
if (mov.CondominoRiferimento != null)
{
mov.CondominoRiferimento.Movimenti.Remove(mov);
mov.CondominoRiferimento = null;
}
if (mov.EvasioneBancaria != null)
{
mov.EvasioneBancaria.MovimentiContabili.Remove(mov);
mov.EvasioneBancaria = null;
}
if (mov.FornitoreRiferimento != null)
{
mov.FornitoreRiferimento.MovimentiContabili.Remove(mov);
mov.FornitoreRiferimento = null;
}
if (mov.ContoCorrenteBancario != null)
{
mov.ContoCorrenteBancario.MovimentiContabili.Remove(mov);
mov.ContoCorrenteBancario = null;
}
if (mov.Spesa != null)
{
mov.Spesa.MovimentiBollette.Remove(mov);
mov.Spesa = null;
}
}
dettaglio.Movimenti.Clear();
i = 0;
decimal importoRipartito = 0;
var totalePercentualiConti = modello.Conti.Sum(item => item.PercentualeRipartizione.GetValueOrDefault());
foreach (var conto in modello.Conti)
{
i++;
decimal importoMovimento;
var importoDettaglio = dettaglio.ImportoLordo.GetValueOrDefault();
if (dettaglio.NumeroRiga.GetValueOrDefault() == 1)
importoDettaglio += dettaglio.SpesaRiferimento.AltreSpese.GetValueOrDefault() + dettaglio.SpesaRiferimento.AltreSpeseEsenti.GetValueOrDefault();
if (totalePercentualiConti != 0)
importoMovimento = (importoDettaglio / totalePercentualiConti) * conto.PercentualeRipartizione.GetValueOrDefault();
else
{
importoMovimento = importoDettaglio;
if (conto.PercentualeRipartizione.GetValueOrDefault() < 0)
importoMovimento = importoMovimento * -1;
}
if (i == modello.Conti.Count)
{
if (tipo == TipoMovimentoEnum.Accredito)
importoRipartito = importoRipartito*-1;
importoMovimento = importoDettaglio - importoRipartito;
}
// se si tratta di un accredito devo invertire il segno dell'importo
var segno = "D";
if (tipo == TipoMovimentoEnum.Accredito)
{
segno = "A";
importoMovimento = importoMovimento * -1;
}
var movimento = new MovimentoContabile(testata, dettaglio, _daoFactory.GetCausaleContabileDao().GetByCodice("IF"), i, conto.ContoRiferimento, importoMovimento, segno) {SottoContoRiferimento = conto.SottoContoRiferimento};
importoRipartito += importoMovimento;
if (oldMovimenti.ContainsKey(i))
{
movimento.Descrizione = oldMovimenti[i].Descrizione;
movimento.PercentualeProprieta = oldMovimenti[i].PercentualeProprieta;
}
else
movimento.Descrizione = modello.DescrizioneVoceFattura;
if (conto.Unita.Count > 0)
{
movimento.IsRipartoPersonalizzato = true;
foreach (var dettaglioModello in conto.Unita)
{
// Lotti
if (dettaglioModello.LottoRiferimento != null)
{
if (!_lottiSelezionati.ContainsKey(GetKey(movimento)))
_lottiSelezionati.Add(GetKey(movimento), GetLottiDataSource(GetKey(movimento), conto.ContoRiferimento.ID, dettaglio.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, null, false));
_lottiSelezionati[GetKey(movimento)].Rows.Find(dettaglioModello.LottoRiferimento.ID)["Selezionato"] = true;
movimento.LottiAddebito += dettaglioModello.LottoRiferimento.ID + "&";
}
// Stabili
if (dettaglioModello.PalazzinaRiferimento != null)
{
if (!_stabiliSelezionati.ContainsKey(GetKey(movimento)))
_stabiliSelezionati.Add(GetKey(movimento), GetStabiliDataSource(GetKey(movimento), conto.ContoRiferimento.ID, dettaglio.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, null, false));
_stabiliSelezionati[GetKey(movimento)].Rows.Find(dettaglioModello.PalazzinaRiferimento.ID)["Selezionato"] = true;
movimento.StabiliAddebito += dettaglioModello.PalazzinaRiferimento.ID + "&";
}
// Gruppi
if (dettaglioModello.GruppoStabileRiferimento != null)
{
if (!_gruppiSelezionati.ContainsKey(GetKey(movimento)))
_gruppiSelezionati.Add(GetKey(movimento), GetGruppiDataSource(GetKey(movimento), conto.ContoRiferimento.ID, dettaglio.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, null, false));
_gruppiSelezionati[GetKey(movimento)].Rows.Find(dettaglioModello.GruppoStabileRiferimento.ID)["Selezionato"] = true;
movimento.GruppiAddebito += dettaglioModello.GruppoStabileRiferimento.ID + "&";
}
// Unità Immobiliari
if (dettaglioModello.UnitaRiferimento != null)
{
if (!_unitaSelezionate.ContainsKey(GetKey(movimento)))
_unitaSelezionate.Add(GetKey(movimento), GetUnitaDataSource(GetKey(movimento), conto.ContoRiferimento.ID, dettaglio.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, false, movimento.Testata.EsercizioRiferimento, false));
var rows = _unitaSelezionate[GetKey(movimento)].Select($"IdUnitaImmobiliare = {dettaglioModello.UnitaRiferimento.ID}");
if (rows.Length == 1)
rows[0]["Selezionato"] = true;
else if(!rows.Any() && conto.ContoRiferimento.IsSpesePersonali)
{
var soggetto = conto.ContoRiferimento.PercentualeProprieta == 0 ? dettaglioModello.UnitaRiferimento.GetConduttorePrincipale(dettaglio.SpesaRiferimento.EsercizioRiferimento.DataChiusura) : dettaglioModello.UnitaRiferimento.GetProprietarioPrincipale(dettaglio.SpesaRiferimento.EsercizioRiferimento.DataChiusura);
if (soggetto != null)
{
rows = _unitaSelezionate[GetKey(movimento)].Select($"IdSoggettoCondominio = {soggetto.ID}");
if (rows.Length == 1)
rows[0]["Selezionato"] = true;
}
}
}
}
if (!string.IsNullOrEmpty(movimento.LottiAddebito))
movimento.LottiAddebito = movimento.LottiAddebito.Substring(0, movimento.LottiAddebito.Length - 1);
if (!string.IsNullOrEmpty(movimento.StabiliAddebito))
movimento.StabiliAddebito = movimento.StabiliAddebito.Substring(0, movimento.StabiliAddebito.Length - 1);
if (!string.IsNullOrEmpty(movimento.GruppiAddebito))
movimento.GruppiAddebito = movimento.GruppiAddebito.Substring(0, movimento.GruppiAddebito.Length - 1);
}
else
{
// ===========================================================================================
// BUGID#2159 - COMMENTATO: Con la nuova funzione di riparto aggregato NON devono
// più essere usati gli oggetti SpeseUnita NON deve quindi essere ripartito lo specifico
// movimento a meno che non sia previsto un riparto personalizzato a livello di modello
// Sostuitita con calcolo degli addebiti specifici per Lotto, Stabile e Scala.
// ----------------------------------------------------------------------------------
// Se sono presenti selezioni per Stabile, Scala o specifica unità le applico ...
// ----------------------------------------------------------------------------------
movimento.LottiAddebito = string.Empty;
movimento.StabiliAddebito = string.Empty;
movimento.GruppiAddebito = string.Empty;
foreach (var dettaglioModello in conto.Unita)
{
// Lotti
if (dettaglioModello.LottoRiferimento != null)
{
if (!string.IsNullOrEmpty(movimento.LottiAddebito))
movimento.LottiAddebito += "&";
movimento.LottiAddebito += dettaglioModello.LottoRiferimento.ID;
}
// Stabili
if (dettaglioModello.PalazzinaRiferimento != null)
{
if (!string.IsNullOrEmpty(movimento.StabiliAddebito))
movimento.StabiliAddebito += "&";
movimento.StabiliAddebito += dettaglioModello.PalazzinaRiferimento.ID;
}
// Gruppi
if (dettaglioModello.GruppoStabileRiferimento != null)
{
if (!string.IsNullOrEmpty(movimento.GruppiAddebito))
movimento.GruppiAddebito += "&";
movimento.GruppiAddebito += dettaglioModello.GruppoStabileRiferimento.ID;
}
}
}
//// ----------------------------------------------------------------------------------
//// ... altrimenti seleziono tutte le unità ...
//// ----------------------------------------------------------------------------------
//else
// if (!_unitaSelezionate.ContainsKey(GetKey(movimento)))
// _unitaSelezionate.Add(GetKey(movimento), GetUnitaDataSource(GetKey(movimento), conto.ContoRiferimento.ID, dettaglio.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, movimento.GetImportoConSegno(), true, movimento.Testata.EsercizioRiferimento));
// ===========================================================================================
}
}
else
{
_log.WarnFormat("Presente dettaglio senza movimenti - {0} - dettaglio:{1} - modello:{1} - tipo:{2}", Utility.GetMethodDescription(), dettaglio.ID, idModello, tipo);
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore durante l'applicazione del modello - {0} - dettaglio:{1} - modello:{1} - tipo:{2}", ex, Utility.GetMethodDescription(), dettaglio.ID, idModello, tipo);
throw;
}
}
public void ApplyDettaglioSpesa(DettaglioSpesa dettaglio)
{
foreach (var movimento in dettaglio.Movimenti)
{
DataTable tb = null;
if (movimento.DettaglioRipartizione.Count > 0)
{
string key = GetKey(movimento);
tb = GetEmptyUnitaDataSource();
_unitaSelezionate.Add(key, tb);
}
if (tb != null)
{
if (!movimento.ContoRiferimento.IsSpesePersonali)
{
var listaUnita = _daoFactory.GetUnitaImmobiliareDao().GetByCondominio(dettaglio.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID);
foreach (var unita in listaUnita)
{
var row = tb.NewRow();
row["IdUnitaImmobiliare"] = unita.ID;
row["Nominativo"] = unita.Descrizione;
row["Interno"] = unita.InternoCompleto;
row["TipoUnita"] = unita.TipoUnitaImmobiliare.Descrizione;
if (unita.Ordine != null)
row["Ordine"] = unita.Ordine;
row["Selezionato"] = isPresenteUnita(unita, movimento);
tb.Rows.Add(row);
}
}
else
{
var soggetti = _daoFactory.GetSoggettoCondominioDao().GetAttiviByCondominioData(dettaglio.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, null, null, dettaglio.SpesaRiferimento.EsercizioRiferimento.DataApertura.GetValueOrDefault());
foreach (var soggetto in soggetti)
{
try
{
var row = tb.NewRow();
row["IdSoggettoCondominio"] = soggetto.ID;
row["Nominativo"] = soggetto.DisplayName;
row["Interno"] = soggetto.UnitaImmobiliare.InternoCompleto;
row["TipoUnita"] = soggetto.UnitaImmobiliare.TipoUnitaImmobiliare.Descrizione;
row["TipoCondomino"] = soggetto.Tipo.ToString();
if (soggetto.UnitaImmobiliare.Ordine != null)
row["Ordine"] = soggetto.UnitaImmobiliare.Ordine;
row["DirittiReali"] = soggetto.DirittoReale.GetValueOrDefault().Description();
if(soggetto.PercentualeRiferimento != null)
row["PercentualeSpese"] = soggetto.PercentualeRiferimento;
row["Selezionato"] = false;
row["ParentId"] = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.ID;
row["ParentName"] = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.Descrizione;
tb.Rows.Add(row);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel calcolo del datasource delle ripartizioni spese (SINGOLO SOGGETTO) - {0} - soggetto:{1} - IdDettaglio:{2}", ex, Utility.GetMethodDescription(), soggetto.ID, dettaglio.ID);
throw;
}
}
}
}
}
}
public ModelloRegistrazioneContabile CreateModelloRipartizione(DettaglioSpesa dettaglio)
{
return CreateModelloRipartizione(dettaglio.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, dettaglio.Movimenti, dettaglio.ImportoLordo.GetValueOrDefault(), "<DA MODIFICARE>", string.Empty);
}
private ResultDettaglioSpesa manageDettaglioSpesa(DettaglioSpesaDTO dto, DettaglioSpesa dettaglioMultiIva)
{
DettaglioSpesa item = null;
string result = string.Empty;
// Controllo sullo stato U, D, I
switch (dto.Stato.ToUpper())
{
case "U":
result = updateDettaglio(dto, dettaglioMultiIva, out item);
break;
case "I":
result = insertDettaglio(dto, dettaglioMultiIva, out item);
break;
}
if (!string.IsNullOrEmpty(result))
item = null;
return new ResultDettaglioSpesa(item, result);
}
public ResultBolletta SalvaBolletta(BollettaDTO dto, bool controlloDataRegistrazione)
{
try
{
var message = string.Empty;
if (dto.IdFornitore > 0 && dto.IdEsercizio > 0)
{
foreach (var dettaglioDto in dto.Dettagli)
{
try
{
if (string.IsNullOrEmpty(dettaglioDto.AliquotaIva))
dettaglioDto.ImportoLordo = dettaglioDto.Imponibile;
else
{
var aliquotaIva = new decimal(Library.Decodifica.Instance.GetElement("CodiceIva", dettaglioDto.AliquotaIva).ValoreNumerico);
dettaglioDto.ImportoIva = dettaglioDto.Imponibile * aliquotaIva;
dettaglioDto.ImportoLordo = dettaglioDto.Imponibile + dettaglioDto.ImportoIva;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore durante il salvataggio di una bolletta (Singolo Dettaglio) - {0} - dettaglio:{1} - idBolletta:{2} - pagata:{3}", ex, Library.Utility.GetMethodDescription(), dettaglioDto.ID, dto.ID, dto.Rid);
throw;
}
}
if (dto.Rid && (dto.IdContoPagamento == 0 || dto.IdSottoContoPagamento == 0))
{
return new ResultBolletta(dto, "Se è selezionato il pagamento automatico tramite rid occorre selezionare un conto corrente di pagamento");
}
var spesa = _daoFactory.GetSpesaDao().Find(dto.ID, false);
var esercizio = _daoFactory.GetEsercizioDao().GetById(dto.IdEsercizio.GetValueOrDefault(), false);
if (spesa != null)
{
spesa.Autorizzata = dto.Autorizzata;
if(!dto.Rid && spesa.Pagamenti.Count > 0)
return new ResultBolletta(dto, "Non è possibile aggiornare la registrazione perchè sono presenti dei pagamenti");
var messageAnnullamentoPagamenti = _pagamentoService.IsAllowAnnullamentoPagamentiSpesa(spesa.ID);
if(!string.IsNullOrEmpty(messageAnnullamentoPagamenti.FatalMessage))
return new ResultBolletta(dto, "Non è possibile aggiornare la registrazione perchè sono presenti dei pagamenti non annullabili." + Environment.NewLine + messageAnnullamentoPagamenti.FatalMessage);
spesa.FornitoreRiferimento = _daoFactory.GetFornitoreDao().GetById(dto.IdFornitore.GetValueOrDefault(), false);
spesa.EsercizioRiferimento = esercizio;
var scadenza = spesa.Scadenze.FirstOrDefault();
if (scadenza != null)
{
scadenza.Scadenza = dto.DataScadenza;
scadenza.Importo = dto.Importo;
// Annullo i pagamenti preesistenti
var messageAnnullaPagamenti = _pagamentoService.AnnullamentoPagamentiSpesa(spesa.ID);
if (!string.IsNullOrEmpty(messageAnnullaPagamenti))
{
var utente = _daoFactory.GetUtenteDao().Find(dto.IdUtente, false);
var username = "******";
if (utente != null)
username = utente.Username;
else
_log.ErrorFormat("Non trovato idUtente - {0} - azienda:{1} - bolletta:{2}", Library.Utility.GetMethodDescription(), Security.Login.Instance.CurrentLogin().Azienda, dto.ID);
_persistenceContext.RollbackAndCloseSession(username);
message += Environment.NewLine + messageAnnullaPagamenti + Environment.NewLine;
return new ResultBolletta(dto, message);
}
}
}
else
{
spesa = new Spesa(_daoFactory.GetFornitoreDao().GetById(dto.IdFornitore.GetValueOrDefault(), false), esercizio) { Autorizzata = dto.Autorizzata };
var protocollo = _protocolloService.GetProgressivo(TipoProtocollo.Fattura, esercizio.DataApertura.GetValueOrDefault().Year, spesa.EsercizioRiferimento.CondominioRiferimento);
if (protocollo.Progressivo != null)
{
spesa.NumeroProtocollo = protocollo.Progressivo;
spesa.AnnoArchiviazioneOttica = esercizio.DataApertura.GetValueOrDefault().Year;
}
else
{
message += protocollo.Message + Environment.NewLine;
return new ResultBolletta(null, message);
}
spesa.Scadenze.Add(new ScadenzaFattura(spesa, dto.DataScadenza, dto.Importo));
}
spesa.RidAutomatica = dto.Rid;
spesa.IsRipartita = false;
spesa.TipoDocumento = "BOLLETTA";
spesa.DataDocumento = dto.DataDocumento;
spesa.NumeroDocumento = dto.NumeroDocumento;
spesa.ImportoBolletta = dto.Importo;
spesa.DataInizioCompetenza = dto.DataInizioCompetenza;
spesa.DataFineCompetenza = dto.DataFineCompetenza;
spesa.IsRipartoPersonalizzato = dto.IsRipartoPersonalizzato;
spesa.IsAbilitataArchiviazioneOttica = dto.IsAbilitataArchiviazioneOttica;
spesa.Utenza = _daoFactory.GetUtenzaDao().GetById(dto.IdUtenza, false);
_daoFactory.GetSpesaDao().SaveOrUpdate(spesa);
// ---------------------------
// Dettagli
// ---------------------------
spesa.Dettagli.Clear();
const int index = 0;
foreach (var dettaglioDto in dto.Dettagli)
{
var dettaglio = new DettaglioSpesa(spesa, index)
{
AliquotaIva = dettaglioDto.AliquotaIva,
Descrizione = dettaglioDto.Descrizione,
ID = dettaglioDto.ID,
Note = dettaglioDto.Note,
Tipo = (TipoDettaglioBollettaEnum)Enum.Parse(typeof (TipoDettaglioBollettaEnum), dettaglioDto.Tipo),
Quantita = dettaglioDto.Quantita
};
if (string.IsNullOrEmpty(dettaglioDto.AliquotaIva))
dettaglio.ImportoLordo = dettaglioDto.Imponibile;
else
{
var aliquotaIva = new decimal(Library.Decodifica.Instance.GetElement("CodiceIva", dettaglioDto.AliquotaIva).ValoreNumerico);
dettaglio.ImportoIva = dettaglioDto.Imponibile * aliquotaIva;
dettaglio.ImportoLordo = dettaglioDto.Imponibile + dettaglio.ImportoIva;
}
spesa.Dettagli.Add(dettaglio);
}
// ---------------------------
// Movimenti
// ---------------------------
_movimentoContabileService.SetMovimentoBolletta(dto, spesa, null, controlloDataRegistrazione);
// ==========================================================================================================================================
// BUGID#2159 - COMMENTATO: Con la nuova funzione di riparto aggregato NON devono
// più essere usati gli oggetti SpeseUnita NON deve quindi essere ripartito lo specifico
// movimento
// Sostuitita con calcolo degli addebiti specifici per Lotto, Stabile e Scala.
// ---------------------------
// Ripartizione
// ---------------------------
foreach (var movimentoDto in dto.Movimenti)
{
var movimento = _daoFactory.GetMovimentoContabileDao().Find(movimentoDto.ID, false);
if (movimento == null)
{
_log.Error("Errore durante il salvataggio di una bolletta - MOVIMENTO NON PIù ESISTENTE " + Library.Utility.GetMethodDescription() + " - movimento:" + movimentoDto.ID + " - idBolletta:" + dto.ID + " - pagata:" + dto.Rid);
return new ResultBolletta(null, "E' stato cancellato in un'altra finestra il movimento di contabilità");
}
if (!string.IsNullOrEmpty(movimentoDto.RipartoAggiornato))
{
movimento.LottiAddebito = null;
movimento.GruppiAddebito = null;
movimento.StabiliAddebito = null;
}
switch (movimentoDto.RipartoAggiornato)
{
case "U":
break;
case "G":
if (movimentoDto.Ripartizione.Gruppi != null && movimentoDto.Ripartizione.Gruppi.Count > 0)
{
var lista = movimentoDto.Ripartizione.Gruppi;
foreach (var item in lista)
{
if (item.Selezionato)
movimento.GruppiAddebito += item.ID + "&";
}
// Se sono stati selezionati tutti i gruppi NON salvo l'elenco dei gruppi
if (movimento.GruppiAddebito == spesa.EsercizioRiferimento.CondominioRiferimento.GetGruppiKey())
movimento.GruppiAddebito = string.Empty;
if (!string.IsNullOrEmpty(movimento.GruppiAddebito) && movimento.GruppiAddebito.EndsWith("&"))
movimento.GruppiAddebito = movimento.GruppiAddebito.Substring(0, movimento.GruppiAddebito.Length - 1);
}
break;
case "S":
if (movimentoDto.Ripartizione.Stabili != null && movimentoDto.Ripartizione.Stabili.Count > 0)
{
var lista = movimentoDto.Ripartizione.Stabili;
foreach (var item in lista)
{
if (item.Selezionato)
movimento.StabiliAddebito += item.ID + "&";
}
// Se sono stati selezionati tutti gli stabili NON salvo l'elenco degli stabili
if (movimento.StabiliAddebito == spesa.EsercizioRiferimento.CondominioRiferimento.GetStabiliKey())
movimento.StabiliAddebito = string.Empty;
if (!string.IsNullOrEmpty(movimento.StabiliAddebito) && movimento.StabiliAddebito.EndsWith("&"))
movimento.StabiliAddebito = movimento.StabiliAddebito.Substring(0, movimento.StabiliAddebito.Length - 1);
}
break;
case "L":
if (movimentoDto.Ripartizione.Lotti != null && movimentoDto.Ripartizione.Lotti.Count > 0)
{
var lista = movimentoDto.Ripartizione.Lotti;
foreach (var item in lista)
{
if (item.Selezionato)
movimento.LottiAddebito += item.ID + "&";
}
// Se sono stati selezionati tutti i lotti NON salvo l'elenco dei lotti
if (movimento.LottiAddebito == spesa.EsercizioRiferimento.CondominioRiferimento.GetLottiKey())
movimento.LottiAddebito = string.Empty;
if (!string.IsNullOrEmpty(movimento.LottiAddebito) && movimento.LottiAddebito.EndsWith("&"))
movimento.LottiAddebito = movimento.LottiAddebito.Substring(0, movimento.LottiAddebito.Length - 1);
}
break;
}
}
//foreach (var movimentoDto in dto.Movimenti)
//{
// var movimento = _daoFactory.GetMovimentoContabileDao().Find(movimentoDto.ID, false);
// if (movimento == null)
// {
//
// _log.Error("Errore durante il salvataggio di una bolletta - MOVIMENTO NON PIù ESISTENTE " + Library.Utility.GetMethodDescription() + " - movimento:" + movimentoDto.ID + " - idBolletta:" + dto.ID + " - pagata:" + pagata);
// return new ResultBolletta(null, "E' stato cancellato in un'altra finestra il movimento di contabilità");
// }
// foreach (var dettaglioRipartizione in movimento.DettaglioRipartizione)
// {
// dettaglioRipartizione.MovimentoRiferimento = null;
// dettaglioRipartizione.UnitaRiferimento = null;
// _daoFactory.GetSpeseUnitaDao().Delete(dettaglioRipartizione);
// }
// movimento.DettaglioRipartizione.Clear();
// if (!string.IsNullOrEmpty(movimentoDto.RipartoAggiornato))
// {
// movimento.LottiAddebito = null;
// movimento.GruppiAddebito = null;
// movimento.StabiliAddebito = null;
// }
// switch (movimentoDto.RipartoAggiornato)
// {
// case "U":
// if (movimentoDto.Ripartizione.UnitaImmobiliari != null && movimentoDto.Ripartizione.UnitaImmobiliari.Count > 0)
// {
// var lista = movimentoDto.Ripartizione.UnitaImmobiliari;
// foreach (var item in lista)
// {
// if (item.Selezionato)
// {
// var dettaglioRipartizione = new SpeseUnita(null, _daoFactory.GetUnitaImmobiliareDao().GetById(item.ID, false), movimento);
// _daoFactory.GetSpeseUnitaDao().SaveOrUpdate(dettaglioRipartizione);
// }
// }
// }
// break;
// case "G":
// if (movimentoDto.Ripartizione.Gruppi != null && movimentoDto.Ripartizione.Gruppi.Count > 0)
// {
// var lista = movimentoDto.Ripartizione.Gruppi;
// foreach (var item in lista)
// {
// if (item.Selezionato)
// {
// var gruppo = _daoFactory.GetGruppoStabileDao().GetById(item.ID, false);
// movimento.GruppiAddebito += gruppo.ID + "&";
// foreach (var unita in gruppo.UnitaImmobiliari)
// {
// var dettaglioRipartizione = new SpeseUnita(null, unita, movimento);
// _daoFactory.GetSpeseUnitaDao().SaveOrUpdate(dettaglioRipartizione);
// }
// }
// }
// // Se sono stati selezionati tutti i gruppi NON salvo l'elenco dei gruppi
// if (movimento.GruppiAddebito == spesa.EsercizioRiferimento.CondominioRiferimento.GetGruppiKey())
// movimento.GruppiAddebito = string.Empty;
// if (!string.IsNullOrEmpty(movimento.GruppiAddebito) && movimento.GruppiAddebito.EndsWith("&"))
// movimento.GruppiAddebito = movimento.GruppiAddebito.Substring(0, movimento.GruppiAddebito.Length - 1);
// }
// break;
// case "S":
// if (movimentoDto.Ripartizione.Stabili != null && movimentoDto.Ripartizione.Stabili.Count > 0)
// {
// var lista = movimentoDto.Ripartizione.Stabili;
// foreach (var item in lista)
// {
// if (item.Selezionato)
// {
// var stabile = _daoFactory.GetPalazzinaDao().GetById(item.ID, false);
// movimento.StabiliAddebito += stabile.ID + "&";
// foreach (var dettaglioRipartizione in stabile.GruppiStabile.SelectMany(gruppo => gruppo.UnitaImmobiliari.Select(unita => new SpeseUnita(null, unita, movimento))))
// {
// _daoFactory.GetSpeseUnitaDao().SaveOrUpdate(dettaglioRipartizione);
// }
// }
// }
// // Se sono stati selezionati tutti gli stabili NON salvo l'elenco degli stabili
// if (movimento.StabiliAddebito == spesa.EsercizioRiferimento.CondominioRiferimento.GetStabiliKey())
// movimento.StabiliAddebito = string.Empty;
// if (!string.IsNullOrEmpty(movimento.StabiliAddebito) && movimento.StabiliAddebito.EndsWith("&"))
// movimento.StabiliAddebito = movimento.StabiliAddebito.Substring(0, movimento.StabiliAddebito.Length - 1);
// }
// break;
// case "L":
// if (movimentoDto.Ripartizione.Lotti != null && movimentoDto.Ripartizione.Lotti.Count > 0)
// {
// var lista = movimentoDto.Ripartizione.Lotti;
// foreach (var item in lista)
// {
// if (item.Selezionato)
// {
// var stabili = _daoFactory.GetPalazzinaDao().GetByLotto(_daoFactory.GetLottoDao().GetById(item.ID, false));
// movimento.LottiAddebito += item.ID + "&";
// foreach (var dettaglioRipartizione in stabili.SelectMany(stabile => stabile.GruppiStabile.SelectMany(gruppo => gruppo.UnitaImmobiliari.Select(unita => new SpeseUnita(null, unita, movimento)))))
// {
// _daoFactory.GetSpeseUnitaDao().SaveOrUpdate(dettaglioRipartizione);
// }
// }
// }
// // Se sono stati selezionati tutti i lotti NON salvo l'elenco dei lotti
// if (movimento.LottiAddebito == spesa.EsercizioRiferimento.CondominioRiferimento.GetLottiKey())
// movimento.LottiAddebito = string.Empty;
// if (!string.IsNullOrEmpty(movimento.LottiAddebito) && movimento.LottiAddebito.EndsWith("&"))
// movimento.LottiAddebito = movimento.LottiAddebito.Substring(0, movimento.LottiAddebito.Length - 1);
// }
// break;
// }
//}
// ==========================================================================================================================================
// ---------------------------
// Pagamenti
// ---------------------------
if (dto.Rid)
{
if (spesa.ImportoBolletta > 0)
_pagamentoService.CreatePagamentiImmediatiBolletta(spesa, dto);
else // nota accredito
{
var riscossioni = new List<RiscossioneNotaAccreditoDTO>
{
new RiscossioneNotaAccreditoDTO
{
IdNotaAccredito = spesa.ID,
IdConto = dto.IdContoPagamento,
IdSottoConto = dto.IdSottoContoPagamento,
Importo = dto.Importo
}
};
_pagamentoService.RiscossioneNoteAccredito(riscossioni, dto.DataScadenza);
}
}
//====================================================================
// Se il tipo utenza non è acqua la bolletta viene subito ripartita
//====================================================================
// Aggiorno il selected sul DTO, necessario in caso di inserimento
foreach (var movimentoDto in dto.Movimenti)
{
var movimento = _daoFactory.GetMovimentoContabileDao().GetById(movimentoDto.ID, false);
if (movimentoDto.Ripartizione != null)
{
foreach (var itemDto in movimentoDto.Ripartizione.UnitaImmobiliari)
itemDto.Selezionato = movimento.DettaglioRipartizione.Any(item => item.UnitaRiferimento.ID == itemDto.ID);
}
}
if (spesa.Utenza != null && !spesa.Utenza.RipartoLetture)
{
foreach (var movimento in spesa.MovimentiBollette)
_ripartizioneSpeseService.RicalcoloRipartizioneByMovimento(movimento);
spesa.IsRipartita = true;
}
spesa.IsRipartoPersonalizzato = dto.IsRipartoPersonalizzato;
dto.IdentificativoArchiviazioneOttica = _archiviazioneService.GetIdentificativoArchiviazione(spesa);
spesa.SetStato();
dto.StatoSpesa = spesa.Stato;
}
else
{
_log.Warn("ATTENZIONE: Per la bolletta non è definito il fornitore o l'esercizio - " + Library.Utility.GetMethodDescription() + " - fornitore:" + dto.IdFornitore.GetValueOrDefault() + " - esercizio:" + dto.IdEsercizio.GetValueOrDefault() + " - idBolletta:" + dto.ID + " - pagata:" + dto.Rid);
if (!(dto.IdFornitore > 0))
message += "Per la bolletta non è definito il FORNITORE" + Environment.NewLine;
if (!(dto.IdEsercizio > 0))
message += "Per la bolletta non è definito l'ESERCIZIO" + Environment.NewLine;
}
if (!string.IsNullOrEmpty(message))
dto = null;
return new ResultBolletta(dto, message);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore durante il salvataggio di una bolletta - {0} - idBolletta:{1} - pagata:{2}", ex, Library.Utility.GetMethodDescription(), dto.ID, dto.Rid);
throw;
}
}
public ResultDettaglioSpesa(DettaglioSpesa dettaglio, string message)
{
Dettaglio = dettaglio;
Message = message;
}
public SpesaInfoDTO InserimentoNotaAccredito(NotaAccreditoDTO notaDto, IList<StornoScadenzaDTO> scadenze)
{
try
{
var esercizio = _daoFactory.GetEsercizioDao().Find(notaDto.IdEsercizio, false);
if(esercizio == null)
throw new InvalidDataException("Non è stato necessario l'esercizio di riferimento");
var nota = _daoFactory.GetSpesaDao().Find(notaDto.ID, false);
if (nota == null)
{
nota = new Spesa(_daoFactory.GetFornitoreDao().GetById(notaDto.IdFornitore, false), esercizio, null);
_daoFactory.GetSpesaDao().SaveOrUpdate(nota);
}
var impostazioni = _daoFactory.GetImpostazioniAziendaDao().GetByAzienda(nota.EsercizioRiferimento.CondominioRiferimento.Azienda.ID);
nota.TipoDocumento = "NOTACC";
nota.NumeroDocumento = notaDto.NumeroDocumento;
nota.DataDocumento = notaDto.DataDocumento;
nota.ImportoRitenuta = scadenze.Sum(item => item.ImportoRitenuta);
nota.Stato = StatoSpesaEnum.Stornata;
DettaglioSpesa dettaglio;
if (notaDto.IdDettaglioSpesa == 0)
{
dettaglio = new DettaglioSpesa(nota, 1);
_daoFactory.GetDettaglioSpesaDao().SaveOrUpdate(dettaglio);
}
else
dettaglio = _daoFactory.GetDettaglioSpesaDao().GetById(notaDto.IdDettaglioSpesa, false);
dettaglio.Descrizione = notaDto.Descrizione;
dettaglio.ImportoLordo = scadenze.Sum(item => item.Importo + item.ImportoRitenuta);
var message = StornoNoteAccredito(nota.ID, scadenze, dettaglio, esercizio, notaDto.DataRegistrazione);
var identificativoArchiviazione = string.Empty;
if (string.IsNullOrEmpty(message))
{
var protocollo = _protocolloService.GetProgressivo(TipoProtocollo.Fattura, esercizio.DataApertura.GetValueOrDefault().Year, nota.EsercizioRiferimento.CondominioRiferimento);
if (protocollo.Progressivo != null)
{
nota.NumeroProtocollo = protocollo.Progressivo;
if (nota.IsAbilitataArchiviazioneOttica)
identificativoArchiviazione = _archiviazioneOtticaService.GetIdentificativoArchiviazione(nota, true);
}
else
message += protocollo.Message + Environment.NewLine;
}
return string.IsNullOrEmpty(message) ? new SpesaInfoDTO { Id = nota.ID, IdentificativoArchiviazione = identificativoArchiviazione, NumeroProtocollo = nota.NumeroProtocollo.GetValueOrDefault(), StampaEtichettaArchiviazione = impostazioni.UtilizzoEtichettatriceArchiviazioneOtticaFatture && nota.EsercizioRiferimento.CondominioRiferimento.IsAbilitataArchiviazioneOtticaPassivi.GetValueOrDefault(), EtichettatriceArchiviazione = impostazioni.EtichettatriceArchiviazioneOttica, TipoEtichettaArchiviazione = impostazioni.TipoEtichettaArchiviazioneOttica } : new SpesaInfoDTO { Id = 0, IdentificativoArchiviazione = null, NumeroProtocollo = 0, StampaEtichettaArchiviazione = false, EtichettatriceArchiviazione = string.Empty, TipoEtichettaArchiviazione = "Testo", Message = message };
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nell'inserimento di una nota di accredito - {0} - idNota:{1} - numeroNota:{2} - fornitore:{3} - esercizio:{4} - descrizione:{5}", ex, Utility.GetMethodDescription(), notaDto.ID, notaDto.NumeroDocumento, notaDto.IdFornitore, notaDto.IdEsercizio, notaDto.Descrizione);
throw;
}
}
public ResultDettaglioSpesa ManageDettaglioDomainEntity(DettaglioSpesaDTO dettaglioDto, DettaglioSpesa dettaglioMultiIva)
{
try
{
return manageDettaglioSpesa(dettaglioDto, dettaglioMultiIva);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella gestione dei dettagli delle Fatture/Spese - {0} - id:{1}", ex, Utility.GetMethodDescription(), dettaglioDto.ID);
throw;
}
}
public virtual IUpdatableBusinessEntity Copy()
{
var dettaglio = new DettaglioSpesa(SpesaRiferimento, NumeroRiga)
{
AliquotaIva = AliquotaIva,
Descrizione = Descrizione,
ImportoIva = ImportoIva,
ImportoLordo = ImportoLordo,
ModelloRipartizione = ModelloRipartizione,
Note = Note,
SoggettoRitenutaAcconto = SoggettoRitenutaAcconto
};
foreach (var mov in Movimenti)
{
dettaglio.Movimenti.Add((MovimentoContabile)mov.Copy());
}
return dettaglio;
}
