/// <summary>
/// Crea un Versamento Condomino valido.
/// </summary>
public VersamentoSoggetto(Esercizio esercizio, SoggettoCondominio soggetto, Conto conto, DateTime data, decimal importo, int numeroProtocollo, TipoVersamentoSoggettoEnum tipo, LogTransazione logTransazione, TipoVersamentoDopoChiusuraEnum? tipoVersamentoDopoChiusura = null, TipoVersamentoPrimaAperturaEnum? tipoVersamentoPrimaApertura = null)
{
Esercizio = esercizio;
Soggetto = soggetto;
ContoPatrimoniale = conto;
Data = data;
Importo = importo;
Tipo = tipo;
NumeroProtocollo = numeroProtocollo;
TipoVersamentoDopoChiusura = tipoVersamentoDopoChiusura;
TipoVersamentoPrimaApertura = tipoVersamentoPrimaApertura;
if (Esercizio != null && Esercizio.Gestione == GestioneEsercizioEnum.Straordinario)
{
TipoVersamentoDopoChiusura = null;
TipoVersamentoPrimaApertura = null;
}
if (Soggetto != null)
Soggetto.Versamenti.Add(this);
LogTransazione = logTransazione;
if (LogTransazione != null)
LogTransazione.Versamenti.Add(this);
}
/// <summary>
/// Crea un Proprietario valido
/// </summary>
public ModelloContabileFornitore(Fornitore fornitore, ModelloRegistrazioneContabile modello, LogTransazione logTransazione)
{
Fornitore = fornitore;
Modello = modello;
if (LogTransazione != null)
LogTransazione.ModelliContabiliFornitore.Add(this);
}
/// <summary>
/// Crea un elemento di evasione bancaria valida
/// </summary>
public EvasioneBancaria(string descrizione, LogTransazione logTransazione)
{
Descrizione = descrizione;
LogTransazione = logTransazione;
if (LogTransazione != null)
LogTransazione.EvasioniBancarie.Add(this);
}
/// <summary>
/// Crea un file CBI valido
/// </summary>
public FileCBI(string hashCode, Azienda azienda, LogTransazione logTransazione)
{
Azienda = azienda;
HashCode = hashCode;
LogTransazione = logTransazione;
if (LogTransazione != null)
LogTransazione.FileCbi.Add(this);
}
public PianoRateale(Esercizio esercizio, TipoAccorpamentoRateEnum tipo, LogTransazione logTransazione)
{
Tipo = tipo;
Esercizio = esercizio;
LogTransazione = logTransazione;
if (LogTransazione != null)
LogTransazione.PianoRateale.Add(this);
}
/// <summary>
/// Crea una Disposizione valida
/// </summary>
public Disposizione(string descrizione, DateTime? data, Azienda azienda, LogTransazione logTransazione)
{
Descrizione = descrizione;
Data = data;
Azienda = azienda;
LogTransazione = logTransazione;
if (LogTransazione != null)
LogTransazione.DisposizioniPagamento.Add(this);
}
/// <summary>
/// Crea uno Modello di regisrazione contabile valido
/// </summary>
public ModelloRegistrazioneContabile(Condominio stabileRiferimento, string descrizione, LogTransazione logTransazione)
{
_descrizione = descrizione;
_condominioRiferimento = stabileRiferimento;
if (stabileRiferimento != null)
stabileRiferimento.ModelliRegistrazioneContabile.Add(this);
if (LogTransazione != null)
LogTransazione.ModelliContabili.Add(this);
}
/// <summary>
/// Crea un Versamento Condomino valido.
/// </summary>
public VersamentoSoggetto(Esercizio esercizio, SoggettoCondominio soggetto, Conto conto, DateTime data, decimal importo, FileCBI file, DatiBancariCondomini contoBancario, LogTransazione logTransazione, TipoVersamentoDopoChiusuraEnum? tipoVersamentoDopoChiusura = null, TipoVersamentoPrimaAperturaEnum? tipoVersamentoPrimaApertura = null)
: this(esercizio, soggetto, conto, data, importo, 0, TipoVersamentoSoggettoEnum.CBI, logTransazione, tipoVersamentoDopoChiusura, tipoVersamentoPrimaApertura)
{
ContoBancario = contoBancario;
File = file;
if (File != null)
File.Versamenti.Add(this);
}
/// <summary>
/// Crea una Spesa valida
/// </summary>
public Spesa(Fornitore fornitore, Esercizio esercizio, LogTransazione logTransazione)
{
FornitoreRiferimento = fornitore;
EsercizioRiferimento = esercizio;
Stato = StatoSpesaEnum.Inserita;
LogTransazione = logTransazione;
if (LogTransazione != null)
LogTransazione.Spese.Add(this);
}
/// <summary>
/// Crea una Pratica valido
/// </summary>
public Pratica(Condominio stabile, Persona personaRiferimento, TipoPratica tipoPratica, DateTime? dataApertura, int? aziendaID, LogTransazione logTransazione)
{
_condominioRiferimento = stabile;
_personaRiferimento = personaRiferimento;
_tipoPraticaRiferimento = tipoPratica;
_aziendaID = aziendaID;
_dataApertura = dataApertura;
LogTransazione = logTransazione;
if (stabile != null)
stabile.Pratiche.Add(this);
}
/// <summary>
/// Crea una Testata di movimento contabile valida
/// </summary>
public PianoRateale(RendicontoAnnuale rendiconto, TipoAccorpamentoRateEnum tipo, LogTransazione logTransazione)
{
Rendiconto = rendiconto;
Tipo = tipo;
if(Rendiconto != null)
Esercizio = rendiconto.Esercizio;
LogTransazione = logTransazione;
if (LogTransazione != null)
LogTransazione.PianoRateale.Add(this);
}
public void SetUp()
{
_documentService = MockRepository.GenerateStub<IDocumentService>();
_fileSystem = MockRepository.GenerateStub<IFileSystem>();
const string str = "Documento Bolletta di Prova";
_documentoSpesa = new byte[str.Length * sizeof(char)];
Buffer.BlockCopy(str.ToCharArray(), 0, _documentoSpesa, 0, _documentoSpesa.Length);
_fileSystem = MockRepository.GenerateStub<IFileSystem>();
_fileSystem.Stub(x => x.ReadAllBytes(Arg<string>.Is.Anything)).Return(_documentoSpesa);
IList<Spesa> listaSpese = new List<Spesa>();
_utente = new Utente("PP");
_logTransazione = new LogTransazione(AzioneUtente.TransazioneContabile, _utente, Guid.NewGuid().ToString());
_azienda = new Azienda("PROV", "Prova") { ID = 1 };
_condominio1 = new Condominio("Condominio 1", 31, 12, 2014, _azienda) { CodiceFiscale = "91138030373" };
_annoGestionaleCondominio1 = new AnnoGestionale(_condominio1, 2014, 2014);
_esercizioCondominio1 = new Esercizio(_condominio1, new DateTime(2014, 1, 1), new DateTime(2014, 12, 31), _annoGestionaleCondominio1, GestioneEsercizioEnum.Ordinario);
_condominio2 = new Condominio("Condominio 2", 31, 12, 2014, _azienda) { CodiceFiscale = "90036640374" };
_annoGestionaleCondominio2 = new AnnoGestionale(_condominio2, 2014, 2014);
_esercizioCondominio2 = new Esercizio(_condominio2, new DateTime(2014, 1, 1), new DateTime(2014, 12, 31), _annoGestionaleCondominio2, GestioneEsercizioEnum.Ordinario);
_persona = new Persona(TipoPersonaEnum.Fisica, "Mario", "Rossi", _azienda.ID, true);
_fornitore = new Fornitore(_persona, _azienda.ID);
_documentiBolletteDTO = buildDocumentoBolletteDTO();
foreach (var documentoBollettaDTO in _documentiBolletteDTO)
{
var esercizio = _esercizioCondominio1;
if (documentoBollettaDTO.CodiceFiscaleCliente == _condominio2.CodiceFiscale)
esercizio = _esercizioCondominio2;
listaSpese.Add(new Spesa(_fornitore, esercizio, _logTransazione) { ID = documentoBollettaDTO.IdSpesa, NumeroDocumento = documentoBollettaDTO.NumeroDocumento, DataDocumento = documentoBollettaDTO.DataDocumento });
}
_daoFactory = MockRepository.GenerateStub<IDaoFactory>();
_daoFactory.Stub(x => x.GetCondominioDao().GetByCodiceFiscale(_condominio1.CodiceFiscale)).Return(_condominio1);
_daoFactory.Stub(x => x.GetCondominioDao().GetByCodiceFiscale(_condominio2.CodiceFiscale)).Return(_condominio2);
_spesaDao = MockRepository.GenerateStub<ISpesaDao>();
_documentoDao = MockRepository.GenerateStub<IDocumentoDao>();
_daoFactory.Stub(x => x.GetSpesaDao()).Return(_spesaDao);
_daoFactory.Stub(x => x.GetDocumentoDao()).Return(_documentoDao);
foreach (var spesa in listaSpese)
_spesaDao.Stub(x => x.Find(spesa.ID, false)).Return(spesa);
_utenzaDocumentoService = MockRepository.GenerateMock<UtenzaDocumentoService>(_daoFactory, _documentService, _fileSystem);
}
/// <summary>
/// Crea il Dettaglio delle unità immobiliari partecipanti ad un modello di ripartizione
/// </summary>
public DettaglioModelloRegistrazioneContabile(ContiModelloRegistrazioneContabile contoModello, LogTransazione logTransazione)
{
if (contoModello != null)
{
_contoModello = contoModello;
_contoModello.Unita.Add(this);
}
if (LogTransazione != null)
LogTransazione.DettaglioModelliContabili.Add(this);
}
/// <summary>
/// Crea il dettaglio di ripartizione conti per un modello di ripartizione
/// </summary>
public ContiModelloRegistrazioneContabile(ModelloRegistrazioneContabile modello, Conto contoRiferimento, SottoConto sottoContoRiferimento, decimal? percentuale, LogTransazione logTransazione)
{
if (modello != null)
{
_modello = modello;
_contoRiferimento = contoRiferimento;
_sottoContoRiferimento = sottoContoRiferimento;
_percentualeRipartizione = percentuale;
_modello.Conti.Add(this);
}
if (LogTransazione != null)
LogTransazione.ContiModelliContabili.Add(this);
}
/// <summary>
/// Crea una rata di pagamento condomino valida.
/// </summary>
public RataSoggetto(Esercizio esercizio, SoggettoCondominio soggetto, DateTime dataScadenza, decimal importo, LogTransazione logTransazione)
{
Esercizio = esercizio;
Soggetto = soggetto;
DataScadenza = dataScadenza;
Importo = importo;
_stato = StatoRataEnum.Inserita;
if (Soggetto != null)
Soggetto.Rate.Add(this);
LogTransazione = logTransazione;
if (LogTransazione != null)
LogTransazione.Rate.Add(this);
}
/// <summary>
/// Crea una Testata di movimento contabile valida
/// </summary>
public TestataMovimentoContabile(Esercizio esercizio, DateTime? dataRegistrazione, TipoTestataMovimentoContabileEnum tipo, LogTransazione logTransazione)
{
EsercizioRiferimento = esercizio;
DataRegistrazione = dataRegistrazione;
Tipo = tipo;
LogTransazione = logTransazione;
if (LogTransazione != null)
LogTransazione.TestateContabili.Add(this);
if (Tipo == TipoTestataMovimentoContabileEnum.Manuale)
IsAllowUpdate = true;
else if (Tipo == TipoTestataMovimentoContabileEnum.Automatica)
IsAllowUpdate = false;
}
/// <summary>
/// Crea un Subentro valido
/// </summary>
public Subentro(Condominio condominio, DateTime data, TipoSoggetto tipoSubentro, string oggettoLettera, string testoLettera, decimal competenzeUscente, decimal competenzeEntrante, bool trasferimentoSaldi, LogTransazione logTransazione)
{
Condominio = condominio;
Data = data;
TipoSubentro = tipoSubentro;
TrasferimentoSaldi = trasferimentoSaldi;
OggettoLettera = oggettoLettera;
TestoLettera = testoLettera;
CompetenzeEntrante = competenzeEntrante;
CompetenzeUscente = competenzeUscente;
LogTransazione = logTransazione;
if (LogTransazione != null)
LogTransazione.Subentri.Add(this);
}
public LogTransazione AddLog(int idUtente, AzioneUtente azioneUtente)
{
try
{
var utente = _daoFactory.GetUtenteDao().GetById(idUtente, false);
var identificativo = Guid.NewGuid().ToString();
var logTransazione = new LogTransazione(azioneUtente, utente, identificativo);
_daoFactory.GetLogTransazioneDao().SaveOrUpdate(logTransazione);
return logTransazione;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante log della transazione - {0} - azione:{1}", ex, Library.Utility.GetMethodDescription(), azioneUtente);
return null;
}
}
/// <summary>
/// Crea un dettaglio di piano di riparto valido.
/// </summary>
public PianoRatealeDettaglio(PianoRateale pianoRatealeRiferimento, DateTime? dataScadenza, decimal? percentualeRiparto, int progressivoRata, bool daSubentro, LogTransazione logTransazione)
{
PianoRatealeRiferimento = pianoRatealeRiferimento;
DataScadenza = dataScadenza;
PercentualeRiparto = percentualeRiparto;
Progressivo = progressivoRata;
Stato = StatoRataEnum.Inserita;
DaSubentro = daSubentro;
if (pianoRatealeRiferimento != null)
pianoRatealeRiferimento.Rate.Add(this);
LogTransazione = logTransazione;
if (LogTransazione != null)
LogTransazione.PianoRatealeDettaglio.Add(this);
}
public void Commit(LogTransazione logTransazione = null)
{
try
{
if (logTransazione != null)
{
_logTransazioneService.Save(logTransazione);
}
if(_persistenceContext != null)
_persistenceContext.CommitAndCloseSession(_utente);
}
catch (Exception ex)
{
var log = LogManager.GetLogger("Sfera");
log.WarnFormat("Errore durante il commit della transazione - {0}", ex, Library.Utility.GetMethodDescription());
throw;
}
}
/// <summary>
/// Crea una rata di pagamento condomino valida.
/// </summary>
public RataSoggetto(PianoRatealeDettaglio pianoRatealeDettaglio, SoggettoCondominio soggetto, DateTime dataScadenza, decimal importo, LogTransazione logTransazione)
{
PianoRatealeDettaglio = pianoRatealeDettaglio;
Esercizio = PianoRatealeDettaglio.PianoRatealeRiferimento.Esercizio;
Soggetto = soggetto;
DataScadenza = dataScadenza;
Importo = importo;
_stato = StatoRataEnum.Inserita;
if (Soggetto != null)
Soggetto.Rate.Add(this);
if (PianoRatealeDettaglio != null)
PianoRatealeDettaglio.RateSoggetti.Add(this);
LogTransazione = logTransazione;
if (LogTransazione != null)
LogTransazione.Rate.Add(this);
}
public LogTransazione AddLog(Utente utente, ComputerDTO computerDto, IpAddress clientIp, AzioneUtente azioneUtente)
{
try
{
var azienda = _daoFactory.GetAziendaDao().GetById(utente.AziendaID.GetValueOrDefault(), false);
var version = new ComputerVersion
{
FrameworkVersion = computerDto.FrameworkVersion,
FrameworkServicePack = computerDto.FrameworkServicePack,
OsBits = computerDto.OsBits,
OsEdition = computerDto.OsEdition,
OsName = computerDto.OsName,
OsServicePack = computerDto.OsServicePack,
OsVersionString = computerDto.OsVersionString,
ProcessorBits = computerDto.ProcessorBits
};
var computer = _daoFactory.GetComputerDao().GetByNomeAzienda(computerDto.ComputerName, azienda.ID);
if (computer != null)
{
computer.Version = version;
computer.UltimoLogin = DateTime.Now;
_daoFactory.GetComputerDao().SaveOrUpdate(computer);
}
else
{
computer = new Computer(computerDto.ComputerName, version, azienda);
_daoFactory.GetComputerDao().SaveOrUpdate(computer);
}
var logTransazione = new LogTransazione(azioneUtente, computer, clientIp, utente, version);
_daoFactory.GetLogTransazioneDao().SaveOrUpdate(logTransazione);
return logTransazione;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante log della transazione - {0} - azione:{1}", ex, Library.Utility.GetMethodDescription() ,azioneUtente);
return null;
}
}
//Non considero nessun vincolo sull'apertura delle pratiche
public string AperturaPratica(int idPratica, DateTime dataApertura, int tipoPratica, int condominioRiferimento, int? personaRiferimento, string oggetto, Urgenza urgenza, ConformitaPratiche? conformita, int aziendaId, LogTransazione logTransazione, out Pratica pratOutput)
{
pratOutput = null;
var message = string.Empty;
try
{
_condominio = _daoFactory.GetCondominioDao().GetById(condominioRiferimento, false);
var pratDao = _daoFactory.GetPraticaDao();
var persDao = _daoFactory.GetPersonaDao();
var tipoPratDao = _daoFactory.GetTipoPraticaDao();
Persona persona = null;
if(personaRiferimento != null)
persona = persDao.GetById(personaRiferimento.GetValueOrDefault(), false);
var tipoPraticaRif = tipoPratDao.GetById(tipoPratica, false);
var pratica = new Pratica(_condominio, persona, tipoPraticaRif, dataApertura, aziendaId, logTransazione) { StatoPratica = "Aperta", Oggetto = oggetto.Truncate(250), Conformita = conformita, Urgenza = urgenza };
if(logTransazione == null)
pratOutput = pratDao.SaveOrUpdate(pratica);
// Richiedente
if (persona != null)
{
var richiedente = new PraticaRichiedente(pratica, persona, pratica.DataApertura) { Note = "Apertura" };
_daoFactory.GetPraticaRichiedenteDao().SaveOrUpdate(richiedente);
pratica.Richiedenti.Add(richiedente);
}
}
catch (Exception ex)
{
_log.ErrorFormat("Non è stato possibile aprire la pratica. Errore durante il salvataggio delle informazioni - {0} - tipoPratica:{1}", ex, Utility.GetMethodDescription(), tipoPratica);
message = "Non è stato possibile aprire la pratica. Errore durante il salvataggio delle informazioni";
}
return message;
}
public string AperturaAutomaticaPratiche(IList<PraticaDTO> pratiche, IList<int> condomini, Urgenza urgenza, int idAzienda, LogTransazione logTransazione)
{
var result = string.Empty;
try
{
foreach (var idCondominio in condomini)
{
foreach (var praticaDTO in pratiche)
{
Pratica pratica;
AperturaPratica(0, DateTime.Now, praticaDTO.IdTipoPraticaRiferimento, idCondominio, null, praticaDTO.Oggetto, urgenza, null, idAzienda, logTransazione, out pratica);
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nell'apertura automatica delle pratiche - {0} - condomini:{1} - pratiche:{2}", ex, Utility.GetMethodDescription(), condomini.Aggregate(string.Empty, (current, id) => current + $"{id},"), pratiche.Aggregate(string.Empty, (current, nome) => current + $"{nome.Oggetto},"));
throw;
}
return result;
}
public void SetMovimentiPagamenti(Disposizione disposizione, string tipoConto, LogTransazione logTransazione)
{
try
{
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("PF");
var lista = new Dictionary<Esercizio, TestataMovimentoContabile>(disposizione.Pagamenti.Count);
foreach (var pag in disposizione.Pagamenti)
{
try
{
var numeroRiga = 0;
var esercizioRiferimento = getEsercizioCompetenza(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento, pag.Data.GetValueOrDefault());
if (esercizioRiferimento == null)
{
var ex = new InvalidDataException(string.Format("Non trovato nessun esercizio attivo"));
_log.FatalFormat("Non trovato nessun esercizio attivo - {0} - condominio:{1} - disposizione:{2} - tipoConto:{3}", ex, Utility.GetMethodDescription(), pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, disposizione.ID, tipoConto);
throw ex;
}
var message = IsAllowDataRegistrazione(new List<int> { esercizioRiferimento.CondominioRiferimento.ID }, esercizioRiferimento, pag.Data.GetValueOrDefault());
if (message.Count == 0)
{
// ================================================
// Testata
// ================================================
TestataMovimentoContabile testata;
if (lista.ContainsKey(esercizioRiferimento))
testata = lista[esercizioRiferimento];
else
{
testata = new TestataMovimentoContabile(esercizioRiferimento, pag.Data, TipoTestataMovimentoContabileEnum.Automatica, logTransazione);
if(logTransazione == null)
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
// Per ora ritengo opportuno avere una testata di movimento contabile distinta per ogni pagamento.
// Per avere un testata che accorpi diversi pagamenti è sufficiente scommentare la riga successiva.
//lista.Add(esercizioRiferimento, testata);
}
// ================================================
// Debiti VS Fornitori
// ------------------------------------------------
// Se è già presente un movimento contabile legato alla ritenute
// vuol dire che il pagamento stato annullato.
// In questo caso il movimento di ritenuta non deve essere generato
// ================================================
numeroRiga++;
var importoFornitori = pag.Importo.GetValueOrDefault();
if (pag.RitenutaAcconto != null && pag.RitenutaAcconto.MovimentoContabileCreazione == null)
importoFornitori += pag.RitenutaAcconto.Importo.GetValueOrDefault();
var movimentoPatrimoniale = new MovimentoContabile(testata, pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.ID, pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoFornitori()), importoFornitori, "D")
{
Descrizione = string.Format("Pagamento Fatt. n.{0} del {1:d}", pag.ScadenzaRiferimento.SpesaRiferimento.NumeroDocumento, pag.ScadenzaRiferimento.SpesaRiferimento.DataDocumento.GetValueOrDefault())
};
if(logTransazione == null)
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);
// ================================================
// Ritenuta
// ================================================
decimal importoRitenuta = 0;
if (pag.ScadenzaRiferimento.SpesaRiferimento.Detrazione.GetValueOrDefault() == 0 && pag.RitenutaAcconto != null && pag.RitenutaAcconto.MovimentoContabileCreazione == null && pag.RitenutaAcconto.Importo != null && pag.RitenutaAcconto.Importo.GetValueOrDefault() != 0)
{
numeroRiga++;
var segnoRitenuta = "A";
importoRitenuta = pag.RitenutaAcconto.Importo.GetValueOrDefault();
if (pag.RitenutaAcconto.Importo.GetValueOrDefault() < 0)
{
segnoRitenuta = "D";
importoRitenuta = importoRitenuta * -1;
}
var movimentoRitenuta = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.ID, pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoRitenuta()), importoRitenuta, segnoRitenuta)
{
FornitoreRiferimento = movimentoPatrimoniale.FornitoreRiferimento
};
if (!string.IsNullOrEmpty(pag.ScadenzaRiferimento.SpesaRiferimento.NumeroDocumento) && pag.ScadenzaRiferimento.SpesaRiferimento.DataDocumento != null)
movimentoRitenuta.Descrizione = "Ritenuta Fatt. n." + pag.ScadenzaRiferimento.SpesaRiferimento.NumeroDocumento + " del " + pag.ScadenzaRiferimento.SpesaRiferimento.DataDocumento.Value.ToShortDateString();
pag.RitenutaAcconto.MovimentoContabileCreazione = movimentoRitenuta;
if(logTransazione == null)
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoRitenuta);
}
// ================================================
// Conto Patrimoniale
// ================================================
numeroRiga++;
if (pag.Conto == null)
{
switch (tipoConto)
{
case "B":
pag.Conto = _daoFactory.GetContoDao().GetByCodice(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.ID, pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoBancario());
break;
case "C":
pag.Conto = _daoFactory.GetContoDao().GetByCodice(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.ID, pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, "903");
break;
}
}
var segnoPagamento = "A";
var importoPagamento = importoFornitori - importoRitenuta;
if (importoPagamento < 0)
{
segnoPagamento = "D";
importoPagamento = importoPagamento * -1;
// Inverto segno e importo anche per il movimento di Debiti v/Fornitori
movimentoPatrimoniale.Segno = invertiSegno("D");
movimentoPatrimoniale.Importo = importoFornitori * -1;
}
var movimentoBancario = new MovimentoContabile(testata, causale, numeroRiga, pag.Conto, importoPagamento, segnoPagamento)
{
Descrizione = movimentoPatrimoniale.GetDescrizione(),
NumeroAssegno = pag.NumeroAssegno,
FornitoreRiferimento =
pag.ScadenzaRiferimento.SpesaRiferimento.
FornitoreRiferimento,
SottoContoRiferimento = pag.SottoConto,
ContoCorrenteBancario = pag.ContoCorrenteBancario
};
pag.MovimentoContabile = movimentoBancario;
if (logTransazione == null)
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoBancario);
}
else
{
var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", pag.Data.GetValueOrDefault()));
_log.FatalFormat("Data di registrazione non valida - {0} - data:{1} - pagamento:{2} - disposizione:{3} - tipoConto:{4} - esercizio:{5}", ex, Utility.GetMethodDescription(), pag.Data.GetValueOrDefault(), pag.ID, disposizione.ID, tipoConto, esercizioRiferimento.ID);
throw ex;
}
}
catch (Exception ex)
{
_log.FatalFormat("Errore inaspettato durante la scrittura dei movimenti per pagamenti - (SINGOLO PAGAMENTO) - {0} - pagamento:{1} - disposizione:{2}", ex, Utility.GetMethodDescription(), pag.ID, disposizione.ID);
throw;
}
}
}
catch (Exception ex)
{
_log.FatalFormat("Errore inaspettato durante la scrittura dei movimenti per pagamenti - {0} - disposizione:{1}", ex, Utility.GetMethodDescription(), disposizione.ID);
throw;
}
}
public void CorrezioneArrotondamenti(LogTransazione logTransazione)
{
var hql = "FROM TestataMovimentoContabile TES LEFT JOIN FETCH TES.Movimenti MOV LEFT JOIN FETCH MOV.ContoRiferimento CON LEFT JOIN FETCH TES.EsercizioRiferimento ESE LEFT JOIN FETCH MOV.Causale CAU WHERE CAU.Codice <> 'AB' AND CAU.Codice <> 'ST' AND ESE.Stato = :stato";
var testate = _daoFactory.GetTestataMovimentoContabileDao().GetByQuery(hql, new QueryParam("stato", Conversione.ToHQLParameter(StatoEsercizioEnum.Aperto)));
foreach (var testataMovimentoContabile in testate)
{
var movimentoArrotondamento = testataMovimentoContabile.Movimenti.FirstOrDefault(item => item.ContoRiferimento.IsArrotondamento);
if (movimentoArrotondamento != null)
{
var importoSquadrato = getImportoSquadrato(testataMovimentoContabile);
if (importoSquadrato != 0)
{
var importo = getImportoSquadrato(testataMovimentoContabile, true);
var segno = "D";
if (importo < 0)
segno = "A";
movimentoArrotondamento.Importo = Math.Abs(importo);
movimentoArrotondamento.Segno = segno;
}
//if(importoSquadrato == movimentoArrotondamento.Importo.GetValueOrDefault())
// DeleteSingoloMovimento(movimentoArrotondamento);
}
else
{
setMovimentoArrotondamento(testataMovimentoContabile, testataMovimentoContabile.Movimenti.FirstOrDefault().Causale, logTransazione);
}
}
}
public AuthorizationMessages EvadiMovimento(string descrizione, IList<MovimentoContabile> movimentiContabili, IList<int> idMovimentiBancari, DateTime? dataRegistrazione, LogTransazione logTransazione)
{
var fatalMessage = string.Empty;
var warnMessage = string.Empty;
try
{
MovimentoBancario movimentoBancarioSingolo = null;
var aggiornaDataRegistrazione = true;
if (idMovimentiBancari.Count == 1)
{
movimentoBancarioSingolo = _daoFactory.GetMovimentoBancarioDao().GetById(idMovimentiBancari[0], false);
if (dataRegistrazione == null)
dataRegistrazione = movimentoBancarioSingolo.DataContabile;
// =================================================================
// Controllo data registrazione
// =================================================================
foreach (var movimentoContabile in movimentiContabili)
{
try
{
if (movimentoContabile != null)
{
var message = IsAllowDataRegistrazione(new List<int> { movimentoContabile.Testata.EsercizioRiferimento.CondominioRiferimento.ID }, movimentoContabile.Testata.EsercizioRiferimento, dataRegistrazione.GetValueOrDefault());
if (message.Count > 0)
{
aggiornaDataRegistrazione = false;
_log.DebugFormat("Data di registrazione non valida - {0} - data:{1} - movimentoContabile:{2} - movimentoBancario:{3} - esercizio:{4}", Utility.GetMethodDescription(), movimentoBancarioSingolo.DataContabile.GetValueOrDefault(), movimentoContabile.ID, movimentoBancarioSingolo.ID, movimentoContabile.Testata.EsercizioRiferimento.ID);
warnMessage += string.Format("La data di registrazione del movimento contabile non è stata aggiornata con la data del movimento bancario perchè la data {0:d} non è valida per l'esercizio {1}{2}", movimentoBancarioSingolo.DataContabile.GetValueOrDefault(), movimentoContabile.Testata.EsercizioRiferimento.DisplayName, Environment.NewLine);
//warnMessage = message.Aggregate(fatalMessage, (current, mess) => current + (mess + Environment.NewLine));
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante il controllo della data di registrazione - {0} - descrizione:{1} - movimento:{2}", ex, Utility.GetMethodDescription(), descrizione, movimentoContabile.ID);
fatalMessage = "Errore inaspettato durante la conferma del movimento contabile.";
}
}
if (!string.IsNullOrEmpty(fatalMessage))
return new AuthorizationMessages(fatalMessage, warnMessage);
}
// =================================================================
// Nuovo oggetto Evasione Bancaria
// =================================================================
var evasione = new EvasioneBancaria(descrizione, logTransazione);
if (logTransazione == null)
_daoFactory.GetEvasioneBancariaDao().SaveOrUpdate(evasione);
// =================================================================
// Evasione di tutti i movimenti contabili
// =================================================================
foreach (var movimentoContabile in movimentiContabili)
{
try
{
if (movimentoContabile != null)
{
movimentoContabile.EvasioneBancaria = evasione;
if (movimentoBancarioSingolo != null)
{
if (aggiornaDataRegistrazione)
{
movimentoContabile.Testata.DataRegistrazione = dataRegistrazione;
if (movimentoContabile.ID > 0)
{
// Se è associato un pagamento al movimento aggiorno la data di pagamento
var pagamento = _daoFactory.GetPagamentoDao().GetByMovimentoContabile(movimentoContabile);
if (pagamento != null)
pagamento.Data = movimentoContabile.Testata.DataRegistrazione;
// Se è associato un versamento condomino al movimento aggiorno la data di versamento
var versamento = _daoFactory.GetVersamentoSoggettoDao().GetByMovimentoContabile(movimentoContabile);
if (versamento != null)
versamento.Data = movimentoContabile.Testata.DataRegistrazione.GetValueOrDefault();
}
}
}
movimentoContabile.Stato = StatoMovimentoContabileEnum.Evaso;
if (movimentoContabile.ID > 0)
{
var pag = _daoFactory.GetPagamentoDao().GetByMovimentoContabile(movimentoContabile);
if (pag != null)
{
if (pag.TipoCodiceConfermaBonifico == TipoCodiceEsitoDisposizioneBonifico.Undefined)
pag.TipoCodiceConfermaBonifico =
TipoCodiceEsitoDisposizioneBonifico.MovimentoBancario;
pag.Stato = StatoSpesaEnum.Evasa;
}
}
}
else
{
_log.ErrorFormat("Errore inaspettato durante la conferma del movimento contabile. Non è stato trovato il movimento - {0} - descrizione:{1} - movimento:{2}", Utility.GetMethodDescription(), descrizione, movimentoContabile.ID);
fatalMessage = "Non è stato trovato il movimento contabile con id: " + movimentoContabile.ID + "." + Environment.NewLine + "Probabilmente è stato eliminato dall'utente in un'altra maschera.";
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la conferma del movimento contabile - SINGOLO MOVIMENTO CONTABILE - {0} - descrizione:{1} - movimento:{2}", ex, Utility.GetMethodDescription(), descrizione, movimentoContabile.ID);
fatalMessage = "Errore inaspettato durante la conferma del movimento contabile.";
}
}
// =================================================================
// Evasione di tutti i movimenti bancari
// =================================================================
foreach (var idMovimento in idMovimentiBancari)
{
try
{
var movimentoBancario = _daoFactory.GetMovimentoBancarioDao().Find(idMovimento, false);
if (movimentoBancario != null)
{
movimentoBancario.EvasioneBancaria = evasione;
movimentoBancario.Stato = StatoMovimentoBancarioEnum.Contabilizzato;
}
else
{
_log.ErrorFormat("Errore inaspettato durante la conferma del movimento bancario. Non è stato trovato il movimento - {0} - descrizione:{1} - movimento:{2}", Utility.GetMethodDescription(), descrizione, idMovimento);
fatalMessage = "Non è stato trovato il movimento bancario con id: " + idMovimento;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la conferma del movimento Bancario - SINGOLO MOVIMENTO BANCARIO - {0} - descrizione:{1} - movimento:{2}", ex, Utility.GetMethodDescription(), descrizione, idMovimento);
fatalMessage = "Errore inaspettato durante la conferma del movimento contabile.";
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la conferma della evasione bancaria - {0} - descrizione:{1} - movimento:{2}", ex, Utility.GetMethodDescription(), descrizione);
fatalMessage = "Errore inaspettato durante la conferma della evasione bancaria.";
}
return new AuthorizationMessages(fatalMessage, warnMessage);
}
public AuthorizationMessages EvadiMovimento(string descrizione, IList<int> idMovimentiContabili, IList<int> idMovimentiBancari, DateTime? dataRegistrazione, LogTransazione logTransazione)
{
var movimentiContabili = new List<MovimentoContabile>(idMovimentiContabili.Count);
foreach (var id in idMovimentiContabili)
{
var movimentoContabile = _daoFactory.GetMovimentoContabileDao().Find(id, false);
if(movimentoContabile != null)
movimentiContabili.Add(movimentoContabile);
}
return EvadiMovimento(descrizione, movimentiContabili, idMovimentiBancari, dataRegistrazione, logTransazione);
}
private void setMovimentoArrotondamento(decimal importoAvere, decimal importoDare, int numeroRiga, Spesa spesa, TestataMovimentoContabile testata, CausaleContabile causale, LogTransazione logTransazione)
{
if (importoAvere != importoDare)
{
var importoArrotondamento = importoAvere - importoDare;
numeroRiga++;
var segno = "D";
if (importoArrotondamento < 0)
{
segno = "A";
importoArrotondamento = importoArrotondamento * -1;
}
var contoArrotondamenti = _pianoContiService.GetContoArrotondamenti(testata.EsercizioRiferimento);
_daoFactory.GetContoDao().SaveOrUpdate(contoArrotondamenti);
var movimentoArrotondamento = new MovimentoContabile(testata, causale, numeroRiga, contoArrotondamenti, importoArrotondamento, segno)
{
Descrizione = spesa != null ? string.Format("Arrotondamento Fatt. n. {0} del {1:d}", spesa.NumeroDocumento, spesa.DataDocumento.GetValueOrDefault()) : string.Format("Arrotondamento per {0}", testata.GetDescrizione())
};
if(logTransazione == null)
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoArrotondamento);
}
}
private void setMovimentoArrotondamento(TestataMovimentoContabile testata, CausaleContabile causale, LogTransazione logTransazione)
{
var importoDare = 0m;
var importoAvere = 0m;
foreach (var movimento in testata.Movimenti)
{
if (movimento.Segno == "D")
importoDare += movimento.Importo.GetValueOrDefault();
else
importoAvere += movimento.Importo.GetValueOrDefault();
}
var differenza = importoAvere - importoDare;
if (differenza != 0)
{
var numeroRiga = testata.Movimenti.Max(item => item.NumeroRiga.GetValueOrDefault()) + 1;
setMovimentoArrotondamento(importoAvere, importoDare, numeroRiga, null, testata, causale, null);
}
}