SteamWare/SteamWareLib/DataWrap.cs

using Newtonsoft.Json;
using System.Collections.Generic;

namespace SteamWare
{
  /// <summary>
  /// classe di wrap verso i TableAdapter impiegati
  /// </summary>
  public class DataWrap
  {
    #region area protected

    /// <summary>
    /// metodo protected di avvio della classe
    /// </summary>
    protected DataWrap()
    {
      // inizializzo i table adapters
      avvioTableAdaptersBase();
      setupConnectionStringBase();
      avvioTableAdaptersSpec();
      setupConnectionStringSpec();
      setupVocabolario();
    }

    /// <summary>
    /// procedura di avvio dei tableAdapter
    /// </summary>
    protected virtual void avvioTableAdaptersBase()
    {
      taLingue = new DataLayer_genericTableAdapters.LingueTableAdapter();
      taVocabolario = new DataLayer_genericTableAdapters.VocabolarioTableAdapter();
      taLogVoc = new DataLayer_genericTableAdapters.LogUpdateDbTableAdapter();
    }
    /// <summary>
    /// procedura di avvio dei tableAdapter
    /// </summary>
    protected virtual void avvioTableAdaptersSpec()
    {
      taCdc = new DataLayer_AnagGenTableAdapters.CDCTableAdapter();
      taDiritti = new DataLayer_AnagGenTableAdapters.DIRITTITableAdapter();
      taPermessi = new DataLayer_AnagGenTableAdapters.PermessiTableAdapter();
      taFunzione = new DataLayer_AnagGenTableAdapters.FUNZIONETableAdapter();
      taPermessi2Funzione = new DataLayer_AnagGenTableAdapters.Permessi2FunzioneTableAdapter();
      taUtente = new DataLayer_AnagGenTableAdapters.UTENTETableAdapter();
      taUserData = new DataLayer_AnagGenTableAdapters.UserDataTableAdapter();
      taUserDataExt = new DataLayer_AnagGenTableAdapters.UserDataExtTableAdapter();
      taLogAna = new DataLayer_AnagGenTableAdapters.LogUpdateDbTableAdapter();
      taAnagDev = new DS_devicesTableAdapters.AnagDevicesTableAdapter();
    }
    /// <summary>
    /// effettua setup dei connection strings da web.config delal singola applicazione
    /// </summary>
    protected virtual void setupConnectionStringBase()
    {
      string connStr = memLayer.ML.confReadString("VocabolarioConnectionString");
      // connections del db vocabolario
      taLingue.Connection.ConnectionString = connStr;
      taVocabolario.Connection.ConnectionString = connStr;
      taLogVoc.Connection.ConnectionString = connStr;
    }
    /// <summary>
    /// effettua setup dei connection strings da web.config della singola applicazione
    /// </summary>
    protected virtual void setupConnectionStringSpec()
    {
      string connStrUt = memLayer.ML.confReadString("UtenteCdcConnectionString");
      string connStrPerm = memLayer.ML.confReadString("PermessiConnectionString");
      // cambio le connString - db anagrafica principale
      taCdc.Connection.ConnectionString = connStrUt;
      taDiritti.Connection.ConnectionString = connStrUt;
      taFunzione.Connection.ConnectionString = connStrUt;
      taUtente.Connection.ConnectionString = connStrUt;
      taUserData.Connection.ConnectionString = connStrUt;
      taUserDataExt.Connection.ConnectionString = connStrUt;
      taLogAna.Connection.ConnectionString = connStrUt;
      taAnagDev.Connection.ConnectionString = connStrUt;
      // connections del db dell'applicazione
      taPermessi.Connection.ConnectionString = connStrPerm;
      taPermessi2Funzione.Connection.ConnectionString = connStrPerm;
    }
    /// <summary>
    /// setup delle tabelle vocabolario
    /// </summary>
    protected void setupVocabolario()
    {
      if (memLayer.ML.isInCacheObject("dictVocabolario"))
      {
        if (memLayer.ML.cacheOnRedis)
        {
          dictVocabolario = JsonConvert.DeserializeObject<Dictionary<string, string>>(memLayer.ML.objCacheObj("dictVocabolario").ToString());
        }
        else
        {
          dictVocabolario = (Dictionary<string, string>)memLayer.ML.objCacheObj("dictVocabolario");
        }
      }
      else
      {
        dictVocabolario = ricaricaDictVocabolario();
        if (memLayer.ML.cacheOnRedis)
        {
          string serVal = JsonConvert.SerializeObject(dictVocabolario);
          memLayer.ML.setCacheVal("dictVocabolario", serVal, true);
        }
        else
        {
          memLayer.ML.setCacheVal("dictVocabolario", dictVocabolario, true);
        }
      }
      // scrivo quanti lemmi ha caricato!
      logger.lg.scriviLog(string.Format("Caricati {0} lemmi!", dictVocabolario.Count));
    }

