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(); }