/// <summary>
/// Crea una relazione tra Causale ACBI e Sottoconto valida
/// </summary>
public CausaleACBISottoconto(CausaleACBI causale, SottoConto sottoconto)
{
CausaleACBI = causale;
SottoConto = sottoconto;
if (CausaleACBI != null)
CausaleACBI.SottoConti.Add(this);
}
/// <summary>
/// Crea una Testata di movimento contabile valida
/// </summary>
public TestataRipartoContatoreCondominiale(Esercizio esercizio, Contatore contatoreCondominiale, Conto contoAddebito, SottoConto sottocontoAddebito, string descrizioneMovimentoAddebito)
{
Esercizio = esercizio;
ContatoreCondominiale = contatoreCondominiale;
ContoAddebito = contoAddebito;
SottocontoAddebito = sottocontoAddebito;
DescrizioneMovimentoAddebito = descrizioneMovimentoAddebito;
}
/// <summary>
/// Crea un movimento contabile valido.
/// E' relativo al conto economico connesso alla registrazione di una spesa
/// </summary>
public RipartizioneSpesa(Spesa spesa, Conto conto, SottoConto sottoConto, decimal? importo, string segno, string descrizione)
{
Spesa = spesa;
ContoRiferimento = conto;
SottoContoRiferimento = sottoConto;
Importo = importo;
Segno = segno;
Descrizione = descrizione;
}
/// <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 un movimento contabile valido.
/// </summary>
public MovimentoContabile(TestataMovimentoContabile testata, CausaleContabile causale, int? numeroRiga, SottoConto sottoConto, decimal? importo, string segno)
{
Causale = causale;
NumeroRiga = numeroRiga;
SottoContoRiferimento = sottoConto;
ContoRiferimento = sottoConto.ContoRiferimento;
Testata = testata;
Importo = importo;
Segno = segno;
Stato = StatoMovimentoContabileEnum.Inserito;
IsVisibileGestione = true;
if (Testata != null)
{
Testata.Movimenti.Add(this);
setNumeroRegistrazione();
}
}
public TestataMovimentoContabile SetMovimentiContatoreCondominiale(Esercizio esercizio, IList<ImportoMovimento> importiAccredito, IList<ImportiDTO> addebitiContatoriDivisionali, DateTime dataRegistrazione, Conto contoAddebito, SottoConto sottoContoAddebito, string descrizione)
{
// controllo data registrazione
var message = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
if (message.Count > 0)
{
var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", dataRegistrazione));
_log.FatalFormat("Data di registrazione non valida - {0} - data:{1} - esercizio:{2}", ex, Utility.GetMethodDescription(), dataRegistrazione, esercizio.ID);
throw ex;
}
var testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null)
{
Descrizione = descrizione,
IsAbilitataArchiviazioneOttica = false,
IsAllowUpdate = true
};
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("SC");
// -------------------------------------------------
// Calcolo Importo
// ------------------------------------------------
var importo = importiAccredito.Sum(item => item.Importo);
// -------------------------------------------------
// Segno Movimento
// ------------------------------------------------
var segnoContoEconomico = "D";
if (importo < 0)
{
segnoContoEconomico = "A";
importo = importo * -1;
}
// ------------------------------------------------
// Conto economico da addebitare
// ------------------------------------------------
var movimentoContoEconomicoAddebito = new MovimentoContabile(testata, causale, 1, contoAddebito, importo, segnoContoEconomico)
{
SottoContoRiferimento = sottoContoAddebito,
Descrizione = descrizione,
IsRipartoPersonalizzato = true
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoContoEconomicoAddebito);
// ------------------------------------------------
// Conto economico da accreditare
// ------------------------------------------------
foreach (var item in importiAccredito)
{
var movimentoContoEconomicoAccredito = new MovimentoContabile(testata, causale, 2, _daoFactory.GetContoDao().GetById(item.IdConto, false), item.Importo, invertiSegno(segnoContoEconomico)) { Descrizione = descrizione, IsRipartoPersonalizzato = true };
if(item.IdSottoConto > 0)
movimentoContoEconomicoAccredito.SottoContoRiferimento = _daoFactory.GetSottoContoDao().GetById(item.IdSottoConto.GetValueOrDefault(), false);
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoContoEconomicoAccredito);
// Ripartizione tra le unità immobiliari
var totaleMillesimi = addebitiContatoriDivisionali.Sum(mill => mill.Importo);
foreach (var importiDTO in addebitiContatoriDivisionali)
{
var unita = _daoFactory.GetUnitaImmobiliareDao().GetById(importiDTO.Id, false);
var importoUnita = (movimentoContoEconomicoAccredito.GetImportoConSegno() * importiDTO.Importo) / totaleMillesimi;
var spesaUnita = new SpeseUnita(importoUnita, unita, null, movimentoContoEconomicoAccredito);
_daoFactory.GetSpeseUnitaDao().SaveOrUpdate(spesaUnita);
}
}
return testata;
}
public MovimentoContabile SetMovimentoBancarioGenerico(DatiBancariCondomini banca, Esercizio esercizioRiferimento, SottoConto sottoconto, decimal importo, string descrizione, DateTime dataRegistrazione, CausaleContabile causale)
{
try
{
var message = IsAllowDataRegistrazione(new List<int> { esercizioRiferimento.CondominioRiferimento.ID }, esercizioRiferimento, dataRegistrazione);
if (message.Count > 0)
{
var ex = new InvalidDataException($"La data di registrazione {dataRegistrazione} non è valida");
_log.FatalFormat("Data di registrazione non valida - {0} - data:{1} - esercizio:{2}", ex, Utility.GetMethodDescription(), dataRegistrazione, esercizioRiferimento.ID);
throw ex;
}
var testata = new TestataMovimentoContabile(esercizioRiferimento, dataRegistrazione, TipoTestataMovimentoContabileEnum.Manuale, null)
{
Descrizione = descrizione,
IsAbilitataArchiviazioneOttica = false,
IsAllowUpdate = true
};
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
// -------------------------------------------------
// Segno Movimento
// ------------------------------------------------
string segnoContoEconomico = "D";
if (importo > 0)
segnoContoEconomico = "A";
else
importo = importo * -1;
// ------------------------------------------------
// Conto economico
// ------------------------------------------------
var movimentoContoEconomico = new MovimentoContabile(testata, causale, 1, sottoconto, importo, segnoContoEconomico) {Descrizione = descrizione};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoContoEconomico);
_ripartizioneService.SalvaRipartizione(movimentoContoEconomico, esercizioRiferimento.CondominioRiferimento.ID);
// ------------------------------------------------
// BANCA
// ------------------------------------------------
var movimentoBancario = new MovimentoContabile(testata, causale, 2, _daoFactory.GetContoDao().GetByCodice(esercizioRiferimento.ID, esercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoBancario()), importo, invertiSegno(segnoContoEconomico))
{
Descrizione = descrizione,
Stato = StatoMovimentoContabileEnum.Evaso,
ContoCorrenteBancario = banca
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoBancario);
return movimentoBancario;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella contabilizzazione di un movimento bancario - {0} - importo:{1} - descrizione:{2} - data registrazione:{3:d}", ex, Utility.GetMethodDescription(), importo, descrizione, dataRegistrazione);
throw;
}
}
public RendicontoAnnualeConto(RendicontoAnnuale rendiconto, SottoConto sottoConto, decimal? importo)
{
Rendiconto = rendiconto;
SottoContoRiferimento = sottoConto;
Importo = importo;
}
public virtual IUpdatableBusinessEntity Copy()
{
var sottoConto = new SottoConto(ContoRiferimento, Descrizione);
return sottoConto;
}
private Conto loadContoSottoconto(DataRow row, Condominio condominio, Conto conto, DataTable sottoconti, Dictionary<int, Conto> loadedConti)
{
if (conto == null) throw new ArgumentNullException("conto");
if (row["DESCR1"] != DBNull.Value)
{
var nomeConto = ((string)row["DESCR1"]).Trim();
if (nomeConto.Length > 50)
nomeConto = nomeConto.Substring(0, 50);
conto = new Conto(condominio, Sfera.Enums.TipoContoEconomicoEnum.Economico, Sfera.Enums.TipoPeriodoCompetenzaContabile.Esercizio, nomeConto, true, true, false)
{PresenteBilancio = true, Ordine = Convert.ToInt32(row["COLONNA"])};
conto.Codice = conto.Ordine.ToString().PadLeft(3, '0');
conto.CodiceImportazione = row["CODITTA"] + "&" + row["CODSTAB"] + "&" + row["COLONNA"];
var contoKey = Convert.ToInt32(row["CODSTAB"]) * 1000 + conto.Ordine;
if (!loadedConti.ContainsKey(contoKey))
loadedConti.Add(contoKey, conto);
// Sottoconti
var sottocontiRows = sottoconti.Select("CODPREDEF = " + row["COLONNA"], "PROGR");
ModelloRegistrazioneContabile modelloContabile = null;
foreach (var rowSottoconto in sottocontiRows)
{
var descrizioneSottoconto = string.Empty;
if (rowSottoconto["DESCR"] != DBNull.Value)
descrizioneSottoconto = rowSottoconto["DESCR"].ToString();
if (string.IsNullOrEmpty(descrizioneSottoconto) && rowSottoconto["TITOLO"] != DBNull.Value)
descrizioneSottoconto = rowSottoconto["TITOLO"].ToString();
if (!string.IsNullOrEmpty(descrizioneSottoconto))
{
var sottoconto = new SottoConto(conto, descrizioneSottoconto)
{
Codice = conto.Codice + "." + rowSottoconto["PROGR"].ToString().PadLeft(3, '0'),
CodiceImportazione =
rowSottoconto["CODITTA"] + "&" +
rowSottoconto["CODSTAB"] + "&" +
rowSottoconto["CODPREDEF"] + "&" +
rowSottoconto["PROGR"]
};
// Modelli
if (Convert.ToDecimal(rowSottoconto["PERCENT"]) < 100)
{
// Se ho già raggiunto il 100% il modello è completo
if (modelloContabile != null && modelloContabile.Conti.Sum(item => item.PercentualeRipartizione.GetValueOrDefault()) >= 1)
modelloContabile = null;
if (modelloContabile == null)
modelloContabile = new ModelloRegistrazioneContabile(condominio, sottoconto.GetDescrizione(null, condominio, null), null);
else
modelloContabile.Descrizione += " - " + sottoconto.GetDescrizione(null, condominio, null);
if (modelloContabile.Descrizione.Length > 100)
modelloContabile.Descrizione = modelloContabile.Descrizione.Substring(0, 100);
new ContiModelloRegistrazioneContabile(modelloContabile, conto, sottoconto, Convert.ToDecimal(rowSottoconto["PERCENT"]) / 100, null);
}
//else
// modelloContabile = null;
}
}
return conto;
}
return null;
}
public TestataMovimentoContabile TrasferimentoSaldiStraordinarioInOrdinario(int idEsercizioStraordinario, int idEsercizioOrdinario, string nomeContoOrdinario, int ordineConto, IBilancioService bilancioService, DateTime? dataChiusura, bool chiusuraTemporanea)
{
try
{
var esercizioStraordinario = _daoFactory.GetEsercizioDao().GetById(idEsercizioStraordinario, false);
var esercizioOrdinario = _daoFactory.GetEsercizioDao().GetById(idEsercizioOrdinario, false);
if (!chiusuraTemporanea)
{
var messagesDataRegistrazione = _movimentiContabiliService.IsAllowDataRegistrazione(new List<int> {esercizioStraordinario.CondominioRiferimento.ID}, esercizioOrdinario, dataChiusura.GetValueOrDefault());
if (messagesDataRegistrazione.Count > 0)
{
var messageDataRegistrazione = messagesDataRegistrazione.Aggregate(string.Empty, (current, mess) => current + (mess + Environment.NewLine));
var ex = new InvalidDataException($"La data di registrazione {dataChiusura.GetValueOrDefault()} non è valida" + Environment.NewLine + messageDataRegistrazione);
_log.Fatal(ex.Message, ex);
throw ex;
}
var contoOrdinario = new Conto(esercizioOrdinario.CondominioRiferimento, TipoContoEconomicoEnum.Economico, TipoPeriodoCompetenzaContabile.Esercizio, nomeContoOrdinario, false, false, false)
{
PresenteBilancio = true,
CustomField = false,
EsercizioRiferimento = esercizioOrdinario,
Ordine = ordineConto,
Codice = ordineConto.ToString(CultureInfo.InvariantCulture).PadLeft(3, '0'),
PercentualeProprieta = 1,
IsSpesePersonali = true,
TrasferimentoSaldiStraordinario = true
};
var contoArrotondamenti = _pianoContiService.GetContoArrotondamenti(esercizioOrdinario);
_daoFactory.GetContoDao().SaveOrUpdate(contoArrotondamenti);
var sottocontoOrdinario = new SottoConto(contoOrdinario, nomeContoOrdinario);
esercizioStraordinario.ContoEconomicoOrdinarioChiusuraStraordinario = contoOrdinario;
var items = bilancioService.GetDataSourceRipartizioneBilancioConsuntivo(esercizioStraordinario.ID, null, null, null, null, null, null, false, false, TipoAccorpamentoRateEnum.Nessuno, false, false, false, false, null).ToList();
var ripartoEconomici = items.Where(item => item.OrdineConto < 9900).ToList();
var testata = new TestataMovimentoContabile(esercizioOrdinario, dataChiusura, TipoTestataMovimentoContabileEnum.Automatica, null);
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
esercizioStraordinario.TestataContabileChiusura = testata;
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("ST");
// ===========================================================================
// Movimenti Chiusura/Apertura conti economici
// ---------------------------------------------------------------------------
// Chiusura di tutti i conti economici della gestione starordianaria (in avere),
// aprendo un conto economico "<CONTO ECONOMICO SALDI STRAORDINARIA>" nella gestione ordinaria (in dare), per il totale della spesa.
// La spesa deve essere ripartita sulla base dei conti utilizzati nella gestione straordinaria.
// I conti devono essere addebitati per soggetto.
// ===========================================================================
var numeroRiga = 0;
foreach (var itemRiparto in ripartoEconomici)
{
// Gli arrotondamenti hanno IdPartecipante == 0, queste righe devono essere usate per registrare i movimenti di arrotondamento.
if (itemRiparto.IdPartecipante > 0)
{
var importo = itemRiparto.Importo.GetValueOrDefault();
if (importo != 0)
{
try
{
var soggetto = _daoFactory.GetSoggettoCondominioDao().GetById(itemRiparto.IdPartecipante, false);
// ---------------------------------------------
// Apertura conto economico nell'ordinario
// ---------------------------------------------
numeroRiga++;
var movimentoAperturaOrdinario = new MovimentoContabile(testata, causale, 1, contoOrdinario, numeroRiga, "D")
{
Descrizione = $"Saldo Gestione Straordinaria '{esercizioStraordinario.Descrizione}' - {soggetto.DisplayName}",
CondominoRiferimento = soggetto,
SottoContoRiferimento = sottocontoOrdinario
};
// Calcolo del segno
var segnoEconomico = "D";
if (importo < 0)
{
segnoEconomico = "A";
importo = importo * -1;
}
movimentoAperturaOrdinario.Segno = segnoEconomico;
movimentoAperturaOrdinario.Importo = importo;
// ---------------------------------------------
// Chiusura conto economico nello straordinario
// ---------------------------------------------
numeroRiga++;
var movimentoChiusuraStraordinario = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetById(itemRiparto.IdConto, false), importo, invertiSegno(segnoEconomico)) { Descrizione = string.Format("Chiusura conto {0}: '{1}' - {2}", itemRiparto.DescrizioneConto, esercizioStraordinario.Descrizione, soggetto.DisplayName), CondominoRiferimento = movimentoAperturaOrdinario.CondominoRiferimento };
// ---------------------------------------------
// Dettaglio spesa unità
// ---------------------------------------------
var spesaUnita = new SpeseUnita(itemRiparto.Importo, null, soggetto, movimentoAperturaOrdinario);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante il trasferimento saldi dell'esercizio straordinario all'ordinario - MOVIMENTO CONTO ECONOMICO - {0} - importo:{1} - idEsercizioStraordinario:{2} - idEsercizioOrdinario:{3} - nomeContoOrdinario:{4} - ordineConto:{5}", ex, Library.Utility.GetMethodDescription(), importo, idEsercizioStraordinario, idEsercizioOrdinario, nomeContoOrdinario, ordineConto);
throw;
}
}
}
else
{
// ---------------------------------------------
// Apertura conto economico nell'ordinario
// ---------------------------------------------
var importo = itemRiparto.Importo;
numeroRiga++;
var movimentoAperturaOrdinario = new MovimentoContabile(testata, causale, 1, contoArrotondamenti, numeroRiga, "D") { Descrizione = $"Saldo Gestione Straordinaria '{esercizioStraordinario.Descrizione}'" };
// Calcolo del segno
var segnoEconomico = "D";
if (importo < 0)
{
segnoEconomico = "A";
importo = importo * -1;
}
movimentoAperturaOrdinario.Segno = segnoEconomico;
movimentoAperturaOrdinario.Importo = importo;
// ---------------------------------------------
// Chiusura conto economico nello straordinario
// ---------------------------------------------
numeroRiga++;
var movimentoChiusuraStraordinario = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetById(itemRiparto.IdConto, false), importo, invertiSegno(segnoEconomico)) { Descrizione = $"Arrondamento chiusura conto {itemRiparto.DescrizioneConto}: '{esercizioStraordinario.Descrizione}'"
};
}
}
// ===========================================================================
// Movimenti Chiusura/Apertura crediti v/condomini gestione straordinaria
// ---------------------------------------------------------------------------
// Chiusura del conto Crediti v/condomini della "<GESTIONE STRAORDINARIA>"
// per i versamenti effettuati nella gestione straordinaria, sul conto "<CONTO ECONOMICO SALDI STRAORDINARIA>",
// accreditando i singoli soggetti.
// ===========================================================================
var ripartoVersamenti = items.Where(item => item.OrdineConto == 9992).ToList();
// Aggiungo soggetti con saldo inziale ma senza versamenti
var saldiIniziali = items.Where(item => item.OrdineConto == 9991).ToList();
var ripartoSaldiIniziali = new List<ReportRipartizioneBilancioDTO>(saldiIniziali.Count);
foreach (var reportRipartizioneBilancioDTO in saldiIniziali)
{
if (ripartoVersamenti.All(item => item.IdPartecipante != reportRipartizioneBilancioDTO.IdPartecipante))
{
reportRipartizioneBilancioDTO.Importo = reportRipartizioneBilancioDTO.Importo.GetValueOrDefault()*-1;
ripartoVersamenti.Add(reportRipartizioneBilancioDTO);
}
else
ripartoSaldiIniziali.Add(reportRipartizioneBilancioDTO);
}
var contoVersamentiEsercizioStraordinario = _daoFactory.GetContoDao().GetByCodice(esercizioStraordinario.ID, esercizioStraordinario.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoVersamentiCondomini());
foreach (var itemRiparto in ripartoVersamenti)
{
var importo = itemRiparto.Importo.GetValueOrDefault();
// aggiungo eventuale saldo iniziale
var itemSaldoIniziale = ripartoSaldiIniziali.FirstOrDefault(item => item.IdPartecipante == itemRiparto.IdPartecipante);
var importoSaldoIniziale = 0m;
if (itemSaldoIniziale != null)
importoSaldoIniziale = itemSaldoIniziale.Importo.GetValueOrDefault();
importo -= importoSaldoIniziale;
try
{
// Gli arrotondamenti hanno IdPartecipante == 0, escludo queste righe.
if (itemRiparto.IdPartecipante > 0)
{
var soggetto = _daoFactory.GetSoggettoCondominioDao().GetById(itemRiparto.IdPartecipante, false);
// ---------------------------------------------
// Apetura conto economico nell'ordinario
// ---------------------------------------------
numeroRiga++;
var movimentoAperturaOrdinario = new MovimentoContabile(testata, causale, numeroRiga, contoOrdinario, 0, "D")
{
Descrizione = $"Saldo Gestione Straordinaria '{esercizioStraordinario.Descrizione}' - {soggetto.DisplayName}",
CondominoRiferimento = soggetto,
SottoContoRiferimento = sottocontoOrdinario
};
// Calcolo del segno
var segnoEconomico = "A";
if (importo < 0)
{
segnoEconomico = "D";
importo = importo * -1;
}
movimentoAperturaOrdinario.Segno = segnoEconomico;
movimentoAperturaOrdinario.Importo = importo;
// ---------------------------------------------
// Chiusura conto crediti v/condomini nello straordinario
// ---------------------------------------------
numeroRiga++;
var movimentoChiusuraStraordinario = new MovimentoContabile(testata, causale, numeroRiga, contoVersamentiEsercizioStraordinario, importo, invertiSegno(segnoEconomico)) { Descrizione = string.Format("Chiusura conto {0}: '{1}' - {2}", contoVersamentiEsercizioStraordinario.Descrizione, esercizioStraordinario.Descrizione, soggetto.DisplayName), CondominoRiferimento = movimentoAperturaOrdinario.CondominoRiferimento };
// ---------------------------------------------
// Dettaglio spesa unità
// ---------------------------------------------
var spesaUnita = new SpeseUnita((itemRiparto.Importo.GetValueOrDefault() - importoSaldoIniziale) * -1, null, soggetto, movimentoAperturaOrdinario);
}
}
catch (Exception ex)
{
_log.FatalFormat("Errore inaspettato durante il trasferimento saldi dell'esercizio straordinario all'ordinario - MOVIMENTO VERSAMENTI - {0} - importo:{1} - idEsercizioStraordinario:{2} - idEsercizioOrdinario:{3} - nomeContoOrdinario:{4} - ordineConto:{5}", ex, Library.Utility.GetMethodDescription(), importo, idEsercizioStraordinario, idEsercizioOrdinario, nomeContoOrdinario, ordineConto);
throw;
}
}
return testata;
}
else
{
// ====================================================================
// Chiusura temporanea dei conti
// ====================================================================
var movimentiEconomici = _daoFactory.GetMovimentoContabileDao().GetByEsercizioEconomici(esercizioStraordinario, esercizioOrdinario.DataApertura, esercizioOrdinario.DataChiusura);
var contoPatrimoniale = _pianoContiService.GetContoChiusuraStraordinario(esercizioStraordinario);
var testataChiusura = new TestataMovimentoContabile(esercizioStraordinario, dataChiusura, TipoTestataMovimentoContabileEnum.Automatica, null)
{
EsercizioOrdinarioChiusura = esercizioOrdinario,
Descrizione = $"Chiusura esercizio straordinario: '{esercizioStraordinario.DisplayName}' per chiusura dell'ordinario: '{esercizioOrdinario.DisplayName}'"
};
var causaleChiusura = _daoFactory.GetCausaleContabileDao().GetByCodice("C2");
var index = 0;
// =================================================
// Calcolo tutti i saldi dei conti
// =================================================
var saldiContoSottoconto = new Dictionary<string, MovimentoContabile>();
foreach (var movimentoContabile in movimentiEconomici)
{
var key = _movimentiContabiliService.GetKeyContoSottoconto(movimentoContabile);
if (saldiContoSottoconto.ContainsKey(key))
{
var movimentoChiusura = saldiContoSottoconto[key];
movimentoChiusura.Importo += movimentoContabile.GetImportoConSegno();
}
else
{
index++;
var movimentoChiusura = new MovimentoContabile(testataChiusura, causaleChiusura, index, movimentoContabile.ContoRiferimento, movimentoContabile.GetImportoConSegno(), string.Empty)
{
Descrizione = $"Chiusura esercizio straordinario: '{esercizioStraordinario.DisplayName}' per chiusura dell'ordinario: '{esercizioOrdinario.DisplayName}'",
CondominoRiferimento = movimentoContabile.CondominoRiferimento,
FornitoreRiferimento = movimentoContabile.FornitoreRiferimento,
ContoCorrenteBancario = movimentoContabile.ContoCorrenteBancario
};
saldiContoSottoconto.Add(key, movimentoChiusura);
}
}
// =================================================
// Elaboro i segni e creo le contropartite
// =================================================
foreach (var kvp in saldiContoSottoconto)
{
var movimentoContabile = kvp.Value;
if (movimentoContabile.ContoRiferimento.Tipo == TipoContoEconomicoEnum.Economico)
{
movimentoContabile.Segno = "A";
if (movimentoContabile.Importo < 0)
{
movimentoContabile.Segno = "D";
movimentoContabile.Importo = movimentoContabile.Importo*-1;
}
}
else if (movimentoContabile.ContoRiferimento.Tipo == TipoContoEconomicoEnum.Patrimoniale)
{
movimentoContabile.Segno = "D";
if (movimentoContabile.Importo < 0)
{
movimentoContabile.Segno = "A";
movimentoContabile.Importo = movimentoContabile.Importo * -1;
}
}
var movimentoPatrimoniale = new MovimentoContabile(testataChiusura, causaleChiusura, index, contoPatrimoniale, movimentoContabile.Importo, invertiSegno(movimentoContabile.Segno))
{
Descrizione = $"Chiusura conto '{kvp.Value.ContoRiferimento.Descrizione}' esercizio straordinario: '{esercizioStraordinario.DisplayName}' per chiusura dell'ordinario: '{esercizioOrdinario.DisplayName}'"
};
}
return testataChiusura;
}
}
catch (Exception ex)
{
_log.FatalFormat("Errore inaspettato durante il trasferimento saldi dell'esercizio straordinario all'ordinario - {0} - idEsercizioStraordinario:{1} - idEsercizioOrdinario:{2} - nomeContoOrdinario:{3} - ordineConto:{4} - dataChiusura:{5:d}", ex, Library.Utility.GetMethodDescription(), idEsercizioStraordinario, idEsercizioOrdinario, nomeContoOrdinario, ordineConto, dataChiusura.GetValueOrDefault());
throw;
}
}
private void updateSottoconto(SottoContoDTO dto, out SottoConto item)
{
item = null;
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
try
{
item = daoFactory.GetSottoContoDao().GetById(dto.ID, false);
// Condizione necessare per il controllo del fatto che sul DB ho una versione uguale o più vecchia
if (dto.Version == item.Version)
{
item.Codice = dto.Codice;
item.PercentualeProprieta = dto.PercentualeProprieta;
item.ContoRiferimento = daoFactory.GetContoDao().GetById(dto.IdContoRiferimento, false);
item.Descrizione = dto.Descrizione;
item.Version = dto.Version;
item.AddebitoCompetenze = dto.AddebitoCompetenze;
item.IsInteressiSanzioni = dto.IsInteressiSanzioni;
}
else
{
// Eccezione: Sul db c'è qualche cosa di più nuovo.
_log.ErrorFormat("Errore nel salvataggio dei sottoconti - id:{0} - il dato sul db è più recente di quello che si vuole salvare", dto.ID);
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel salvataggio dei conti - {0} - id:{1}", ex, Utility.GetMethodDescription(), dto.ID);
throw;
}
}
public void SetUp()
{
_azienda = new Azienda("PROVA", "Azienda di prova") {ID=1};
_aziendaDestinazione = new Azienda("DEST", "Azienda di destinazione") { ID = 2 };
_condominio = new Condominio("Condominio ABC", 31, 12, 2015, _azienda)
{
ID = 1,
Codice = "COND01",
CodiceCUC = "CUC123456",
CodiceSIA = "SIA12",
AnnoInizio = 2015,
CodiceFiscale = "012365477859",
CodiceCalcoloTariffaAcqua = "TAR01"
};
_condominio.Palazzine.Clear();
_esercizio = new EsercizioDTO
{
Descrizione = "Primo Esercizio",
DataApertura = new DateTime(2016, 6, 1),
DataChiusura = new DateTime(2017, 5, 31)
};
_banca01 = new DatiBancariCondomini("12345", "12345", "123456789012", "A", _condominio) {Iban = "IT02L1234512345123456789012" };
_banca02 = new DatiBancariCondomini("03268", "10001", "100000000000", "A", _condominio) { Iban = "IT11X03268100001100000000000" };
_stabile01 = new Palazzina(_condominio, "Stabile 01") {ID=1};
_stabile01.GruppiStabile.Clear();
_condominio.Palazzine.Add(_stabile01);
var comune = new Comune("A944", "Bologna", new Provincia("BO", new Regione("Emilia Romagna")));
_gruppoStabile01 = new GruppoStabile(_stabile01, "Scala 01") { ID = 1, Ordine = 1, Note = "Note per Scala01", Indirizzo = new Address { Cap = "40131", Civico = "SCA/1", Indirizzo = "Via Scala01", Localita = "Scaletta01", Comune = comune } };
_gruppoStabile02 = new GruppoStabile(_stabile01, "Scala 02") { ID = 2, Ordine = 2, Note = "Note per Scala02", Indirizzo = new Address { Cap = "40132", Civico = "SCA/2", Indirizzo = "Via Scala02", Localita = "Scaletta02", Comune = comune } };
_condominio.Indirizzo = new Address
{
Indirizzo = "via dei Fiori",
Cap = "40100",
Civico = "23",
Localita = "Pioppa",
Comune = comune
};
var listaTipoUnitaImmobiliare = new List<TipoUnitaImmobiliare>
{
new TipoUnitaImmobiliare("Tipo01") {ID = 1},
new TipoUnitaImmobiliare("Tipo02") {ID = 2}
};
var fornitore = new Fornitore(new Persona(TipoPersonaEnum.Giuridica, "Franco", "Livoresi", _azienda.ID, true) {PartitaIva = "01867511204"}, _azienda.ID) {ID =1};
var fornitore01 = new Fornitore(new Persona(TipoPersonaEnum.Giuridica, "Luigi", "Majorana", _azienda.ID, true) { PartitaIva = "01230460394" }, _azienda.ID) {ID = 2};
var agenziaAssicurativa = new AgenziaAssicurativa(new Persona(TipoPersonaEnum.Giuridica, "", "Agenzia Bologna", _azienda.ID, true) { PartitaIva = "03211600402" }, fornitore01, "Agenzia BO", _azienda.ID) {ID = 3};
var tipoContratto = new TipoContratto("Pulizia Scale") {ID=1};
var tipoContrattoAssicurativo = new TipoContratto("Assicurazione") {ID=2};
_unitaImmobiliare01 = new UnitaImmobiliare(_gruppoStabile01, listaTipoUnitaImmobiliare[0]) { ID = 1, Descrizione = "Unità 01", Ordine = 1};
_unitaImmobiliare02 = new UnitaImmobiliare(_gruppoStabile01, new TipoUnitaImmobiliare("Tipo02")) { ID = 2, Descrizione = "Unità 02", Ordine = 2 };
_unitaImmobiliare03 = new UnitaImmobiliare(_gruppoStabile02, listaTipoUnitaImmobiliare[1]) { ID = 3, Descrizione = "Unità 03", Ordine = null };
_unitaImmobiliare04 = new UnitaImmobiliare(_gruppoStabile02, new TipoUnitaImmobiliare("Tipo NEW")) { ID = 4, Descrizione = "Unità 04", Ordine = 4 };
_unitaImmobiliare01.CondizioniSicurezzaImpianto = new SicurezzaImpianto
{
Norma = true,
Note = "Note01"
};
_unitaImmobiliareImpiantistica01 = new UnitaImmobiliareImpiantistica(_unitaImmobiliare01, "TipoImpianto01", true) { ID = 1, Descrizione = "Impianto 01"};
_unitaImmobiliareImpiantistica02 = new UnitaImmobiliareImpiantistica(_unitaImmobiliare01, "TipoImpianto02", false) {ID = 2, Descrizione = "Impianto 02"};
_persona01 = new Persona(TipoPersonaEnum.Fisica, "Mario", "Rossi", _azienda.ID, false)
{
ID = 1,
ComuneNascita = comune,
IndirizzoResidenza =
new Address
{
Indirizzo = "via residenza01",
Cap = "40101",
Civico = "1",
Comune = comune,
Localita = "Pioppa 01"
},
Domicilio =
new Address
{
Indirizzo = "via domicilio01",
Cap = "40101",
Civico = "1",
Comune = comune,
Localita = "Pioppa 01"
},
Recapito =
new Address
{
Indirizzo = "via recapito01",
Cap = "40101",
Civico = "1",
Comune = comune,
Localita = "Pioppa 01"
}
};
_proprietario01 = new Proprietario(_unitaImmobiliare01, _persona01) {ID = 1, Descrizione = "Mario Rossi", VersamentoMav = true, Consigliere = true, Principale = true};
_persona02 = new Persona(TipoPersonaEnum.Giuridica, "Giulio", "Verdi", _azienda.ID, false)
{
ID = 2,
ComuneNascita = comune,
IndirizzoResidenza =
new Address
{
Indirizzo = "via residenza02",
Cap = "40102",
Civico = "2",
Comune = comune,
Localita = "Pioppa 02"
},
Domicilio =
new Address
{
Indirizzo = "via domicilio02",
Cap = "40102",
Civico = "2",
Comune = comune,
Localita = "Pioppa 02"
},
Recapito =
new Address
{
Indirizzo = "via recapito02",
Cap = "40102",
Civico = "2",
Comune = comune,
Localita = "Pioppa 02"
}
};
_proprietario02 = new Proprietario(_unitaImmobiliare02, _persona02) {ID = 2, Descrizione = "Giulio Verdi", DataInizio = new DateTime(2015, 1, 1)};
_persona03 = new Persona(TipoPersonaEnum.Fisica, "Franco", "Bianchi", _azienda.ID, false)
{
ID = 3,
IndirizzoResidenza =
new Address
{
Indirizzo = "via residenza03",
Cap = "40103",
Civico = "3",
Comune = comune,
Localita = "Pioppa 03"
},
Domicilio =
new Address
{
Indirizzo = "via domicilio03",
Cap = "40103",
Civico = "3",
Comune = comune,
Localita = "Pioppa 03"
}
};
_persona01.Recapito = new Address { Indirizzo = "via recapito03", Cap = "40103", Civico = "3", Comune = comune, Localita = "Pioppa 03" };
_proprietario03 = new Proprietario(_unitaImmobiliare03, _persona03) {ID = 3, Descrizione = "Franco Bianchi"};
_proprietario04 = new Proprietario(_unitaImmobiliare04, _persona01)
{
ID = 4,
SoggettoPrincipale = _proprietario01
};
_persona04 = new Persona(TipoPersonaEnum.Fisica, "Primo", "Conduttore", _azienda.ID, false)
{
ID = 4,
IndirizzoResidenza =
new Address
{
Indirizzo = "via residenza04",
Cap = "40104",
Civico = "4",
Comune = comune,
Localita = "Pioppa 04"
},
Domicilio =
new Address
{
Indirizzo = "via domicilio04",
Cap = "40104",
Civico = "4",
Comune = comune,
Localita = "Pioppa 04"
},
Recapito =
new Address
{
Indirizzo = "via recapito04",
Cap = "40104",
Civico = "4",
Comune = comune,
Localita = "Pioppa 04"
}
};
_conduttore01 = new Conduttore(_unitaImmobiliare01, _persona04) {ID = 5, Descrizione = "Primo Conduttore"};
_persona05 = new Persona(TipoPersonaEnum.Fisica, "Secondo", "Conduttore", _azienda.ID, false)
{
ID = 5,
IndirizzoResidenza =
new Address
{
Indirizzo = "via residenza05",
Cap = "40105",
Civico = "5",
Comune = comune,
Localita = "Pioppa 05"
},
Domicilio =
new Address
{
Indirizzo = "via domicilio05",
Cap = "40105",
Civico = "5",
Comune = comune,
Localita = "Pioppa 05"
},
Recapito =
new Address
{
Indirizzo = "via recapito05",
Cap = "40105",
Civico = "5",
Comune = comune,
Localita = "Pioppa 05"
}
};
_conduttore02 = new Conduttore(_unitaImmobiliare02, _persona05) {ID = 6, Descrizione = "Secondo Conduttore"};
_contatto01 = new Email("*****@*****.**", true, _persona01) { ID = 1, Descrizione = "mail principale persona 01"};
_contatto02 = new Email("*****@*****.**", false, _persona01) { ID = 2, Descrizione = "mail secondaria persona 01" };
_contatto03 = new Cellulare("1234567890", true, _persona01) { ID = 3, Descrizione = "cellulare principale persona 01" };
_contatto04 = new Fax("9876543210", false, _persona02) { ID = 4, Descrizione = "fax persona 02" };
_contatto05 = new Telefono("1357924680", true, _persona03) { ID = 5, Descrizione = "telefono persona 03" };
_contatto06 = new EmailCertificata("*****@*****.**", true, _persona01) { ID = 6, Descrizione = "mail certificata persona 01" };
_contatto07 = new SitoInternet("www.bianchi.it", false, _persona03) { ID = 7, Descrizione = "sito internet persona03" };
_contatto08 = new Telefono("3333333333", false, _persona04) { ID = 8, Descrizione = "telefono persona 04" };
_contatto09 = new Cellulare("9999999999", true, _persona05) { ID = 9, Descrizione = "cellulare persona 05" };
_contatto10 = new Email("*****@*****.**", false, _persona05) { ID=10 };
_condominio.PersoneDaNonSollecitare.Add(new PersonaDaNonSollecitare(_persona01, _condominio) { Motivo = "persona01 non paga" });
_condominio.PersoneDaNonSollecitare.Add(new PersonaDaNonSollecitare(_persona03, _condominio) { Motivo = "persona02 è simpatica" });
// Contratto Appalto
_documentocontrattoAppalto01 = new Documento(201, "Appalto", true, _azienda) { ID = 1, CondominioRiferimento = _condominio, Checksum = "CHK001", FileName = "appalto01", FileExtension = "pdf", Descrizione = "Appalto001" };
_documentocontrattoAppalto02 = new Documento(202, "Appalto", true, _azienda) { ID = 2, CondominioRiferimento = _condominio, Checksum = "CHK002", FileName = "appalto02", FileExtension = "pdf", Descrizione = "Appalto002" };
_contrattoAppalto = new ContrattoAppalto(tipoContratto, _condominio, fornitore)
{
ID = 1,
NumeroContratto = "CONTRA001",
Scadenza = new DateTime(2016, 12, 31),
Descrizione = "Contratto di Appalto di prova",
Note = "Nota per contratto appalto",
Documenti = { _documentocontrattoAppalto01, _documentocontrattoAppalto02 }
};
_documentocontrattoAppalto01.ContrattoRiferimento = _contrattoAppalto;
_documentocontrattoAppalto02.ContrattoRiferimento = _contrattoAppalto;
// Contratto Assicurativo
_documentocontrattoAssicurativo01 = new Documento(203, "Assicurativo01", true, _azienda) { ID = 3, CondominioRiferimento = _condominio, Checksum = "CHK003", FileName = "assicurazione01", FileExtension = "pdf", Descrizione = "Assicurazione001" };
_documentocontrattoAssicurativo02 = new Documento(204, "Assicurativo02", true, _azienda) { ID = 4, CondominioRiferimento = _condominio, Checksum = "CHK004", FileName = "assicurazione02", FileExtension = "pdf", Descrizione = "Assicurazione002" };
_contrattoAssicurativo = new AssicurazioneContratto(new DateTime(2016, 11, 30), new DateTime(2016, 07, 15), tipoContrattoAssicurativo)
{
ID = 2,
FornitoreAttuale = agenziaAssicurativa,
NumeroContratto = "CONTR_ASS_001",
Scadenza = new DateTime(2016, 12, 31),
Descrizione = "Contratto Assicurativo di prova",
Note = "Nota per contratto assicurativo",
Documenti = { _documentocontrattoAssicurativo01, _documentocontrattoAssicurativo02 }
};
_contrattoAssicurativoGlobale = new GlobaleAssicurazione(new DateTime(2016, 11, 30),
new DateTime(2016, 07, 15), tipoContrattoAssicurativo)
{
ID = 3,
FornitoreAttuale = agenziaAssicurativa,
NumeroContratto = "CONTR_GLOB_001",
Scadenza = new DateTime(2016, 12, 31),
ImportoLimiteCoseRCT = 50000,
ImportoMassimaleSinistroRCT = 60000,
ImportoUnicoRCT = 70000,
ImportoPremio = 80000,
Descrizione = "Contratto Globale di prova",
Note = "Nota per contratto globale",
FranchigiaDanniAcqua = 90000,
FranchigiaRicercaGuasto = 100000,
ValoreRicostruzioneNuovo = 110000,
DanniAcqua = true,
RicercaGuasto = true
};
_contrattoAssicurativoIncendio = new IncendioAssicurazione(new DateTime(2016, 11, 30), new DateTime(2016, 07, 15), tipoContrattoAssicurativo)
{
ID = 4,
FornitoreAttuale = agenziaAssicurativa,
NumeroContratto = "CONTR_INC_001",
ImportoLimiteCoseRCT = 150000,
ImportoMassimaleSinistroRCT = 160000,
ImportoUnicoRCT = 170000,
ImportoPremio = 180000,
FranchigiaDanniAcqua = 120000,
FranchigiaRicercaGuasto = 130000,
ValoreRicostruzioneNuovo = 140000,
DanniAcqua = true,
RicercaGuasto = false,
Scadenza = new DateTime(2016, 12, 31),
Descrizione = "Contratto Incendio di prova",
Note = "Nota per contratto incendio"
};
_contrattoAssicurativoFurto = new FurtoAssicurazione(new DateTime(2016, 11, 30), new DateTime(2016, 07, 15), tipoContrattoAssicurativo)
{
ID = 5,
FornitoreAttuale = agenziaAssicurativa,
NumeroContratto = "CONTR_FURTO_001",
Scadenza = new DateTime(2016, 12, 31),
Descrizione = "Contratto Furto di prova",
Note = "Nota per contratto furto"
};
_contrattoAssicurativoInfortuni = new InfortuniAssicurazione(new DateTime(2016, 11, 30), new DateTime(2016, 07, 15), tipoContrattoAssicurativo)
{
ID = 6,
FornitoreAttuale = agenziaAssicurativa,
NumeroContratto = "CONTR_INFORTUNI_001",
Scadenza = new DateTime(2016, 12, 31),
Descrizione = "Contratto Infortuni di prova",
Note = "Nota per contratto infortuni"
};
_contrattoAssicurativoResponsabilitaCivile = new ResponsabilitaCivileAssicurazione(new DateTime(2016, 11, 30), new DateTime(2016, 07, 15), tipoContrattoAssicurativo)
{
ID = 7,
FornitoreAttuale = agenziaAssicurativa,
NumeroContratto = "CONTR_RESPCIV_001",
Scadenza = new DateTime(2016, 12, 31),
Descrizione = "Contratto Responsabilità civile di prova",
Note = "Nota per contratto responsabilità civile"
};
_condominio.ContrattiAssicurativi.Add(_contrattoAssicurativo);
_condominio.ContrattiAssicurativi.Add(_contrattoAssicurativoGlobale);
_condominio.ContrattiAssicurativi.Add(_contrattoAssicurativoIncendio);
_condominio.ContrattiAssicurativi.Add(_contrattoAssicurativoFurto);
_condominio.ContrattiAssicurativi.Add(_contrattoAssicurativoInfortuni);
_condominio.ContrattiAssicurativi.Add(_contrattoAssicurativoResponsabilitaCivile);
_contrattoAssicurativo.CondominioRiferimento = _condominio;
_contrattoAssicurativoGlobale.CondominioRiferimento = _condominio;
_contrattoAssicurativoIncendio.CondominioRiferimento = _condominio;
_contrattoAssicurativoFurto.CondominioRiferimento = _condominio;
_contrattoAssicurativoInfortuni.CondominioRiferimento = _condominio;
_contrattoAssicurativoResponsabilitaCivile.CondominioRiferimento = _condominio;
_documentocontrattoAssicurativo01.ContrattoRiferimento = _contrattoAssicurativo;
_documentocontrattoAssicurativo02.ContrattoRiferimento = _contrattoAssicurativo;
// Conti / Millesimi
_conto01 = new Conto(_condominio, TipoContoEconomicoEnum.Economico, TipoPeriodoCompetenzaContabile.Esercizio, "SPESE GENERALI PROPRIETA'", true, true, false) {DescrizioneBilancio = "SPE GEN", Codice = "001", ID = 1};
_conto02 = new Conto(_condominio, TipoContoEconomicoEnum.Economico, TipoPeriodoCompetenzaContabile.Riscaldamento, "SPESE RISCALDAMENTO", true, true, false) { DescrizioneBilancio = "SPE RIS", Codice = "002", ID = 2 };
_sottoconto01 = new SottoConto(_conto01, "SPESE SCALA 01") { Codice = "001.001", ID = 1 };
_sottoconto02 = new SottoConto(_conto01, "SPESE SCALA 02") { Codice = "001.002", ID = 2 };
_sottoconto03 = new SottoConto(_conto02, "SPESE ABITAZIONI") { Codice = "002.001", ID = 3 };
_sottoconto04 = new SottoConto(_conto02, "SPESE GARAGE") { Codice = "002.002", ID = 4 };
_millesimo01 = new Millesimo(_conto01, _unitaImmobiliare01) { ID = 1, Valore = 100 };
_millesimo02 = new Millesimo(_conto01, _unitaImmobiliare02) { ID = 2, Valore = 200 };
_millesimo03 = new Millesimo(_conto02, _unitaImmobiliare01) { ID = 3, Valore = 300 };
_millesimo04 = new Millesimo(_conto02, _unitaImmobiliare02) { ID = 4, Valore = 400 };
_fascicoloImmobiliare = new FascicoloImmobiliare("Prova Fascicolo", "PRO", "01") {ID=1};
_fascicoloCondominio = new FascicoloCondominio(_fascicoloImmobiliare, _condominio) { ID =1, Necessario = true, Presente = false };
_fascicoloCondominio.Documenti.Add(_documentocontrattoAppalto01);
_fascicoloCondominio.Documenti.Add(_documentocontrattoAssicurativo02);
_documentocontrattoAppalto01.Fascicoli.Add(_fascicoloCondominio);
_documentocontrattoAssicurativo02.Fascicoli.Add(_fascicoloCondominio);
// Stub per IDaoFactory
_daoFactory = MockRepository.GenerateStub<IDaoFactory>();
// Stub per azienda
var aziendaDao = MockRepository.GenerateStub<IAziendaDao>();
aziendaDao.Stub(x => x.Find(2, false)).Return(_aziendaDestinazione);
_daoFactory.Stub(x => x.GetAziendaDao()).Return(aziendaDao);
// Stub per tipo unità immobiliare
var tipoUnitaImmobiliareDao = MockRepository.GenerateStub<ITipoUnitaImmobiliareDao>();
tipoUnitaImmobiliareDao.Stub(x => x.GetByAzienda(Arg<int>.Is.Anything)).Return(listaTipoUnitaImmobiliare);
_daoFactory.Stub(x => x.GetTipoUnitaImmobiliareDao()).Return(tipoUnitaImmobiliareDao);
// Stub per fornitore
var fornitoreDao = MockRepository.GenerateStub<IFornitoreDao>();
fornitoreDao.Stub(x => x.Find(1, false)).Return(fornitore);
fornitoreDao.Stub(x => x.Find(2, false)).Return(fornitore01);
fornitoreDao.Stub(x => x.GetByPartitaIva("01867511204", _aziendaDestinazione.ID)).Return(fornitore);
fornitoreDao.Stub(x => x.GetByPartitaIva("01230460394", _aziendaDestinazione.ID)).Return(fornitore01);
fornitoreDao.Stub(x => x.GetByPartitaIva("03211600402", _aziendaDestinazione.ID)).Return(agenziaAssicurativa);
_daoFactory.Stub(x => x.GetFornitoreDao()).Return(fornitoreDao);
// Stub per tipo contratto
var tipoContrattoDao = MockRepository.GenerateStub<ITipoContrattoDao>();
tipoContrattoDao.Stub(x => x.GetByDescrizione("Pulizia Scale", _aziendaDestinazione.ID)).Return(tipoContratto);
tipoContrattoDao.Stub(x => x.GetByDescrizione("Assicurazione", _aziendaDestinazione.ID)).Return(tipoContrattoAssicurativo);
_daoFactory.Stub(x => x.GetTipoContrattoDao()).Return(tipoContrattoDao);
// Stub per Comune
var comuneDao = MockRepository.GenerateStub<IComuneDao>();
comuneDao.Stub(x => x.Find(comune.Codice, false)).Return(comune);
comuneDao.Stub(x => x.Find(null, false)).Throw(new NullReferenceException("Id non può essere null"));
_daoFactory.Stub(x => x.GetComuneDao()).Return(comuneDao);
// Stub per fascicolo immobiliare
_fascicoloImmobiliareDao = MockRepository.GenerateStub<IFascicoloImmobiliareDao>();
_fascicoloImmobiliareDao.Stub(x => x.GetByAzienda(_aziendaDestinazione.ID)).Return(new List<FascicoloImmobiliare> { _fascicoloImmobiliare });
_daoFactory.Stub(x => x.GetFascicoloImmobiliareDao()).Return(_fascicoloImmobiliareDao);
_documentService = MockRepository.GenerateStub<IDocumentService>();
_exportCsvCondominiService = new ExportCsvCondominiService();
_importCsvCondominiService = new ImportCsvCondominiService(_daoFactory, _documentService);
}
public decimal GetImportoCompetenza(decimal importo, Conto conto, SottoConto sottoconto, TipoSoggetto tipoSoggetto)
{
decimal importoCompetenza;
var percentualeProprieta = conto.PercentualeProprieta;
if (sottoconto?.PercentualeProprieta != null)
percentualeProprieta = sottoconto.PercentualeProprieta.Value;
var importoCompetenzaProprietario = importo * percentualeProprieta;
if (tipoSoggetto == TipoSoggetto.Proprietario)
importoCompetenza = importoCompetenzaProprietario;
else
importoCompetenza = importo - importoCompetenzaProprietario;
return importoCompetenza;
}
private string getKeyContoSottoconto(Conto conto, SottoConto sottoConto)
{
var key = conto.ID.ToString();
if (sottoConto != null)
key += "|" + sottoConto.ID;
else
key += "|0";
return key;
}
private string loadCondominio(string codiceCondominio, Azienda azienda, OleDbConnection conn)
{
string message = string.Empty;
// ===========================================================================================================
// Lettura Tabelle
// ===========================================================================================================
// ----------------------------------------------------------------------------------
// Condomini
// ----------------------------------------------------------------------------------
var condominioAdapter = new OleDbDataAdapter("SELECT * FROM TabCondomìni WHERE TabCondomìni.Codice = '" + codiceCondominio + "'", conn);
var dsCondomini = new DataSet("Condomini");
condominioAdapter.Fill(dsCondomini, "TabCondomìni");
if (dsCondomini.Tables["TabCondomìni"].Rows.Count > 0)
{
var rowCondominio = dsCondomini.Tables["TabCondomìni"].Rows[0];
var esercizioAdapter = new OleDbDataAdapter("SELECT * FROM TabEsercizi WHERE idCondominio = " + rowCondominio["id"] + " AND TabEsercizi.Attivo = True AND TabEsercizi.Straordinario = False AND (TabEsercizi.Nome LIKE 'ORDINARIO%' OR TabEsercizi.Nome LIKE '0RDINARIO%') ORDER BY DataF DESC", conn);
esercizioAdapter.Fill(dsCondomini, "TabEsercizi");
if (dsCondomini.Tables["TabEsercizi"].Rows.Count > 0)
{
var rowEsercizio = dsCondomini.Tables["TabEsercizi"].Rows[0];
var dataInizioEsercizio = (DateTime)rowEsercizio["DataI"];
var dataFineEsercizio = (DateTime)rowEsercizio["DataF"];
Condominio condominio = _daoFactory.GetCondominioDao().GetByCodice(codiceCondominio.PadLeft(3, '0'), azienda.ID);
if (condominio == null)
{
condominio = new Condominio(rowCondominio["Nome"].ToString(), dataFineEsercizio.Day, dataFineEsercizio.Month, dataFineEsercizio.Year + 1, azienda) {Codice = codiceCondominio.PadLeft(3, '0')};
_daoFactory.GetCondominioDao().SaveOrUpdate(condominio);
addDefault(condominio);
}
else
{
// ======================================================================================
// Eliminazione vecchi dati
// ======================================================================================
foreach (UnitaImmobiliare unita in _daoFactory.GetUnitaImmobiliareDao().GetByCondominio(condominio.ID))
{
foreach (Millesimo mill in unita.Millesimi)
{
mill.UnitaRiferimento = null;
mill.ContoRiferimento = null;
}
unita.Millesimi.Clear();
unita.GruppoStabileRiferimento.UnitaImmobiliari.Remove(unita);
_daoFactory.GetUnitaImmobiliareDao().Delete(unita);
}
foreach (Palazzina stabileDelete in condominio.Palazzine)
{
foreach (GruppoStabile gruppo in stabileDelete.GruppiStabile)
gruppo.PalazzinaRiferimento = null;
stabileDelete.CondominioRiferimento = null;
}
condominio.Palazzine.Clear();
var stabileFirst = new Palazzina(condominio, "Stabile A");
_daoFactory.GetPalazzinaDao().SaveOrUpdate(stabileFirst);
// Dati Bancari
foreach (DatiBancariCondomini banca in condominio.DatiBancari)
{
foreach (MovimentoBancario mov in banca.MovimentiBancari)
{
mov.Condominio = null;
mov.Banca = null;
mov.Fornitore = null;
mov.Esercizio = null;
mov.File = null;
}
banca.CondominioRiferimento = null;
}
condominio.DatiBancari.Clear();
// Piano Conti
foreach (Conto contoDelete in condominio.Conti)
{
contoDelete.CondominioRiferimento = null;
contoDelete.Millesimi.Clear();
}
condominio.Conti.Clear();
// Modelli Ripartizione
foreach (ModelloRegistrazioneContabile modello in condominio.ModelliRegistrazioneContabile)
modello.CondominioRiferimento = null;
condominio.ModelliRegistrazioneContabile.Clear();
// Esercizi
foreach (Esercizio esercizioDelete in condominio.Esercizi)
{
esercizioDelete.AnnoGestionale.Esercizi.Remove(esercizioDelete);
_daoFactory.GetEsercizioDao().Delete(esercizioDelete);
}
condominio.Esercizi.Clear();
// Anno Gestionale
foreach (AnnoGestionale anno in condominio.AnniGestionali)
_daoFactory.GetAnnoGestionaleDao().Delete(anno);
condominio.AnniGestionali.Clear();
// ======================================================================================
condominio.Descrizione = rowCondominio["Nome"].ToString();
// ======================================================================================
// Default del condominio
// ======================================================================================
// Conti comuni del Piano dei conti
IList<PianoConti> conti = _daoFactory.GetPianoContiDao().GetByAzienda(azienda.ID);
foreach (PianoConti pianoConto in conti)
{
if(pianoConto.IsRequired)
pianoConto.ConvertToConto(condominio);
}
// Nuovo esercizio
DateTime inizioEsercizioOld = dataInizioEsercizio;
DateTime fineEsercizioOld = dataFineEsercizio;
var annoNew = new AnnoGestionale(condominio, inizioEsercizioOld.AddYears(1).Year, fineEsercizioOld.AddYears(1).Year);
_daoFactory.GetAnnoGestionaleDao().SaveOrUpdate(annoNew);
var esercizioNew = new Esercizio(condominio, inizioEsercizioOld.AddYears(1), fineEsercizioOld.AddYears(1), annoNew, Sfera.Enums.GestioneEsercizioEnum.Ordinario);
_daoFactory.GetEsercizioDao().SaveOrUpdate(esercizioNew);
}
condominio.CodiceImportazione = rowCondominio["id"].ToString().Trim();
if (rowCondominio["Note"] != DBNull.Value && !string.IsNullOrEmpty(rowCondominio["Note"].ToString()))
condominio.Note = rowCondominio["Note"].ToString();
if (rowCondominio["CF"] != DBNull.Value && !string.IsNullOrEmpty(rowCondominio["CF"].ToString()))
condominio.CodiceFiscale = rowCondominio["CF"].ToString().Trim();
// ----------------------------
// Banche
// ----------------------------
var bancheCondominiAdapter = new OleDbDataAdapter("SELECT * FROM TabBanche INNER JOIN TabBanche_Condomìni ON TabBanche.id = TabBanche_Condomìni.idBanca WHERE TabBanche_Condomìni.idCondominio = " + rowCondominio["id"], conn);
bancheCondominiAdapter.Fill(dsCondomini, "Banche");
foreach (DataRow rowBanca in dsCondomini.Tables["Banche"].Rows)
{
try
{
if (rowBanca["TabBanche_Condomìni.Attivo"] != DBNull.Value && (bool)rowBanca["TabBanche_Condomìni.Attivo"])
{
DatiBancariCondomini datiBancari = null;
if (rowBanca["CodSiaOrdinante"] != DBNull.Value && !string.IsNullOrEmpty(rowBanca["CodSiaOrdinante"].ToString()))
condominio.CodiceSIA = rowBanca["CodSiaOrdinante"].ToString().Trim();
if (rowBanca["IBAN"] != DBNull.Value && !string.IsNullOrEmpty(rowBanca["IBAN"].ToString()))
{
datiBancari = new DatiBancariCondomini(rowBanca["IBAN"].ToString().Trim().Replace(" ", ""), condominio);
condominio.DatiBancari.Add(datiBancari);
_daoFactory.GetDatiBancariCondominiDao().SaveOrUpdate(datiBancari);
}
else if (rowBanca["Abi"] != DBNull.Value && !string.IsNullOrEmpty(rowBanca["Abi"].ToString()) && rowBanca["Cab"] != DBNull.Value && !string.IsNullOrEmpty(rowBanca["Cab"].ToString()) && rowBanca["CC"] != DBNull.Value && !string.IsNullOrEmpty(rowBanca["CC"].ToString()))
{
var coor = new CoordinateBancarie
{
Abi = rowBanca["Abi"].ToString().Trim().PadLeft(5, '0'),
Cab = rowBanca["Cab"].ToString().Trim().PadLeft(5, '0'),
ContoCorrente = rowBanca["CC"].ToString().Trim().PadLeft(12, '0')
};
datiBancari = new DatiBancariCondomini(coor.CalcolaIBAN(), condominio);
condominio.DatiBancari.Add(datiBancari);
_daoFactory.GetDatiBancariCondominiDao().SaveOrUpdate(datiBancari);
}
if (datiBancari != null && rowBanca["Predefinito"] != DBNull.Value)
{
datiBancari.Principale = (bool)rowBanca["Predefinito"];
datiBancari.CodiceImportazione = rowBanca["TabBanche_Condomìni.id"].ToString().Trim();
}
if (datiBancari != null)
datiBancari.Note = rowBanca["NomeCC"].ToString().Trim();
}
}
catch (Exception ex)
{
_log.Error("Errore inaspettato nell'importazione di un condominio da GeCo: " + Library.Utility.GetMethodDescription() + " (Banche) - banca:" + rowBanca["id"], ex);
throw;
}
}
// Se ho una sola coordinata bancaria questa è la principale
if (condominio.DatiBancari.Count == 1)
Library.IesiGenericCollections<DatiBancariCondomini>.GetByIndex(condominio.DatiBancari, 0).Principale = true;
// ----------------------------
// Stabili/Scale
// ----------------------------
var stabiliScaleAdapter = new OleDbDataAdapter("SELECT DISTINCT TabIndirizzi.*, TabEdifici.*, TabIndirizzi_Condomìni.idCondominio, TabCodComune.Nome " +
"FROM TabEdifici INNER JOIN " +
"((TabCodComune INNER JOIN " +
"(TabIndirizzi INNER JOIN " +
"TabIndirizzi_Condomìni ON TabIndirizzi.id = TabIndirizzi_Condomìni.idIndirizzo) ON TabCodComune.id = TabIndirizzi.idComune) INNER JOIN TabLocali ON TabIndirizzi_Condomìni.id = TabLocali.idIndirizzoCondominio) ON TabEdifici.id = TabLocali.idEdificio " +
"WHERE TabIndirizzi_Condomìni.idCondominio = " + rowCondominio["id"] + " " +
"ORDER BY TabIndirizzi_Condomìni.idCondominio, TabIndirizzi.id", conn);
stabiliScaleAdapter.Fill(dsCondomini, "StabiliScale");
int numeroUnitaImmobiliari = 0;
bool first = true;
var stabile = Library.IesiGenericCollections<Palazzina>.GetByIndex(condominio.Palazzine, 0);
var descrizioneStabile = string.Empty;
Address indirizzoStabile = null;
IList<NameValueDTO<int, string>> listaPersone = _daoFactory.GetPersonaDao().GetByQueryDTO<NameValueDTO<int, string>>("SELECT new NameValueDTOIntString(PERS.ID, PERS.CodiceImportazione) FROM Persona PERS WHERE PERS.AziendaID = :azienda", new[] { new QueryParam("azienda", azienda.ID) });
foreach (DataRow rowStabile in dsCondomini.Tables["StabiliScale"].Rows)
{
try
{
GruppoStabile newScala;
if (first)
{
newScala = Library.IesiGenericCollections<GruppoStabile>.GetByIndex(stabile.GruppiStabile, 0);
newScala.Descrizione = rowStabile["TabEdifici.Nome"].ToString();
}
else
{
newScala = new GruppoStabile(stabile, rowStabile["TabEdifici.Nome"].ToString());
_daoFactory.GetGruppoStabileDao().SaveOrUpdate(newScala);
}
newScala.Descrizione = rowStabile["TabEdifici.Nome"].ToString();
newScala.Indirizzo = getIndirizzo(rowStabile);
newScala.CodiceImportazione = rowStabile["TabEdifici.id"].ToString().Trim();
newScala.Note = rowStabile["TabEdifici.Note"].ToString().Trim() + Environment.NewLine + rowStabile["TabIndirizzi.Note"].ToString().Trim();
descrizioneStabile += rowStabile["TabIndirizzi.Nome"].ToString().Trim() + " ";
if (indirizzoStabile == null)
indirizzoStabile = (Address)newScala.Indirizzo.Clone();
// Unità Immobiliari
message += loadUnitaImmobiliari((int)rowEsercizio["id"], newScala, (int)rowStabile["TabEdifici.id"], dataInizioEsercizio, listaPersone, conn);
numeroUnitaImmobiliari += newScala.UnitaImmobiliari.Count;
first = false;
}
catch (Exception ex)
{
_log.Error("Errore inaspettato nell'importazione di un condominio da GeCo: " + Library.Utility.GetMethodDescription() + " (Scale) - indirizzo:" + rowStabile["TabIndirizzi.id"], ex);
throw;
}
}
stabile.Descrizione = descrizioneStabile.Trim();
stabile.Indirizzo = indirizzoStabile;
if (stabile.Indirizzo != null) condominio.Indirizzo =
(Address)stabile.Indirizzo.Clone();
condominio.NumeroUnitaImmobiliari = numeroUnitaImmobiliari;
// ===================================
// Piano dei conti
// ===================================
var pianoContiAdapter = new OleDbDataAdapter("SELECT TabCapitoli.*, TabEsercizi.idCondominio " +
"FROM TabEsercizi INNER JOIN TabCapitoli ON TabEsercizi.id = TabCapitoli.idEsercizio " +
"WHERE TabEsercizi.Attivo = true AND TabEsercizi.Straordinario = false AND TabEsercizi.id = " + rowEsercizio["id"] + " " +
"ORDER BY TabCapitoli.Codice", conn);
pianoContiAdapter.Fill(dsCondomini, "PianoConti");
var loadedConti = new List<Conto>();
DataTable tbPianoConti = dsCondomini.Tables["PianoConti"];
int ordineConto = 0;
foreach (DataRow row in tbPianoConti.Rows)
{
try
{
var conto = new Conto(condominio, Sfera.Enums.TipoContoEconomicoEnum.Economico, Sfera.Enums.TipoPeriodoCompetenzaContabile.Esercizio, row["Nome"].ToString(), true, true, false);
_daoFactory.GetContoDao().SaveOrUpdate(conto);
string codice = row["Codice"].ToString().Trim();
if (!string.IsNullOrEmpty(codice))
{
conto.Codice = codice.Length > 2 ? codice.Substring(0, 2).PadLeft(3, '0') : codice.PadLeft(3, '0');
}
conto.PresenteBilancio = true;
conto.CodiceImportazione = row["id"].ToString();
ordineConto++;
conto.Ordine = ordineConto;
loadedConti.Add(conto);
dsCondomini = new DataSet();
var sottoContiAdapter = new OleDbDataAdapter("SELECT * FROM TabSottoCapitoli WHERE TabSottoCapitoli.idCapitolo = " + row["id"], conn);
sottoContiAdapter.Fill(dsCondomini, "SottoConti");
var ordineSottoConto = 0;
foreach (DataRow rowSottoConto in dsCondomini.Tables["SottoConti"].Rows)
{
try
{
var sottoConto = new SottoConto(conto, rowSottoConto["Nome"].ToString()) {CodiceImportazione = rowSottoConto["id"].ToString()};
ordineSottoConto++;
sottoConto.Codice = conto.Codice + "." + ordineSottoConto.ToString().PadLeft(3, '0');
_daoFactory.GetSottoContoDao().SaveOrUpdate(sottoConto);
}
catch (Exception ex)
{
_log.Error("Errore inaspettato nell'importazione di un condominio da GeCo: " + Library.Utility.GetMethodDescription() + " (Sotto Conti) - sottoconto:" + rowSottoConto["id"], ex);
throw;
}
}
}
catch (Exception ex)
{
_log.Error("Errore inaspettato nell'importazione di un condominio da GeCo: " + Library.Utility.GetMethodDescription() + " (Piano dei conti) - conto:" + row["id"], ex);
throw;
}
}
// ===================================
// Millesimi
// ===================================
try
{
var unitaCondominio = _daoFactory.GetUnitaImmobiliareDao().GetByCondominio(condominio.ID);
foreach (Conto conto in loadedConti)
{
try
{
dsCondomini = new DataSet();
var millesimiAdapter = new OleDbDataAdapter("SELECT * " +
"FROM (TabMillesimi INNER JOIN TabMillesimiLocali ON TabMillesimi.id = TabMillesimiLocali.idTabMillesimi) INNER JOIN TabCapitoli ON TabMillesimi.id = TabCapitoli.idTabMillesimi " +
"WHERE TabMillesimi.idEsercizio = " + rowEsercizio["id"].ToString().Trim() + " AND TabCapitoli.id = " + conto.CodiceImportazione.Trim() + ";", conn);
millesimiAdapter.Fill(dsCondomini, "Millesimi");
foreach (DataRow rowMillesimo in dsCondomini.Tables["Millesimi"].Rows)
{
try
{
if ((float)rowMillesimo["PercProp"] > 0)
{
//string hql = "FROM UnitaImmobiliare UNI WHERE UNI.CodiceImportazione = :codice";
//IList<UnitaImmobiliare> listaUnita = _daoFactory.GetUnitaImmobiliareDao().GetByQuery(hql, new QueryParam[] { new QueryParam("codice", rowMillesimo["idLocale"].ToString().Trim()) });
IList<UnitaImmobiliare> listaUnita = (from item in unitaCondominio
where item.CodiceImportazione == rowMillesimo["idLocale"].ToString().Trim()
select item).ToList();
if (listaUnita.Count > 0)
{
var newMillesimo = new Millesimo(conto, listaUnita[0])
{
Valore = Convert.ToDecimal((float) rowMillesimo["Mill"]),
CodiceImportazione = rowMillesimo["TabMillesimiLocali.id"].ToString().Trim()
};
_daoFactory.GetMillesimoDao().SaveOrUpdate(newMillesimo);
if (listaUnita[0].GetConduttorePrincipale(dataInizioEsercizio) != null)
{
var percentualeProp = Convert.ToDecimal((float)rowMillesimo["PercProp"]) / 100m;
new SoggettoCondominioRipartizione(conto, listaUnita[0].GetProprietarioPrincipale(dataInizioEsercizio), percentualeProp);
new SoggettoCondominioRipartizione(conto, listaUnita[0].GetConduttorePrincipale(dataInizioEsercizio), 1 - percentualeProp);
}
}
}
}
catch (Exception ex)
{
_log.Error("Errore inaspettato nell'importazione di un condominio da GeCo: " + Library.Utility.GetMethodDescription() + " (Millesimi) - millesimo:" + rowMillesimo["TabMillesimiLocali.id"].ToString().Trim(), ex);
throw;
}
}
}
catch (Exception ex)
{
_log.Error("Errore inaspettato nell'importazione di un condominio da GeCo: " + Library.Utility.GetMethodDescription() + " (Millesimi) - conto:" + conto.CodiceImportazione, ex);
throw;
}
}
}
catch (Exception ex)
{
_log.Error("Errore inaspettato nell'importazione di un condominio da GeCo: " + Library.Utility.GetMethodDescription() + " (Millesimi) - condominio:" + codiceCondominio, ex);
throw;
}
// ===================================
// Regole di ripartizione
// ===================================
try
{
var regoleAdapter = new OleDbDataAdapter("SELECT TabRegoleRipartizione.Nome, TabRegoleRipartizione.Note, TabRegoleRipartizione.idEsercizio, TabDettagliRegoleRipartizione.* " +
"FROM TabRegoleRipartizione INNER JOIN TabDettagliRegoleRipartizione ON TabRegoleRipartizione.id = TabDettagliRegoleRipartizione.idRegola " +
"WHERE TabRegoleRipartizione.idEsercizio = " + rowEsercizio["id"].ToString().Trim() + ";", conn);
regoleAdapter.Fill(dsCondomini, "Regole");
int lastIdModello = 0;
ModelloRegistrazioneContabile lastModello = null;
foreach (DataRow rowRegola in dsCondomini.Tables["Regole"].Rows)
{
try
{
var hql = "FROM Conto C WHERE C.CodiceImportazione = :codice";
var listaConti = _daoFactory.GetContoDao().GetByQuery(hql, new[] { new QueryParam("codice", rowRegola["idCapitolo"].ToString().Trim()) });
if (listaConti.Count > 0)
{
var hqlSottoConto = "FROM SottoConto S WHERE S.CodiceImportazione = :codice";
var listaSottoConti = _daoFactory.GetSottoContoDao().GetByQuery(hqlSottoConto, new[] { new QueryParam("codice", rowRegola["idSottoCapitolo"].ToString().Trim()) });
if (listaSottoConti.Count > 0)
{
if ((int)rowRegola["idRegola"] != lastIdModello)
{
var modello = new ModelloRegistrazioneContabile(condominio, rowRegola["Nome"].ToString(), null)
{
CodiceImportazione = rowRegola["idRegola"].ToString().Trim()
};
lastIdModello = (int)rowRegola["idRegola"];
lastModello = modello;
_daoFactory.GetModelloRegistrazioneContabileDao().SaveOrUpdate(modello);
}
var contoModello = new ContiModelloRegistrazioneContabile(lastModello, listaConti[0], listaSottoConti[0], Convert.ToDecimal((float)rowRegola["Perc"])/100m, null) {CodiceImportazione = rowRegola["id"].ToString().Trim()};
_daoFactory.GetContiModelloRegistrazioneContabileDao().SaveOrUpdate(contoModello);
}
}
}
catch (Exception ex)
{
_log.Error("Errore inaspettato nell'importazione di un condominio da GeCo: " + Library.Utility.GetMethodDescription() + " (Regole Ripartizione) - regola:" + rowRegola["idRegola"].ToString().Trim(), ex);
throw;
}
}
}
catch (Exception ex)
{
_log.Error("Errore inaspettato nell'importazione di un condominio da GeCo: " + Library.Utility.GetMethodDescription() + " (Regole Ripartizione)", ex);
throw;
}
}
else
{
message = "Non è stato trovato alcun esercizio Ordinario importabile per il condominio: " + codiceCondominio + " - " + rowCondominio["Nome"];
_log.Error(message + " - " + Library.Utility.GetMethodDescription());
}
}
else
{
message = "Non è stato trovato il condominio: " + codiceCondominio;
_log.Error(message + " - " + Library.Utility.GetMethodDescription());
}
return message;
}
public SottoContoDTO GetSottoContoByDomainEntity(SottoConto conto)
{
try
{
return setSottoContoDto(conto, false);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel caricamento dei sottoconti - {0} - id:{1}", ex, Utility.GetMethodDescription(), conto?.ID.ToString(CultureInfo.InvariantCulture) ?? "<NULL>");
throw;
}
}
public string UpdateConto(IList<ContoListaDTO> conti)
{
try
{
var message = new StringBuilder();
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
foreach(var contoDto in conti)
{
try
{
Conto conto;
if (contoDto.ID > 0)
{
conto = daoFactory.GetContoDao().GetById(contoDto.ID, false);
conto.Descrizione = contoDto.Descrizione;
}
else
{
conto = new Conto(daoFactory.GetCondominioDao().GetById(contoDto.IdCondominio, false), contoDto.Tipo, tipoCompetenza: TipoPeriodoCompetenzaContabile.Esercizio, descrizione: contoDto.Descrizione, ripartizione: false, utilizzabileRegistrazioneSpese: contoDto.UtilizzabileRegistrazioneSpese, utilizzabileVersamentoCondomini: contoDto.UtilizzabileVersamentoCondomini) {CustomField = true, CodiceImportazione = contoDto.CodiceImportazione, DettaglioMovimentiContabili = contoDto.DettaglioMovimentiContabili};
daoFactory.GetContoDao().SaveOrUpdate(conto);
}
conto.Codice = contoDto.Codice;
conto.Ordine = contoDto.Ordine;
conto.UtilizzabileRegistrazioneSpese = contoDto.UtilizzabileRegistrazioneSpese;
conto.UtilizzabilePagamentoFornitori = contoDto.UtilizzabilePagamentoFornitori;
conto.IsTransitorio = contoDto.IsTransitorio;
conto.IsAccantonamentoFondi = contoDto.IsAccantonamentoFondi;
conto.IsMillesimiProprieta = contoDto.IsMillesimiProprieta;
conto.DettaglioMovimentiContabili = contoDto.DettaglioMovimentiContabili;
conto.IsLiquido = contoDto.IsLiquido;
conto.IsArrotondamento = contoDto.IsArrotondamento;
if (!string.IsNullOrEmpty(contoDto.TipoLiquidita))
{
TipoLiquidita tipoLiquidita;
if (Enum.TryParse(contoDto.TipoLiquidita, true, out tipoLiquidita))
conto.TipoLiquidita = tipoLiquidita;
}
conto.ContatoreRiferimento = null;
if (contoDto.IdContatore != null)
{
var contatore = daoFactory.GetContatoreDao().Find(contoDto.IdContatore.GetValueOrDefault(), false);
if (contatore != null)
conto.ContatoreRiferimento = contatore;
}
if (conto.Tipo == TipoContoEconomicoEnum.Undefined)
conto.Tipo = TipoContoEconomicoEnum.Economico;
if (conto.Tipo == TipoContoEconomicoEnum.Economico)
{
conto.PercentualeProprieta = contoDto.PercentualeProprieta;
conto.IsSpesePersonali = contoDto.IsSpesePersonali;
conto.IsRipartoLetture = contoDto.IsRipartoLetture;
conto.DescrizioneBilancio = contoDto.DescrizioneBilancio;
conto.Ripartizione = true;
conto.PresenteBilancio = true;
if (!string.IsNullOrEmpty(conto.Descrizione) && conto.Descrizione.Length > 100)
conto.Descrizione = conto.Descrizione.Substring(0, 100);
if (!string.IsNullOrEmpty(conto.DescrizioneBilancio) && conto.DescrizioneBilancio.Length > 100)
conto.DescrizioneBilancio = conto.DescrizioneBilancio.Substring(0, 100);
if(contoDto.ID == 0)
conto.TipoCompetenza = TipoPeriodoCompetenzaContabile.Esercizio;
}
if(conto.Tipo == TipoContoEconomicoEnum.Patrimoniale)
conto.UtilizzabileVersamentoCondomini = contoDto.UtilizzabileVersamentoCondomini;
conto.EsercizioRiferimento = contoDto.IdEsercizio != null ? daoFactory.GetEsercizioDao().Find(contoDto.IdEsercizio.Value, false) : null;
// =====================================================================
// Sotto Conti
// =====================================================================
const int index = 0;
foreach (var sottoContoDto in contoDto.SottoConti)
{
if (!string.IsNullOrEmpty(sottoContoDto.Descrizione))
{
SottoConto sottoConto;
var descrizione = sottoContoDto.Descrizione;
if (!string.IsNullOrEmpty(descrizione) && descrizione.Length > 250)
descrizione = descrizione.Substring(0, 250);
if (sottoContoDto.ID > 0)
{
sottoConto = daoFactory.GetSottoContoDao().GetById(sottoContoDto.ID, false);
sottoConto.Descrizione = descrizione;
}
else
{
sottoConto = new SottoConto(conto, descrizione) { CustomField = true };
daoFactory.GetSottoContoDao().SaveOrUpdate(sottoConto);
}
sottoConto.Codice = sottoContoDto.Codice;
sottoConto.PercentualeProprieta = sottoContoDto.PercentualeProprieta;
sottoConto.AddebitoCompetenze = sottoContoDto.AddebitoCompetenze;
sottoConto.IsInteressiSanzioni = sottoContoDto.IsInteressiSanzioni;
sottoConto.DettaglioMovimentiContabili = sottoContoDto.DettaglioMovimentiContabili;
// -------------------------------------
// Aggiorno il codice dei sottoconti
// -------------------------------------
if (!string.IsNullOrEmpty(sottoConto.Codice))
{
if (sottoConto.Codice.Contains('.'))
{
var codiceSottoConto = conto.Codice + sottoConto.Codice.Substring(sottoConto.Codice.IndexOf('.'));
if (codiceSottoConto.Length <= 7)
sottoConto.Codice = codiceSottoConto;
}
}
else
sottoConto.Codice = conto.Codice + "." + index.ToString(CultureInfo.InvariantCulture).PadLeft(3, '0');
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nell'update di uno specifico conto - {0} - id:{1} - {2}", ex, Utility.GetMethodDescription(), contoDto.ID, contoDto.Descrizione);
throw;
}
}
return message.ToString();
}
catch (Exception ex)
{
var idConti = conti.Aggregate(string.Empty, (current, contoListaDTO) => current + contoListaDTO.ID + ", ");
_log.ErrorFormat("Errore nell'update conti - {0} - conti:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), idConti, _info.Azienda);
throw;
}
}
private bool insertSottoconto(SottoContoDTO dto, out SottoConto item)
{
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
try
{
item = new SottoConto(daoFactory.GetContoDao().GetById(dto.IdContoRiferimento, false), dto.Descrizione) {Codice = dto.Codice, PercentualeProprieta = dto.PercentualeProprieta, AddebitoCompetenze = dto.AddebitoCompetenze, IsInteressiSanzioni = dto.IsInteressiSanzioni, DettaglioMovimentiContabili = dto.DettaglioMovimentiContabili, CustomField = true};
daoFactory.GetSottoContoDao().SaveOrUpdate(item);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nell'inserimento del Sotto Conto - {0} - id:{1}", ex, Utility.GetMethodDescription(), dto.ID);
throw;
}
return true;
}
public TestataMovimentoContabile SetMovimentiSollecito(Esercizio esercizio, IList<Sollecito> solleciti, DateTime dataRegistrazione, Conto conto, SottoConto sottoconto)
{
try
{
// controllo data registrazione
var message = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
if (message.Count > 0)
{
var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", dataRegistrazione));
_log.FatalFormat("Data di registrazione non valida - {0} - data:{1} - conto:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), dataRegistrazione, conto.ID, esercizio.ID);
throw ex;
}
var testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null)
{
Descrizione = "Addebito solleciti del " + dataRegistrazione.ToShortDateString(),
IsAllowUpdate = true
};
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("IA");
var numeroRiga = 0;
// Contropartita
numeroRiga++;
var contoContropartita = _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, "913");
new MovimentoContabile(testata, causale, numeroRiga, contoContropartita, solleciti.Sum(item => item.ImportoCompetenza.GetValueOrDefault()), "A");
foreach (var soll in solleciti)
{
numeroRiga++;
var movimento = new MovimentoContabile(testata, causale, numeroRiga, conto, soll.ImportoCompetenza, "D") {SottoContoRiferimento = sottoconto};
if (soll.Soggetto != null)
movimento.CondominoRiferimento = soll.Soggetto;
soll.MovimentoEconomico = movimento;
movimento.IsRipartoPersonalizzato = true;
var soggetto = soll.Soggetto ?? soll.Persona.SoggettiCondominio.FirstOrDefault(item => item.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.CondominioRiferimento.ID == soll.Esercizio.CondominioRiferimento.ID);
if (soggetto != null)
{
movimento.CondominoRiferimento = soggetto;
switch (soggetto.Tipo)
{
case TipoSoggetto.Proprietario:
movimento.PercentualeProprieta = 1;
break;
case TipoSoggetto.Conduttore:
movimento.PercentualeProprieta = 0;
break;
}
new SpeseUnita(soll.ImportoCompetenza, null, soggetto, movimento);
}
}
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
return testata;
}
catch (Exception ex)
{
_log.Fatal("Errore inaspettato nella creazione del movimento di addebito competenze per sollecito - " + Utility.GetMethodDescription() + " - IdEsercizio:" + esercizio.ID.ToString(), ex);
throw;
}
}
public TestataMovimentoContabile SetMovimentiAddebitoCompetenze(Esercizio esercizio, AddebitoCompetenza addebito, DateTime dataRegistrazione, Conto conto, SottoConto sottoConto, string descrizione)
{
try
{
// controllo data registrazione
var message = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
if (message.Count > 0)
{
var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", dataRegistrazione));
_log.ErrorFormat("Data di registrazione non valida - {0} - data:{1} - addebito:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), dataRegistrazione, addebito.ID, esercizio.ID);
throw ex;
}
// se la testata è automatica non è possibile aggiornare gli importi nel dettaglio, se manuale è possibile l'aggiornamento.
// per ora la testata viene inserita come manuale.
//TestataMovimentoContabile testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, Sfera.Enums.TipoTestataMovimentoContabileEnum.Automatica);
var testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Manuale, null) {Descrizione = descrizione, IsAllowUpdate = true};
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("IA");
var numeroRiga = 0;
// Contropartita
numeroRiga++;
var contoContropartita = _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, "913");
new MovimentoContabile(testata, causale, numeroRiga, contoContropartita, addebito.Dettaglio.Sum(item => item.Importo), "A") {Descrizione = descrizione};
foreach (var item in addebito.Dettaglio)
{
try
{
numeroRiga++;
var movimento = new MovimentoContabile(testata, causale, numeroRiga, conto, item.Importo, "D")
{
SottoContoRiferimento = sottoConto,
Descrizione = descrizione,
CondominoRiferimento = item.Soggetto
};
item.MovimentoContabile = movimento;
switch (item.Soggetto.Tipo)
{
case TipoSoggetto.Proprietario:
movimento.PercentualeProprieta = 1;
break;
case TipoSoggetto.Conduttore:
movimento.PercentualeProprieta = 0;
break;
}
movimento.IsRipartoPersonalizzato = true;
new SpeseUnita(item.Importo, null, item.Soggetto, movimento);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella creazione del movimento di addebito competenze per sollecito - SINGOLO DETTAGLIO - {0} - item:{1}", ex, Utility.GetMethodDescription(), item.ID);
throw;
}
}
addebito.TestataMovimento = testata;
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
return testata;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella creazione del movimento di addebito competenze per sollecito - {0} - esercizio:{1} - dataRegistrazione:{2} - addebito:{3} - conto:{4} - sottoconto:{5} - descrizione:{6}", ex, Utility.GetMethodDescription(), esercizio != null ? esercizio.ID.ToString() : "<NULL>", dataRegistrazione, addebito != null ? addebito.ID.ToString() : "<NULL>", conto != null ? conto.ID.ToString() : "<NULL>", sottoConto != null ? sottoConto.ID.ToString() : "<NULL>", descrizione);
throw;
}
}
private SottoContoDTO setSottoContoDto(SottoConto sottoConto, bool gestione)
{
var dto = new SottoContoDTO
{
IdContoRiferimento = sottoConto.ContoRiferimento.ID,
DescrizioneContoRiferimento = sottoConto.ContoRiferimento.Descrizione,
ID = sottoConto.ID,
IsDeleteAllow = true,
Codice = sottoConto.Codice,
PercentualeProprieta = sottoConto.PercentualeProprieta,
AddebitoCompetenze = sottoConto.AddebitoCompetenze,
IsInteressiSanzioni = sottoConto.IsInteressiSanzioni,
DettaglioMovimentiContabili = sottoConto.DettaglioMovimentiContabili,
DisplayName = $"{sottoConto.ContoRiferimento.Codice} - {sottoConto.ContoRiferimento.Descrizione} - {sottoConto.GetDescrizione(null, sottoConto.ContoRiferimento.CondominioRiferimento, null)}",
DescrizioneCompleta = $"{sottoConto.Codice} - {sottoConto.Descrizione}",
Version = sottoConto.Version,
Descrizione = gestione ? sottoConto.Descrizione : sottoConto.GetDescrizione(null, sottoConto.ContoRiferimento.CondominioRiferimento, null)
};
return dto;
}
