/// <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 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);
}
private string getAddebito(string tipo, ModelloRegistrazioneContabile modello, int index)
{
try
{
var dettaglio = modello.Conti.Skip(index).Take(1).FirstOrDefault();
var addebito = string.Empty;
if (dettaglio != null)
{
switch (tipo)
{
case "L":
foreach (var dettaglioModelloRegistrazioneContabile in dettaglio.Unita.Where(item => item.LottoRiferimento != null))
{
if (!string.IsNullOrEmpty(addebito))
addebito += "&";
addebito += dettaglioModelloRegistrazioneContabile.LottoRiferimento.ID;
}
break;
case "S":
foreach (var dettaglioModelloRegistrazioneContabile in dettaglio.Unita.Where(item => item.PalazzinaRiferimento != null))
{
if (!string.IsNullOrEmpty(addebito))
addebito += "&";
addebito += dettaglioModelloRegistrazioneContabile.PalazzinaRiferimento.ID;
}
break;
case "G":
foreach (var dettaglioModelloRegistrazioneContabile in dettaglio.Unita.Where(item => item.GruppoStabileRiferimento != null))
{
if (!string.IsNullOrEmpty(addebito))
addebito += "&";
addebito += dettaglioModelloRegistrazioneContabile.GruppoStabileRiferimento.ID;
}
break;
}
}
if (string.IsNullOrEmpty(addebito))
addebito = null;
return addebito;
}
catch (Exception ex)
{
_log.Error("Errore nella ricerca di un addebito personalizzato - " + Utility.GetMethodDescription() + " - tipo: " + tipo + " - modello:" + modello.ID + " - index:" + index, ex);
throw;
}
}
public AuthorizationMessages SalvaModello(ModelloListaRegistrazioneContabileDTO dto, bool ricalcoloSpeseEsistenti, int idUtente, LogTransazione logTransazione)
{
try
{
var logTransazioneModello = logTransazione;
var logTransazioneDettaglioModello = logTransazione;
var logTransazioneFornitoreModello = logTransazione;
var logTransazioneContoModello = logTransazione;
var fatalMessage = string.Empty;
var warnMessage = string.Empty;
ModelloRegistrazioneContabile modello = null;
if (dto.ID == 0)
{
var condominio = _daoFactory.GetCondominioDao().Find(dto.IdCondominio, false);
if (condominio != null)
{
var descrizione = string.Empty;
if (!string.IsNullOrEmpty(dto.Descrizione))
{
descrizione = dto.Descrizione;
if (descrizione.Length > 100)
descrizione = descrizione.Substring(0, 100);
}
var voceFattura = string.Empty;
if (!string.IsNullOrEmpty(dto.DescrizioneVoceFattura))
{
voceFattura = dto.DescrizioneVoceFattura;
if (voceFattura.Length > 512)
voceFattura = voceFattura.Substring(0, 512);
}
modello = new ModelloRegistrazioneContabile(condominio, descrizione, logTransazioneModello) { DescrizioneVoceFattura = voceFattura };
if (logTransazioneModello != null)
{
_daoFactory.GetModelloRegistrazioneContabileDao().SaveOrUpdate(modello);
logTransazioneContoModello = null;
logTransazioneDettaglioModello = null;
logTransazioneFornitoreModello = null;
}
}
}
else
{
modello = _daoFactory.GetModelloRegistrazioneContabileDao().Find(dto.ID, false);
if(modello != null)
modello.Descrizione = dto.Descrizione;
}
if (modello != null)
{
modello.DescrizioneVoceFattura = dto.DescrizioneVoceFattura;
// --------------------------
// Fornitori
// --------------------------
modello.Fornitori.Clear();
foreach (var dtoFornitore in dto.Fornitori)
{
ModelloContabileFornitore modelloFornitore = null;
if (dtoFornitore.ID == 0)
{
if (dtoFornitore.IdFornitore > 0)
{
var fornitore = _daoFactory.GetFornitoreDao().Find(dtoFornitore.IdFornitore, false);
if (fornitore != null)
{
modelloFornitore = new ModelloContabileFornitore(fornitore, modello, logTransazioneFornitoreModello);
if(logTransazioneFornitoreModello != null)
_daoFactory.GetModelloContabileFornitoreDao().SaveOrUpdate(modelloFornitore);
}
else
{
_log.WarnFormat("Fornitore inesistente - {0} - fornitore:{1}", Library.Utility.GetMethodDescription(), dtoFornitore.IdFornitore);
}
}
else
{
_log.WarnFormat("Fornitore non definito - {0}", Library.Utility.GetMethodDescription());
}
}
else
{
modelloFornitore = _daoFactory.GetModelloContabileFornitoreDao().Find(dtoFornitore.ID, false);
if (modelloFornitore != null)
modelloFornitore.Fornitore = _daoFactory.GetFornitoreDao().GetById(dtoFornitore.IdFornitore, false);
else
{
_log.WarnFormat("Modello inesistente - {0} - IdModello:{1}", Library.Utility.GetMethodDescription(), dtoFornitore.IdModello);
}
}
if (modelloFornitore != null)
modello.Fornitori.Add(modelloFornitore);
}
// --------------------------
// Conti
// --------------------------
modello.Conti.Clear();
foreach (var dtoConto in dto.Conti)
{
var conto = _daoFactory.GetContoDao().Find(dtoConto.IdConto, false);
var sottoConto = _daoFactory.GetSottoContoDao().Find(dtoConto.IdSottoConto, false);
var modelloConto = _daoFactory.GetContiModelloRegistrazioneContabileDao().Find(dtoConto.ID, false);
if (modelloConto == null)
{
modelloConto = new ContiModelloRegistrazioneContabile(modello, conto, sottoConto, dtoConto.PercentualeRipartizione, logTransazioneContoModello);
if (logTransazioneContoModello != null)
{
_daoFactory.GetContiModelloRegistrazioneContabileDao().SaveOrUpdate(modelloConto);
logTransazioneDettaglioModello = null;
}
}
else
{
modelloConto.PercentualeRipartizione = dtoConto.PercentualeRipartizione;
if (conto != null)
modelloConto.ContoRiferimento = conto;
if (sottoConto != null)
modelloConto.SottoContoRiferimento = sottoConto;
}
// --------------------------
// Riparto
// --------------------------
modelloConto.Unita.Clear();
foreach (var dtoRiparto in dtoConto.Riparto)
{
var modelloRiparto = _daoFactory.GetDettaglioModelloRegistrazioneContabileDao().Find(dtoRiparto.ID, false);
if (modelloRiparto == null)
{
modelloRiparto = new DettaglioModelloRegistrazioneContabile(modelloConto, logTransazioneDettaglioModello);
if(logTransazioneDettaglioModello != null)
_daoFactory.GetDettaglioModelloRegistrazioneContabileDao().SaveOrUpdate(modelloRiparto);
}
// Lotto
modelloRiparto.LottoRiferimento = dtoRiparto.IdLotto > 0 ? _daoFactory.GetLottoDao().GetById(dtoRiparto.IdLotto.Value, false) : null;
// Stabile
modelloRiparto.PalazzinaRiferimento = dtoRiparto.IdStabile > 0 ? _daoFactory.GetPalazzinaDao().GetById(dtoRiparto.IdStabile.Value, false) : null;
// Gruppo Stabile
modelloRiparto.GruppoStabileRiferimento = dtoRiparto.IdGruppoStabile > 0 ? _daoFactory.GetGruppoStabileDao().GetById(dtoRiparto.IdGruppoStabile.Value, false) : null;
// Unità Immobiliare
modelloRiparto.UnitaRiferimento = dtoRiparto.IdUnita > 0 ? _daoFactory.GetUnitaImmobiliareDao().GetById(dtoRiparto.IdUnita.Value, false) : null;
modelloConto.Unita.Add(modelloRiparto);
}
modello.Conti.Add(modelloConto);
}
if (ricalcoloSpeseEsistenti)
{
var authMessage = ReloadRipartizioneByModelloEsercizio(modello.ID, null, null, idUtente, logTransazione);
if (!string.IsNullOrEmpty(authMessage.FatalMessage))
fatalMessage += authMessage.FatalMessage + Environment.NewLine;
if (!string.IsNullOrEmpty(authMessage.WarnMessage))
warnMessage += authMessage.WarnMessage + Environment.NewLine;
}
return new AuthorizationMessages(fatalMessage, warnMessage) {Id = modello.ID};
}
return new AuthorizationMessages(fatalMessage, warnMessage);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante il salvataggio del modello contabile - {0} - modello:{1} - condominio:{2}", ex, Library.Utility.GetMethodDescription(), dto.ID, dto.IdCondominio);
throw;
}
}
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 virtual IUpdatableBusinessEntity Copy()
{
var modello = new ModelloRegistrazioneContabile(CondominioRiferimento, Descrizione, null);
return modello;
}
public IList<UnitaImmobiliare> GetUnitaModello(ModelloRegistrazioneContabile modello)
{
Iesi.Collections.Generic.ISet<UnitaImmobiliare> listaUnita = new HashedSet<UnitaImmobiliare>();
foreach (var dettaglioModello in modello.Conti)
listaUnita.AddAll(getUnitaByConto(dettaglioModello));
return listaUnita.ToList();
}
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;
}
private ModelloRegistrazioneContabileDTO setModelloDto(ModelloRegistrazioneContabile modello)
{
var dto = new ModelloRegistrazioneContabileDTO
{
Descrizione = modello.Descrizione,
DescrizioneVoceFattura = modello.DescrizioneVoceFattura,
ID = modello.ID
};
foreach (var conto in modello.Conti)
{
var contoDto = new ContiModelloRegistrazioneContabileDTO
{
ContoRiferimento = setContoDto(conto.ContoRiferimento, null, false, null, false),
IdModello = dto.ID,
DescrizioneModello = dto.Descrizione,
PercentualeRipartizione = conto.PercentualeRipartizione,
ID = conto.ID
};
if (conto.SottoContoRiferimento != null)
contoDto.SottoContoRiferimento = setSottoContoDto(conto.SottoContoRiferimento, false);
}
return dto;
}
public ModelloRegistrazioneContabile CreateModelloRipartizione(int idCondominio, ISet<MovimentoContabile> movimenti, decimal importo, string nomeModello, string descrizioneVoceSpesa)
{
try
{
if (movimenti.Count > 0)
{
if (nomeModello.Length > 100)
nomeModello = nomeModello.Substring(0, 100);
if (!string.IsNullOrEmpty(descrizioneVoceSpesa) && descrizioneVoceSpesa.Length > 50)
descrizioneVoceSpesa = descrizioneVoceSpesa.Substring(0, 50);
var modello = new ModelloRegistrazioneContabile(_daoFactory.GetCondominioDao().GetById(idCondominio, false), nomeModello, null) { DescrizioneVoceFattura = descrizioneVoceSpesa };
decimal divisore = 1;
foreach (var movimento in movimenti.OrderBy(item => Math.Abs(item.GetImportoConSegno().GetValueOrDefault())))
{
decimal percentuale;
if (importo != 0)
percentuale = movimento.GetImportoConSegno().GetValueOrDefault() / importo;
else
{
if (divisore != 1)
percentuale = movimento.GetImportoConSegno().GetValueOrDefault() / divisore;
else
{
percentuale = movimento.GetImportoConSegno().GetValueOrDefault();
do
{
percentuale = percentuale / 10;
divisore = divisore * 10;
} while (Math.Abs(percentuale) >= 10);
}
}
var contoModello = new ContiModelloRegistrazioneContabile(modello, movimento.ContoRiferimento, movimento.SottoContoRiferimento, percentuale, null);
// -----------------------------------------------------
// Selezione per lotti
// -----------------------------------------------------
if (_lottiSelezionati.ContainsKey(GetKey(movimento)))
{
var lottiTable = _lottiSelezionati[GetKey(movimento)];
foreach (DataRow row in lottiTable.Rows)
{
if (row["Selezionato"] != DBNull.Value && (bool)row["Selezionato"])
{
new DettaglioModelloRegistrazioneContabile(contoModello, null)
{
LottoRiferimento = _daoFactory.GetLottoDao().GetById((int)row["Id"], false)
};
}
}
}
// -----------------------------------------------------
// Selezione per stabili
// -----------------------------------------------------
var selezioneStabili = false;
if (_stabiliSelezionati.ContainsKey(GetKey(movimento)))
{
var stabiliTable = _stabiliSelezionati[GetKey(movimento)];
foreach (DataRow row in stabiliTable.Rows)
{
if (row["Selezionato"] != DBNull.Value && (bool)row["Selezionato"])
{
new DettaglioModelloRegistrazioneContabile(contoModello, null)
{
PalazzinaRiferimento = _daoFactory.GetPalazzinaDao().GetById((int)row["Id"], false)
};
selezioneStabili = true;
}
}
}
// -----------------------------------------------------
// Selezione per gruppi
// -----------------------------------------------------
if (_gruppiSelezionati.ContainsKey(GetKey(movimento)) && !selezioneStabili)
{
var gruppiTable = _gruppiSelezionati[GetKey(movimento)];
foreach (DataRow row in gruppiTable.Rows)
{
if (row["Selezionato"] != DBNull.Value && (bool)row["Selezionato"])
{
new DettaglioModelloRegistrazioneContabile(contoModello, null)
{
GruppoStabileRiferimento = _daoFactory.GetGruppoStabileDao().GetById((int)row["Id"], false)
};
}
}
}
}
return modello;
}
_log.ErrorFormat("Tentativo di salvare un modello senza movimenti associati - {0} - idCondominio:{1} - nome:{2}", Utility.GetMethodDescription(), idCondominio.ToString(), nomeModello);
return null;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella creazione del modello di riparto - {0} - condominio:{1} - importo:{2} - nomeModello:{3} - descrizioneVoceSpesa:{4}", ex, Utility.GetMethodDescription(), idCondominio, importo, nomeModello, descrizioneVoceSpesa);
throw;
}
}
