/// <summary>
/// Sets a setting.
/// </summary>
/// <typeparam name="T">The type of the setting.</typeparam>
/// <param name="setting">The setting to set.</param>
/// <param name="value">The value to set.</param>
public static void SetSetting <T>(SettingType setting, T value)
{
lock (_settingLock)
{
using (var db = new Db())
{
var set = db.Settings.Find(setting.ToString());
if (set == null)
{
set = new Setting
{
Name = setting.ToString(),
Value = JsonConvert.SerializeObject(value)
};
db.Settings.Add(set);
}
else
{
set.Value = JsonConvert.SerializeObject(value);
db.Entry(set).CurrentValues.SetValues(set);
}
db.SaveChanges();
}
}
}
private void RefreshSettings()
{
_settings.Clear();
string settingType = _settingType.ToString();
foreach (SystemSetting item in _context.SystemSettings.Where(n => n.Type.Equals(settingType)))
{
_settings.Add(item);
}
}
public Setting(String title, String value, SettingCategory category, SettingType dataType)
{
_title = title;
_value = value;
_category = category;
_dataType = dataType.ToString();
}
/// <summary>
/// Gets a setting value.
/// </summary>
/// <typeparam name="T">The type of the setting.</typeparam>
/// <param name="setting">The setting to retrieve.</param>
/// <param name="def">The default value of the setting.</param>
/// <returns>The setting value.</returns>
public static T GetSetting <T>(SettingType setting, T def)
{
using (var db = new Db())
{
var dbval = db.Settings.Find(setting.ToString());
if (dbval == null)
{
return(def != null ? def : default);
public dynamic GetSettings(SettingType type)
{
dynamic data = default(dynamic);
if (settings != null)
{
Setting s = settings.FirstOrDefault(d => d.Name == type.ToString());
data = JsonConvert.DeserializeObject(s?.Value);
}
return(data);
}
void AddEntry()
{
if (!CanAddEntry())
{
return;
}
var settings = _plist.Root.ArrayValue(BUILD_SETTINGS_KEY);
int existingSettingIndex = IndexOfSetting(_setting);
var dic = new PListDictionary();
dic.Add(SETTING_KEY, _setting);
dic.Add(DISPLAY_NAME_KEY, _name);
dic.Add(GROUP_KEY, _groups[_groupIndex]);
dic.Add(TYPE_KEY, _entryType.ToString());
switch (_entryType)
{
case SettingType.Bool:
AddBoolValue(dic);
break;
case SettingType.Enum:
AddEnumValues(dic);
break;
case SettingType.String:
AddStringValue(dic);
break;
case SettingType.Array:
case SettingType.StringList:
AddArrayValue(dic);
break;
default:
throw new System.Exception("Invalid Entry Type");
}
if (existingSettingIndex < 0)
{
settings.Add(dic);
}
else
{
settings.RemoveAt(existingSettingIndex);
settings.Insert(existingSettingIndex, dic);
}
_plist.Save();
ResetEntry();
}
/// <summary>
/// Gets a setting value.
/// </summary>
/// <typeparam name="T">The type of the setting.</typeparam>
/// <param name="setting">The setting to retrieve.</param>
/// <param name="def">The default value of the setting.</param>
/// <returns>The setting value.</returns>
public static T GetSetting <T>(SettingType setting, T def)
{
using (var db = new Db())
{
var dbval = db.Settings.Find(setting.ToString());
if (dbval != null)
{
try
{
return(JsonConvert.DeserializeObject <T>(dbval.Value));
}
catch
{
return(def != null ? def : default(T));
}
}
return(def != null ? def : default(T));
}
}
/// <summary>
/// Referenciával rendelkező beállítás lekérdezés (több azonos nevű, de eltérő dologra hivatkozó beállítás. LEhet használni pl partnerfüggő, pénztárfüggő, felhasználófüggő stb beállítás kezelésére)
/// </summary>
public static T Get <T>(this DbSet <T> settings, SettingType settingType, long referenceId) where T : class, ISetting, new()
{
var s = settings.GetData <T>(x => { x.Name = settingType.ToString(); x.ReferenceId = referenceId; });
return(s);
}
/// <summary>
/// Update, or create, a new setting.
/// </summary>
/// <param name="name">Name of the setting.</param>
/// <param name="value">String value of the setting.</param>
/// <param name="type">Data type of the setting. Defaults to String.</param>
public static void Set(string name, string value, SettingType type = SettingType.String)
{
Setting setting = Settings.settings.SingleOrDefault(s => s.Name == name && s.Type == type.ToString());
if (setting != null) {
setting.Value = value;
setting.Changed = true;
}
else {
Settings.settings.Add(
new Setting() {
ID = 0,
Name = name,
Type = type.ToString(),
Value = value,
Changed = true
});
}
Settings.Save();
}
/// <summary>
/// Fetches a string value from the memory and returns the given default-value if not present.
/// </summary>
/// <param name="name">Name of the setting.</param>
/// <param name="defaultValue">The return value if the setting doesn't exist yet. Defaults to ""</param>
/// <param name="type">Data type of the setting. Defaults to String.</param>
/// <returns>The string from settings or default value.</returns>
public static string Get(string name, string defaultValue = "", SettingType type = SettingType.String)
{
string value = defaultValue;
Setting setting = Settings.settings.SingleOrDefault(s => s.Name == name && s.Type == type.ToString());
if (setting != null) {
value = setting.Value;
}
else {
DataRow dataRow = SQLite.SingleOrDefault(
"settings",
"value",
new List<SQLiteCondition>() {
new SQLiteCondition() { ColumnName = "username", ColumnValue = WindowsIdentity.GetCurrent().Name},
new SQLiteCondition() { ColumnName = "name", ColumnValue = name},
new SQLiteCondition() { ColumnName = "type", ColumnValue = type.ToString()}
});
if (dataRow != null) {
value = dataRow["value"].ToString();
}
else {
Settings.Set(name, value, type);
}
}
return value;
}
public static string GetSetting(string key, SettingType type)
{
foreach (var item in instance.settings)
{
if (key == item.Key)
{
if (type != item.Type)
{
Debug.LogError("The types " + item.Type.ToString() + " and " + type.ToString() + " of the setting key " + key + " are not the same!");
return("ERROR");
}
return(item.Value);
}
}
Debug.LogError("The setting key '" + key + "' doesn't exists!");
return("ERROR");
}
public override string ToString()
{
return(SettingType.ToString() + "=" + Data.ToString());
}
public void SetSetting(SettingType nicheType)
{
Console.WriteLine($"Setting set to {nicheType.ToString()}");
setting = nicheType;
}
private static string GetSettingFilePath(SettingType settingType)
{
return(Path.Combine(UserSettingsDirectory, $"{settingType.ToString()}.json"));
}