    /// <summary>
    /// prende l'oggetto tabVocabolario in ram e lo trasforma in dictionary
    /// </summary>
    /// <returns></returns>
    protected Dictionary<string, string> ricaricaDictVocabolario()
    {
      // continuo
      Dictionary<string, string> answ = new Dictionary<string, string>();
      if (taVocabolario == null)
      {
        foreach (DataLayer_generic.VocabolarioRow riga in DW.taVocabolario.GetData())
        {
          answ.Add(riga.Lingua.ToUpper() + "#" + riga.Lemma.ToUpper(), riga.Traduzione);
        }
      }
      else
      {
        foreach (DataLayer_generic.VocabolarioRow riga in taVocabolario.GetData())
        {
          answ.Add(riga.Lingua.ToUpper() + "#" + riga.Lemma.ToUpper(), riga.Traduzione);
        }
      }
      return answ;
    }

    #endregion

    #region area public

    /// <summary>
    /// tableAdapter diritti
    /// </summary>
    public DataLayer_AnagGenTableAdapters.DIRITTITableAdapter taDiritti;
    /// <summary>
    /// tableAdapter permessi
    /// </summary>
    public DataLayer_AnagGenTableAdapters.PermessiTableAdapter taPermessi;
    /// <summary>
    /// tableAdapter funzione
    /// </summary>
    public DataLayer_AnagGenTableAdapters.FUNZIONETableAdapter taFunzione;
    /// <summary>
    /// tableAdapter permessi2funzione
    /// </summary>
    public DataLayer_AnagGenTableAdapters.Permessi2FunzioneTableAdapter taPermessi2Funzione;
    /// <summary>
    /// tableAdapter CdC
    /// </summary>
    public DataLayer_AnagGenTableAdapters.CDCTableAdapter taCdc;
    /// <summary>
    /// tableAdapter utenti
    /// </summary>
    public DataLayer_AnagGenTableAdapters.UTENTETableAdapter taUtente;
    /// <summary>
    /// tableAdapter userData (user/pwd)
    /// </summary>
    public DataLayer_AnagGenTableAdapters.UserDataTableAdapter taUserData;
    /// <summary>
    /// tableAdapter userDataExt (user/pwd)
    /// </summary>
    public DataLayer_AnagGenTableAdapters.UserDataExtTableAdapter taUserDataExt;
    /// <summary>
    /// table adapter lingue
    /// </summary>
    public DataLayer_genericTableAdapters.LingueTableAdapter taLingue;
    /// <summary>
    /// table adapter vocabolario
    /// </summary>
    public DataLayer_genericTableAdapters.VocabolarioTableAdapter taVocabolario;
    /// <summary>
    /// table adapter versione vocabolario
    /// </summary>
    public DataLayer_genericTableAdapters.LogUpdateDbTableAdapter taLogVoc;
    /// <summary>
    /// table adapter versione anagrafica
    /// </summary>
    public DataLayer_AnagGenTableAdapters.LogUpdateDbTableAdapter taLogAna;
    /// <summary>
    /// table adapter Devices utente
    /// </summary>
    public DS_devicesTableAdapters.AnagDevicesTableAdapter taAnagDev;
    /// <summary>
    /// oggetto vocabolario organizzato come dizionario con chiave lang#lemma e valore la traduzione
    /// </summary>
    public Dictionary<string, string> dictVocabolario;
    /// <summary>
    /// resetta il vocabolario rileggendo i dati...
    /// </summary>
    public void resetVocabolario()
    {
      memLayer.ML.emptyCacheVal("dictVocabolario");
      setupVocabolario();
    }
    /// <summary>
    /// Verifica se il vocabolario sia ok...
    /// </summary>
    public bool vocabolarioOk
    {
      get
      {
        bool answ = false;
        try
        {
          answ = (dictVocabolario != null);
          if (answ)
          {
            answ = dictVocabolario.Count > 0;
          }
        }
        catch
        { }
        return answ;
      }
    }

    /// <summary>
    /// crea nel db corrente il lemma richiesto e lo valorizza come "--{0}--"
    /// </summary>
    /// <param name="lemma"></param>
    /// <returns></returns>
    public void creaNuovoLemmaVoc(string lemma)
    {
      foreach (DataLayer_generic.LingueRow rigaLingua in taLingue.GetData())
      {
        taVocabolario.Insert(rigaLingua.Lingua, lemma, string.Format("--{0}--", lemma));
      }
    }
    /// <summary>
    /// restituisce conteggio numero record dell'oggetto vocabolario
    /// </summary>
    public int numRecVoc
    {
      get
      {
        int answ = 0;
        try
        {
          answ = dictVocabolario.Count;
        }
        catch
        { }
        return answ;
      }
    }
    /// <summary>
    /// elenco lingue ammesse da vocabolario...
    /// </summary>
    public DataLayer_generic.LingueDataTable lingue
    {
      get
      {
        return taLingue.GetData();
      }
    }
    /// <summary>
    /// classe singleton x la gestione dei tableadapters
    /// </summary>
    public static DataWrap DW = new DataWrap();

    #endregion
  }
}