public void UpdateRuleId(string oldRuleId, string newRuleId)
{
var rule = GetRuleByID(oldRuleId);
rule["id"] = newRuleId;
RulesDataStoreChanged?.Invoke();
}
/// <summary>
/// Adds a rule to the Rules data store. This will add it to the rulesList.
/// </summary>
/// <param name="newRule">The RuleWithSettingsMetadata to be added</param>
public void AddRule(JObject newRule)
{
m_DataStore.rulesList.Add(newRule);
RulesDataStoreChanged?.Invoke();
RemoteSettingDataStoreChanged?.Invoke();
AddRuleToAddedRuleIDs(newRule);
}
/// <summary>
/// Deletes a rule from the Rules data store. This will delete it from the rulesList.
/// </summary>
/// <param name="deletedRuleID">ID of the Rule to be deleted</param>
public void DeleteRule(string deletedRuleID)
{
AddRuleToDeletedRuleIDs(GetRuleByID(deletedRuleID));
m_DataStore.rulesList.Remove(m_DataStore.rulesList.Find(rule => rule.id == deletedRuleID));
RulesDataStoreChanged?.Invoke();
RemoteSettingDataStoreChanged?.Invoke();
}
/// <summary>
/// Adds a rule to the Rules data store. This will add it to the rulesList.
/// </summary>
/// <param name="newRule">The RuleWithSettingsMetadata to be added</param>
public void AddRule(RuleWithSettingsMetadata newRule)
{
m_DataStore.rulesList.Add(newRule);
RulesDataStoreChanged?.Invoke();
RemoteSettingDataStoreChanged?.Invoke();
AddRuleToAddedRuleIDs(newRule);
}
/// <summary>
/// Sets the Rules data store using a list of Rules.
/// </summary>
/// <param name="newRulesDataStore">A list of Rule objects</param>
public void SetRulesDataStore(List <Rule> newRulesDataStore)
{
m_DataStore.rulesList = new List <RuleWithSettingsMetadata>();
var defaultSettings = m_DataStore.rsKeyList;
foreach (var rule in newRulesDataStore)
{
var settingsInRule = new List <RsKvtData>();
foreach (var setting in rule.value)
{
string entityId = null;
var defaultSettingIndex = defaultSettings.FindIndex(item => (item.rs.key == setting.key && item.rs.type == setting.type));
if (defaultSettingIndex == -1)
{
entityId = Guid.NewGuid().ToString();
}
else
{
entityId = defaultSettings[defaultSettingIndex].metadata.entityId;
}
settingsInRule.Add(new RsKvtData(entityId, setting));
}
m_DataStore.rulesList.Add(new RuleWithSettingsMetadata(rule.id, rule.name, rule.enabled, rule.priority, rule.condition, rule.rolloutPercentage, settingsInRule, rule.startDate, rule.endDate));
}
RulesDataStoreChanged?.Invoke();
RemoteSettingDataStoreChanged?.Invoke();
}
/// <summary>
/// Enables or disables the given rule.
/// </summary>
/// <param name="ruleId">ID of Rule to be enabled or disabled</param>
/// <param name="enabled">true = enabled, false = disabled</param>
public void EnableOrDisableRule(string ruleId, bool enabled)
{
var ruleIndex = m_DataStore.rulesList.FindIndex(r => r.id == ruleId);
var rule = m_DataStore.rulesList[ruleIndex];
rule.enabled = enabled;
m_DataStore.rulesList[ruleIndex] = rule;
AddRuleToUpdatedRuleIDs(ruleId);
RulesDataStoreChanged?.Invoke();
}
/// <summary>
/// Updates the attributes for a given rule. This will update the rule in the rulesList.
/// </summary>
/// <param name="ruleId">ID of the rule being updated</param>
/// <param name="newRule">RuleWithSettingsMetadata object containing the new attributes</param>
public void UpdateRuleAttributes(string ruleId, RuleWithSettingsMetadata newRule)
{
if (ValidateRule(newRule))
{
var ruleIndex = m_DataStore.rulesList.FindIndex(r => r.id == ruleId);
m_DataStore.rulesList[ruleIndex] = newRule;
RulesDataStoreChanged?.Invoke();
AddRuleToUpdatedRuleIDs(newRule.id);
}
}
/// <summary>
/// Enables or disables the given rule.
/// </summary>
/// <param name="ruleId">ID of Rule to be enabled or disabled</param>
/// <param name="enabled">true = enabled, false = disabled</param>
public void EnableOrDisableRule(string ruleId, bool enabled)
{
for (int i = 0; i < m_DataStore.rulesList.Count; i++)
{
if (m_DataStore.rulesList[i]["id"].Value <string>() == ruleId)
{
m_DataStore.rulesList[i]["enabled"] = enabled;
break;
}
}
AddRuleToUpdatedRuleIDs(ruleId);
RulesDataStoreChanged?.Invoke();
}
/// <summary>
/// Deletes a rule from the Rules data store. This will delete it from the rulesList.
/// </summary>
/// <param name="deletedRuleID">ID of the Rule to be deleted</param>
public void DeleteRule(string deletedRuleID)
{
AddRuleToDeletedRuleIDs(deletedRuleID);
for (int i = 0; i < m_DataStore.rulesList.Count; i++)
{
if (m_DataStore.rulesList[i]["id"].Value <string>() == deletedRuleID)
{
m_DataStore.rulesList.RemoveAt(i);
break;
}
}
//m_DataStore.rulesList.Remove(m_DataStore.rulesList.Find(rule => rule.id == deletedRuleID));
RulesDataStoreChanged?.Invoke();
RemoteSettingDataStoreChanged?.Invoke();
}
public void UpdateRule(JObject oldRule, JObject newRule)
{
if (IsVariantRule(oldRule))
{
for (int i = 0; i < m_DataStore.rulesList.Count; i++)
{
if (m_DataStore.rulesList[i]["id"].Value <string>() == oldRule["id"].Value <string>())
{
m_DataStore.rulesList[i] = newRule;
}
}
}
AddRuleToUpdatedRuleIDs(newRule["id"].Value <string>());
RulesDataStoreChanged?.Invoke();
}
/// <summary>
/// Updates the type of a given rule.
/// </summary>
/// <param name="ruleId">ID of the rule being updated</param>
/// <param name="newType">New type for the rule</param>
public void UpdateRuleType(string ruleId, string newType)
{
// see which type is being changed to.
// if going from segmentation to variant, need to change datastructure
// if going from variant to segmentation, need to blow away variant structure and move to old structure
// find the rule first
for (int i = 0; i < m_DataStore.rulesList.Count; i++)
{
if (m_DataStore.rulesList[i]["id"].Value <string>() == ruleId)
{
var ruleObj = m_DataStore.rulesList[i];
var oldType = ruleObj["type"].Value <string>();
if (oldType == "segmentation" && newType == "variant")
{
var oldValue = (JArray)ruleObj["value"];
oldValue.Parent.Remove();
var newVariant = new JObject();
newVariant["id"] = "variant-1";
newVariant["type"] = newType;
newVariant["weight"] = null;
newVariant["values"] = oldValue;
var ruleValueJArray = new JArray();
ruleValueJArray.Add(newVariant);
ruleObj["value"] = ruleValueJArray;
ruleObj["type"] = newType;
}
else if (oldType == "variant" && newType == "segmentation")
{
if (!EditorUtility.DisplayDialog("Switching rule type from 'variant' to 'segmentation' will remove your variants",
"Do you want to proceed?", "Yes", "No"))
{
return;
}
var oldValue = (JArray)ruleObj["value"];
oldValue.Parent.Remove();
var newValues = (JArray)oldValue[0]["values"];
ruleObj["type"] = newType;
ruleObj["value"] = newValues;
}
RulesDataStoreChanged?.Invoke();
AddRuleToUpdatedRuleIDs(ruleId);
}
}
}
/// <summary>
/// Updates the attributes for a given rule. This will update the rule in the rulesList.
/// </summary>
/// <param name="ruleId">ID of the rule being updated</param>
/// <param name="newRule">RuleWithSettingsMetadata object containing the new attributes</param>
public void UpdateRuleAttributes(string ruleId, JObject newRule)
{
if (ValidateRule(newRule))
{
for (int i = 0; i < m_DataStore.rulesList.Count; i++)
{
if (m_DataStore.rulesList[i]["id"].Value <string>() == ruleId)
{
m_DataStore.rulesList[i] = newRule;
break;
}
}
RulesDataStoreChanged?.Invoke();
AddRuleToUpdatedRuleIDs(ruleId);
}
}
/// <summary>
/// Sets the Rules data store using a list of Rules.
/// </summary>
/// <param name="newRulesDataStore">A list of Rule objects</param>
public void SetRulesDataStore(JArray newRulesDataStore)
{
m_DataStore.rulesList = new JArray();
var defaultSettings = m_DataStore.rsKeyList;
foreach (var rule in newRulesDataStore)
{
if (rule["type"].Value <string>() == "segmentation")
{
var settingsInRule = new JArray();
foreach (var setting in rule["value"])
{
var newSetting = new JObject();
// if rule is already formatted, with ["rs"] key present in the setting, leave setting as is:
if (setting["rs"] != null)
{
newSetting = (JObject)setting;
}
else
{
string entityId = null;
var defaultSettingIndex = -1;
for (int i = 0; i < defaultSettings.Count; i++)
{
if (defaultSettings[i]["rs"]["key"].Value <string>() == setting["key"].Value <string>() && defaultSettings[i]["rs"]["type"].Value <string>() == setting["type"].Value <string>())
{
defaultSettingIndex = i;
}
}
if (defaultSettingIndex == -1)
{
entityId = Guid.NewGuid().ToString();
}
else
{
entityId = defaultSettings[defaultSettingIndex]["metadata"]["entityId"].Value <string>();
}
newSetting["metadata"] = new JObject();
newSetting["metadata"]["entityId"] = entityId;
newSetting["rs"] = setting;
}
settingsInRule.Add(newSetting);
}
var newRule = rule;
newRule["value"] = settingsInRule;
m_DataStore.rulesList.Add(newRule);
}
else if (rule["type"].Value <string>() == "variant")
{
foreach (var variant in rule["value"])
{
var variantsJArray = (JArray)variant["values"];
var settingsInVariant = new JArray();
for (int i = 0; i < variantsJArray.Count; i++)
{
var newSetting = new JObject();
// if rule is already formatted, with ["rs"] key present in the setting, leave setting as is:
if (variantsJArray[i]["rs"] != null)
{
newSetting = (JObject)variantsJArray[i];
}
else
{
string entityId = null;
var defaultSettingIndex = -1;
for (int j = 0; j < defaultSettings.Count; j++)
{
if (defaultSettings[j]["rs"]["key"].Value <string>() == variantsJArray[i]["key"].Value <string>() && defaultSettings[j]["rs"]["type"].Value <string>() == variantsJArray[i]["type"].Value <string>())
{
defaultSettingIndex = j;
}
}
if (defaultSettingIndex == -1)
{
entityId = Guid.NewGuid().ToString();
}
else
{
entityId = defaultSettings[defaultSettingIndex]["metadata"]["entityId"].Value <string>();
}
newSetting["metadata"] = new JObject();
newSetting["metadata"]["entityId"] = entityId;
newSetting["rs"] = variantsJArray[i];
}
settingsInVariant.Add(newSetting);
}
variant["values"] = settingsInVariant;
}
m_DataStore.rulesList.Add(rule);
}
}
RulesDataStoreChanged?.Invoke();
RemoteSettingDataStoreChanged?.Invoke();
}
