Internal rule conversion

Change-Id: I086e378ca435ec9109ff2f24010df032896b2fb1
Signed-off-by: Somin Kim <somin926.kim@samsung.com>

diff --git a/src/context_trigger.cpp b/src/context_trigger.cpp
index 6836145..d165575 100644 (file)
--- a/src/context_trigger.cpp
+++ b/src/context_trigger.cpp
@@ -36,8 +36,8 @@
 #define TYPE_CONDITION 2
 #define TYPE_OPTION TRIG_TMPL_KEY_OPTION
 #define TYPE_ATTRIBUTE TRIG_TMPL_KEY_ATTRIBUTE
-#define INITIAL_RULE "{ \"" TRIG_RULE_DESCRIPTION "\" : \"\", \"" TRIG_RULE_DETAILS "\" : {  } }"
-#define INITIAL_ENTRY "{ \"" TRIG_RULE_DATA_ARR "\" : [ ] }"
+#define OLD_INITIAL_RULE "{ \"" OLD_TRIG_RULE_KEY_DESCRIPTION "\" : \"\", \"" OLD_TRIG_RULE_KEY_DETAILS "\" : {  } }"
+#define OLD_INITIAL_ENTRY "{ \"" OLD_TRIG_RULE_KEY_DATA_ARR "\" : [ ] }"
 #define INITIAL_REF "{ \"" TRIG_TMPL_KEY_OPTION "\" : [ ], \"" TRIG_TMPL_KEY_ATTRIBUTE "\" : [ ] }"
 
 static ctx::DBusClient __dbusClient;
@@ -53,22 +53,22 @@ static std::string get_custom_item_subject(const char* provider, const char* ite
 //static std::string double_to_string(int value);
 
 typedef struct _context_trigger_rule_s {
-       ctx::Json jrule;        // rule_id, description, details(event, condition[])
+       ctx::Json jrule;
        ctx::Json jref;
 
        _context_trigger_rule_s() {
-               jrule = INITIAL_RULE;
+               jrule = OLD_INITIAL_RULE;
                jref = INITIAL_REF;
        }
 } _context_trigger_rule_h;
 
 typedef struct _context_trigger_rule_entry_s {
-       ctx::Json jentry;       // key, value, operator
        int type;
+       ctx::Json jentry;
        ctx::Json jref;
 
        _context_trigger_rule_entry_s(int t): type(t) {
-               jentry = INITIAL_ENTRY;
+               jentry = OLD_INITIAL_ENTRY;
 
                if (t == TYPE_CONDITION) {
                        jref = INITIAL_REF;
@@ -84,13 +84,13 @@ SO_EXPORT int context_trigger_add_rule(context_trigger_rule_h rule, int* rule_id
 
        // Err: No event
        std::string ename;
-       bool ret = (rule->jrule).get(TRIG_RULE_DETAILS "." TRIG_RULE_EVENT, TRIG_RULE_EVENT_ITEM, &ename);
+       bool ret = (rule->jrule).get(OLD_TRIG_RULE_KEY_DETAILS "." OLD_TRIG_RULE_KEY_EVENT, OLD_TRIG_RULE_KEY_EVENT_ITEM, &ename);
        if (!ret)
                return CONTEXT_TRIGGER_ERROR_INVALID_RULE;
 
        // Err: No action added
        std::string type;
-       ret = (rule->jrule).get(TRIG_RULE_DETAILS "." TRIG_RULE_ACTION, TRIG_RULE_ACTION_TYPE, &type);
+       ret = (rule->jrule).get(OLD_TRIG_RULE_KEY_DETAILS "." OLD_TRIG_RULE_KEY_ACTION, OLD_TRIG_RULE_KEY_ACTION_TYPE, &type);
        if (!ret)
                return CONTEXT_TRIGGER_ERROR_INVALID_RULE;
 
@@ -245,9 +245,9 @@ SO_EXPORT int context_trigger_rule_create(context_trigger_logical_type_e logical
        if (logical_str.empty()) {
                return CONTEXT_TRIGGER_ERROR_INVALID_PARAMETER;
        }
-
+       // TODO SOM
        *rule = new(std::nothrow) _context_trigger_rule_h();
-       (*rule)->jrule.set(TRIG_RULE_DETAILS, TRIG_RULE_OPERATOR, logical_str);
+       (*rule)->jrule.set(OLD_TRIG_RULE_KEY_DETAILS, OLD_TRIG_RULE_KEY_OPERATOR, logical_str);
 
        return ERR_NONE;
 }
@@ -269,13 +269,13 @@ SO_EXPORT int context_trigger_rule_add_entry(context_trigger_rule_h rule, contex
        ASSERT_NOT_NULL(rule && entry);
 
        std::string des;
-       bool ret = (rule->jrule).get(NULL, TRIG_RULE_DESCRIPTION, &des);
+       bool ret = (rule->jrule).get(NULL, OLD_TRIG_RULE_KEY_DESCRIPTION, &des);
        IF_FAIL_RETURN(ret, CONTEXT_TRIGGER_ERROR_INVALID_PARAMETER);
 
        if (entry->type == TYPE_EVENT) {
                // Err: More than one event
                ctx::Json elem;
-               if ((rule->jrule).get(TRIG_RULE_DETAILS, TRIG_RULE_EVENT, &elem)) {
+               if ((rule->jrule).get(OLD_TRIG_RULE_KEY_DETAILS, OLD_TRIG_RULE_KEY_EVENT, &elem)) {
                        return CONTEXT_TRIGGER_ERROR_INVALID_RULE;
                }
 
@@ -285,22 +285,22 @@ SO_EXPORT int context_trigger_rule_add_entry(context_trigger_rule_h rule, contex
 
                // Err: If referential conditions are registered priviously, check them
                std::string ename;
-               (entry->jentry).get(NULL, TRIG_RULE_EVENT_ITEM, &ename);
+               (entry->jentry).get(NULL, OLD_TRIG_RULE_KEY_EVENT_ITEM, &ename);
                ret = ctx::rule_validator::check_referential_data(ename, rule->jref);
                IF_FAIL_RETURN(ret, CONTEXT_TRIGGER_ERROR_INVALID_RULE);
 
                ctx::Json temp = (entry->jentry).str();
-               ret = (rule->jrule).set(TRIG_RULE_DETAILS, TRIG_RULE_EVENT, temp);
+               ret = (rule->jrule).set(OLD_TRIG_RULE_KEY_DETAILS, OLD_TRIG_RULE_KEY_EVENT, temp);
        } else if (entry->type == TYPE_CONDITION) {
                // Err: Condition without comparison data
-               if ((entry->jentry).getSize(NULL, TRIG_RULE_DATA_ARR) < 1) {
+               if ((entry->jentry).getSize(NULL, OLD_TRIG_RULE_KEY_DATA_ARR) < 1) {
                        return CONTEXT_TRIGGER_ERROR_INVALID_RULE;
                }
 
                ctx::Json elem;
-               for (int i = 0; (entry->jentry).getAt(NULL, TRIG_RULE_DATA_ARR, i, &elem); i++) {
-                       int val_arr_size = elem.getSize(NULL, TRIG_RULE_DATA_VALUE_ARR);
-                       int op_arr_size = elem.getSize(NULL, TRIG_RULE_DATA_VALUE_OPERATOR_ARR);
+               for (int i = 0; (entry->jentry).getAt(NULL, OLD_TRIG_RULE_KEY_DATA_ARR, i, &elem); i++) {
+                       int val_arr_size = elem.getSize(NULL, OLD_TRIG_RULE_KEY_DATA_VALUE_ARR);
+                       int op_arr_size = elem.getSize(NULL, OLD_TRIG_RULE_KEY_DATA_VALUE_OPERATOR_ARR);
 
                        // Err: Condition without comparison data
                        if (val_arr_size != op_arr_size || val_arr_size < 1 || op_arr_size < 1) {
@@ -313,7 +313,7 @@ SO_EXPORT int context_trigger_rule_add_entry(context_trigger_rule_h rule, contex
 
                        // If event is already added ....
                        std::string ename;
-                       ret = (rule->jrule).get(TRIG_RULE_DETAILS "." TRIG_RULE_EVENT, TRIG_RULE_EVENT_ITEM, &ename);
+                       ret = (rule->jrule).get(OLD_TRIG_RULE_KEY_DETAILS "." OLD_TRIG_RULE_KEY_EVENT, OLD_TRIG_RULE_KEY_EVENT_ITEM, &ename);
                        if (ret) {
                                // Err: Check referential information if exists
                                ret = ctx::rule_validator::check_referential_data(ename, entry->jref);
@@ -332,7 +332,7 @@ SO_EXPORT int context_trigger_rule_add_entry(context_trigger_rule_h rule, contex
                }
 
                ctx::Json temp = (entry->jentry).str();
-               ret = (rule->jrule).append(TRIG_RULE_DETAILS, TRIG_RULE_CONDITION, temp);
+               ret = (rule->jrule).append(OLD_TRIG_RULE_KEY_DETAILS, OLD_TRIG_RULE_KEY_CONDITION, temp);
        } else {
                // Entry is not created
                return CONTEXT_TRIGGER_ERROR_INVALID_PARAMETER;
@@ -371,7 +371,7 @@ SO_EXPORT int context_trigger_rule_set_action_app_control(context_trigger_rule_h
 
        // Err: if action arleady exists
        std::string type;
-       if ((rule->jrule).get(TRIG_RULE_DETAILS "." TRIG_RULE_ACTION, TRIG_RULE_ACTION_TYPE, &type)) {
+       if ((rule->jrule).get(OLD_TRIG_RULE_KEY_DETAILS "." OLD_TRIG_RULE_KEY_ACTION, OLD_TRIG_RULE_KEY_ACTION_TYPE, &type)) {
                return CONTEXT_TRIGGER_ERROR_INVALID_RULE;
        }
 
@@ -396,7 +396,7 @@ SO_EXPORT int context_trigger_rule_set_action_app_control(context_trigger_rule_h
        pkgmgrinfo_appinfo_destroy_appinfo(app_info);
 
        // Set action type
-       (rule->jrule).set(TRIG_RULE_DETAILS "." TRIG_RULE_ACTION, TRIG_RULE_ACTION_TYPE, TRIG_RULE_ACTION_TYPE_APP_CONTROL);
+       (rule->jrule).set(OLD_TRIG_RULE_KEY_DETAILS "." OLD_TRIG_RULE_KEY_ACTION, OLD_TRIG_RULE_KEY_ACTION_TYPE, OLD_TRIG_RULE_KEY_ACTION_TYPE_APP_CONTROL);
 
        // Set app control
        bundle* appctl_bundle = NULL;
@@ -409,7 +409,7 @@ SO_EXPORT int context_trigger_rule_set_action_app_control(context_trigger_rule_h
        IF_FAIL_RETURN_TAG(error == ERR_NONE, CONTEXT_TRIGGER_ERROR_INVALID_PARAMETER, _E, "Bundle encode failed");
 
        std::string appctl_str = reinterpret_cast<const char*>(appctl_raw);
-       (rule->jrule).set(TRIG_RULE_DETAILS "." TRIG_RULE_ACTION, TRIG_RULE_ACTION_APP_CONTROL, appctl_str);
+       (rule->jrule).set(OLD_TRIG_RULE_KEY_DETAILS "." OLD_TRIG_RULE_KEY_ACTION, OLD_TRIG_RULE_KEY_ACTION_APP_CONTROL, appctl_str);
 
        bundle_free_encoded_rawdata(&appctl_raw);
 
@@ -427,7 +427,7 @@ SO_EXPORT int context_trigger_rule_set_action_notification(context_trigger_rule_
 
        // if action arleady exists
        std::string type;
-       if ((rule->jrule).get(TRIG_RULE_DETAILS "." TRIG_RULE_ACTION, TRIG_RULE_ACTION_TYPE, &type)) {
+       if ((rule->jrule).get(OLD_TRIG_RULE_KEY_DETAILS "." OLD_TRIG_RULE_KEY_ACTION, OLD_TRIG_RULE_KEY_ACTION_TYPE, &type)) {
                return CONTEXT_TRIGGER_ERROR_INVALID_RULE;
        }
 
@@ -444,13 +444,13 @@ SO_EXPORT int context_trigger_rule_set_action_notification(context_trigger_rule_
        }
 
        // Set title, content
-       (rule->jrule).set(TRIG_RULE_DETAILS "." TRIG_RULE_ACTION, TRIG_RULE_ACTION_TYPE, TRIG_RULE_ACTION_TYPE_NOTIFICATION);
-       (rule->jrule).set(TRIG_RULE_DETAILS "." TRIG_RULE_ACTION, TRIG_RULE_ACTION_NOTI_TITLE, title);
-       (rule->jrule).set(TRIG_RULE_DETAILS "." TRIG_RULE_ACTION, TRIG_RULE_ACTION_NOTI_CONTENT, content);
+       (rule->jrule).set(OLD_TRIG_RULE_KEY_DETAILS "." OLD_TRIG_RULE_KEY_ACTION, OLD_TRIG_RULE_KEY_ACTION_TYPE, OLD_TRIG_RULE_KEY_ACTION_TYPE_NOTIFICATION);
+       (rule->jrule).set(OLD_TRIG_RULE_KEY_DETAILS "." OLD_TRIG_RULE_KEY_ACTION, OLD_TRIG_RULE_KEY_ACTION_NOTI_TITLE, title);
+       (rule->jrule).set(OLD_TRIG_RULE_KEY_DETAILS "." OLD_TRIG_RULE_KEY_ACTION, OLD_TRIG_RULE_KEY_ACTION_NOTI_CONTENT, content);
 
        // Set icon path
        if (icon_path) {
-               (rule->jrule).set(TRIG_RULE_DETAILS "." TRIG_RULE_ACTION, TRIG_RULE_ACTION_NOTI_ICON_PATH, icon_path);
+               (rule->jrule).set(OLD_TRIG_RULE_KEY_DETAILS "." OLD_TRIG_RULE_KEY_ACTION, OLD_TRIG_RULE_KEY_ACTION_NOTI_ICON_PATH, icon_path);
        }
 
        // Set app control
@@ -465,7 +465,7 @@ SO_EXPORT int context_trigger_rule_set_action_notification(context_trigger_rule_
                IF_FAIL_RETURN_TAG(error == ERR_NONE, CONTEXT_TRIGGER_ERROR_INVALID_PARAMETER, _E, "Bundle encode failed");
 
                std::string appctl_str = reinterpret_cast<const char*>(appctl_raw);
-               (rule->jrule).set(TRIG_RULE_DETAILS "." TRIG_RULE_ACTION, TRIG_RULE_ACTION_APP_CONTROL, appctl_str);
+               (rule->jrule).set(OLD_TRIG_RULE_KEY_DETAILS "." OLD_TRIG_RULE_KEY_ACTION, OLD_TRIG_RULE_KEY_ACTION_APP_CONTROL, appctl_str);
 
                bundle_free_encoded_rawdata(&appctl_raw);
        }
@@ -480,21 +480,21 @@ SO_EXPORT int context_trigger_rule_set_action_dbus_call(context_trigger_rule_h r
 
        /* if action arleady exists */
        std::string type;
-       if ((rule->jrule).get(TRIG_RULE_DETAILS "." TRIG_RULE_ACTION, TRIG_RULE_ACTION_TYPE, &type))
+       if ((rule->jrule).get(OLD_TRIG_RULE_KEY_DETAILS "." OLD_TRIG_RULE_KEY_ACTION, OLD_TRIG_RULE_KEY_ACTION_TYPE, &type))
                return CONTEXT_TRIGGER_ERROR_INVALID_RULE;
 
        /* Set action type */
-       (rule->jrule).set(TRIG_RULE_DETAILS "." TRIG_RULE_ACTION, TRIG_RULE_ACTION_TYPE, TRIG_RULE_ACTION_TYPE_DBUS_CALL);
+       (rule->jrule).set(OLD_TRIG_RULE_KEY_DETAILS "." OLD_TRIG_RULE_KEY_ACTION, OLD_TRIG_RULE_KEY_ACTION_TYPE, OLD_TRIG_RULE_KEY_ACTION_TYPE_DBUS_CALL);
 
        /* Set basic dbus method call info */
-       (rule->jrule).set(TRIG_RULE_DETAILS "." TRIG_RULE_ACTION, TRIG_RULE_ACTION_DBUS_NAME, bus_name);
-       (rule->jrule).set(TRIG_RULE_DETAILS "." TRIG_RULE_ACTION, TRIG_RULE_ACTION_DBUS_OBJECT, object_path);
-       (rule->jrule).set(TRIG_RULE_DETAILS "." TRIG_RULE_ACTION, TRIG_RULE_ACTION_DBUS_INTERFACE, interface_name);
-       (rule->jrule).set(TRIG_RULE_DETAILS "." TRIG_RULE_ACTION, TRIG_RULE_ACTION_DBUS_METHOD, method_name);
+       (rule->jrule).set(OLD_TRIG_RULE_KEY_DETAILS "." OLD_TRIG_RULE_KEY_ACTION, OLD_TRIG_RULE_KEY_ACTION_DBUS_NAME, bus_name);
+       (rule->jrule).set(OLD_TRIG_RULE_KEY_DETAILS "." OLD_TRIG_RULE_KEY_ACTION, OLD_TRIG_RULE_KEY_ACTION_DBUS_OBJECT, object_path);
+       (rule->jrule).set(OLD_TRIG_RULE_KEY_DETAILS "." OLD_TRIG_RULE_KEY_ACTION, OLD_TRIG_RULE_KEY_ACTION_DBUS_INTERFACE, interface_name);
+       (rule->jrule).set(OLD_TRIG_RULE_KEY_DETAILS "." OLD_TRIG_RULE_KEY_ACTION, OLD_TRIG_RULE_KEY_ACTION_DBUS_METHOD, method_name);
 
        /* Set the parameters */
        if (param)
-               (rule->jrule).set(TRIG_RULE_DETAILS "." TRIG_RULE_ACTION, TRIG_RULE_ACTION_DBUS_PARAMETER, param);
+               (rule->jrule).set(OLD_TRIG_RULE_KEY_DETAILS "." OLD_TRIG_RULE_KEY_ACTION, OLD_TRIG_RULE_KEY_ACTION_DBUS_PARAMETER, param);
 
        return CONTEXT_TRIGGER_ERROR_NONE;
 }
@@ -505,7 +505,7 @@ SO_EXPORT int context_trigger_rule_set_description(context_trigger_rule_h rule,
        _D("BEGIN");
        ASSERT_NOT_NULL(rule);
 
-       (rule->jrule).set(NULL, TRIG_RULE_DESCRIPTION, description);
+       (rule->jrule).set(NULL, OLD_TRIG_RULE_KEY_DESCRIPTION, description);
 
        return CONTEXT_TRIGGER_ERROR_NONE;
 }
@@ -517,7 +517,7 @@ SO_EXPORT int context_trigger_rule_get_description(context_trigger_rule_h rule,
        ASSERT_NOT_NULL(rule && description);
 
        std::string val;
-       (rule->jrule).get(NULL, TRIG_RULE_DESCRIPTION, &val);
+       (rule->jrule).get(NULL, OLD_TRIG_RULE_KEY_DESCRIPTION, &val);
 
        *description = strdup(val.c_str());
 
@@ -571,8 +571,8 @@ int context_trigger_rule_event_create_internal(const char* event_item, context_t
        IF_FAIL_RETURN_TAG(error == ERR_NONE, error, _E, "Failed to request template: %#x", error);
 
        *entry = new(std::nothrow) _context_trigger_rule_entry_h(TYPE_EVENT);
-       (*entry)->jentry.set(NULL, TRIG_RULE_EVENT_ITEM, event_item);
-       (*entry)->jentry.set(NULL, TRIG_RULE_EVENT_OPERATOR, logical_str);
+       (*entry)->jentry.set(NULL, OLD_TRIG_RULE_KEY_EVENT_ITEM, event_item);
+       (*entry)->jentry.set(NULL, OLD_TRIG_RULE_KEY_EVENT_OPERATOR, logical_str);
 
        return CONTEXT_TRIGGER_ERROR_NONE;
 }
@@ -646,8 +646,8 @@ int context_trigger_rule_condition_create_internal(const char* condition_item, c
        IF_FAIL_RETURN_TAG(error == ERR_NONE, error, _E, "Failed to request template: %#x", error);
 
        *entry = new(std::nothrow) _context_trigger_rule_entry_h(TYPE_CONDITION);
-       (*entry)->jentry.set(NULL, TRIG_RULE_CONDITION_ITEM, condition_item);
-       (*entry)->jentry.set(NULL, TRIG_RULE_CONDITION_OPERATOR, logical_str);
+       (*entry)->jentry.set(NULL, OLD_TRIG_RULE_KEY_CONDITION_ITEM, condition_item);
+       (*entry)->jentry.set(NULL, OLD_TRIG_RULE_KEY_CONDITION_OPERATOR, logical_str);
 
        return CONTEXT_TRIGGER_ERROR_NONE;
 }
@@ -693,13 +693,13 @@ SO_EXPORT int context_trigger_rule_entry_add_option_int(context_trigger_rule_ent
 
        bool ret = true;
        std::string name;
-       (entry->jentry).get(NULL, TRIG_RULE_CONDITION_ITEM, &name);
+       (entry->jentry).get(NULL, OLD_TRIG_RULE_KEY_CONDITION_ITEM, &name);
        ret = ctx::rule_validator::check_option_int(name, option_key, value);
        if (!ret) {
                return CONTEXT_TRIGGER_ERROR_INVALID_RULE;
        }
 
-       (entry->jentry).set(TRIG_RULE_CONDITION_OPTION, option_key, value);
+       (entry->jentry).set(OLD_TRIG_RULE_KEY_CONDITION_OPTION, option_key, value);
 
        return CONTEXT_TRIGGER_ERROR_NONE;
 }
@@ -711,13 +711,13 @@ SO_EXPORT int context_trigger_rule_entry_add_option_string(context_trigger_rule_
 
        bool ret = true;
        std::string name;
-       (entry->jentry).get(NULL, TRIG_RULE_CONDITION_ITEM, &name);
+       (entry->jentry).get(NULL, OLD_TRIG_RULE_KEY_CONDITION_ITEM, &name);
        ret = ctx::rule_validator::check_option_string(name, option_key, value);
        if (!ret) {
                return CONTEXT_TRIGGER_ERROR_INVALID_RULE;
        }
 
-       (entry->jentry).set(TRIG_RULE_CONDITION_OPTION, option_key, value);
+       (entry->jentry).set(OLD_TRIG_RULE_KEY_CONDITION_OPTION, option_key, value);
 
        return CONTEXT_TRIGGER_ERROR_NONE;
 }
@@ -733,7 +733,7 @@ SO_EXPORT int context_trigger_rule_entry_add_option(context_trigger_rule_entry_h
        }
 
        std::string name;
-       (entry->jentry).get(NULL, TRIG_RULE_CONDITION_ITEM, &name);
+       (entry->jentry).get(NULL, OLD_TRIG_RULE_KEY_CONDITION_ITEM, &name);
 
        // Err: Check if key is valid
        bool ret = ctx::rule_validator::check_valid_key(TYPE_OPTION, name, option_key);
@@ -743,7 +743,7 @@ SO_EXPORT int context_trigger_rule_entry_add_option(context_trigger_rule_entry_h
        ret = ctx::rule_validator::set_ref_info(TYPE_OPTION, &(entry->jref), name, option_key, event_data_key);
        IF_FAIL_RETURN(ret, CONTEXT_TRIGGER_ERROR_OPERATION_FAILED);
 
-       (entry->jentry).set(TRIG_RULE_CONDITION_OPTION, option_key, std::string(TRIG_RULE_REF_KEY_PREFIX) + std::string(event_data_key));
+       (entry->jentry).set(OLD_TRIG_RULE_KEY_CONDITION_OPTION, option_key, std::string(TRIG_RULE_REF_KEY_PREFIX) + std::string(event_data_key));
 
        return CONTEXT_TRIGGER_ERROR_NONE;
 }
@@ -760,14 +760,16 @@ SO_EXPORT int context_trigger_rule_entry_add_key(context_trigger_rule_entry_h en
 
        // Err: Check if key is valid
        std::string name;
-       (entry->jentry).get(NULL, TRIG_RULE_EVENT_ITEM, &name);
+       (entry->jentry).get(NULL, OLD_TRIG_RULE_KEY_EVENT_ITEM, &name);
+
        bool ret = ctx::rule_validator::check_valid_key(TYPE_ATTRIBUTE, name, key);
        IF_FAIL_RETURN(ret, CONTEXT_TRIGGER_ERROR_INVALID_RULE);
 
+       // Err: Comparison key is already added
        ctx::Json elem;
-       for (int i = 0; (entry->jentry).getAt(NULL, TRIG_RULE_DATA_ARR, i, &elem); i++) {
+       for (int i = 0; (entry->jentry).getAt(NULL, OLD_TRIG_RULE_KEY_DATA_ARR, i, &elem); i++) {
                std::string elem_item;
-               elem.get(NULL, TRIG_RULE_DATA_KEY, &elem_item);
+               elem.get(NULL, OLD_TRIG_RULE_KEY_DATA_KEY, &elem_item);
                // Err: Comparison key is already added
                if (elem_item.compare(key) == 0) {
                        return CONTEXT_TRIGGER_ERROR_INVALID_RULE;
@@ -775,9 +777,9 @@ SO_EXPORT int context_trigger_rule_entry_add_key(context_trigger_rule_entry_h en
        }
 
        ctx::Json data;
-       data.set(NULL, TRIG_RULE_DATA_KEY, key);
-       data.set(NULL, TRIG_RULE_DATA_KEY_OPERATOR, logical_str);
-       (entry->jentry).append(NULL, TRIG_RULE_DATA_ARR, data);
+       data.set(NULL, OLD_TRIG_RULE_KEY_DATA_KEY, key);
+       data.set(NULL, OLD_TRIG_RULE_KEY_DATA_KEY_OPERATOR, logical_str);
+       (entry->jentry).append(NULL, OLD_TRIG_RULE_KEY_DATA_ARR, data);
 
        return CONTEXT_TRIGGER_ERROR_NONE;
 }
@@ -785,24 +787,24 @@ SO_EXPORT int context_trigger_rule_entry_add_key(context_trigger_rule_entry_h en
 static int context_trigger_rule_entry_add_comparison_string_internal(context_trigger_rule_entry_h entry, const char* key, std::string op, std::string value)
 {
        ctx::Json elem;
-       for (int i = 0; (entry->jentry).getAt(NULL, TRIG_RULE_DATA_ARR, i, &elem); i++) {
+       for (int i = 0; (entry->jentry).getAt(NULL, OLD_TRIG_RULE_KEY_DATA_ARR, i, &elem); i++) {
                std::string elem_item;
-               elem.get(NULL, TRIG_RULE_DATA_KEY, &elem_item);
+               elem.get(NULL, OLD_TRIG_RULE_KEY_DATA_KEY, &elem_item);
 
                if (elem_item.compare(key) == 0) {
                        std::string elem_val;
                        std::string elem_op;
-                       for (int j = 0; elem.getAt(NULL, TRIG_RULE_DATA_VALUE_ARR, j, &elem_val); j++) {
-                               elem.getAt(NULL, TRIG_RULE_DATA_VALUE_OPERATOR_ARR, j, &elem_op);
+                       for (int j = 0; elem.getAt(NULL, OLD_TRIG_RULE_KEY_DATA_VALUE_ARR, j, &elem_val); j++) {
+                               elem.getAt(NULL, OLD_TRIG_RULE_KEY_DATA_VALUE_OPERATOR_ARR, j, &elem_op);
 
                                // Err: Duplicated <operator, value>
                                if (elem_val.compare(value) == 0 && elem_op.compare(op) == 0) {
                                        return CONTEXT_TRIGGER_ERROR_INVALID_RULE;
                                }
                        }
-                       elem.append(NULL, TRIG_RULE_DATA_VALUE_ARR, value.c_str());
-                       elem.append(NULL, TRIG_RULE_DATA_VALUE_OPERATOR_ARR, op);
-                       (entry->jentry).setAt(NULL, TRIG_RULE_DATA_ARR, i, elem);
+                       elem.append(NULL, OLD_TRIG_RULE_KEY_DATA_VALUE_ARR, value.c_str());
+                       elem.append(NULL, OLD_TRIG_RULE_KEY_DATA_VALUE_OPERATOR_ARR, op);
+                       (entry->jentry).setAt(NULL, OLD_TRIG_RULE_KEY_DATA_ARR, i, elem);
 
                        return CONTEXT_TRIGGER_ERROR_NONE;
                }
@@ -815,24 +817,24 @@ static int context_trigger_rule_entry_add_comparison_string_internal(context_tri
 static int context_trigger_rule_entry_add_comparison_int_internal(context_trigger_rule_entry_h entry, const char* key, std::string op, int value)
 {
        ctx::Json elem;
-       for (int i = 0; (entry->jentry).getAt(NULL, TRIG_RULE_DATA_ARR, i, &elem); i++) {
+       for (int i = 0; (entry->jentry).getAt(NULL, OLD_TRIG_RULE_KEY_DATA_ARR, i, &elem); i++) {
                std::string elem_item;
-               elem.get(NULL, TRIG_RULE_DATA_KEY, &elem_item);
+               elem.get(NULL, OLD_TRIG_RULE_KEY_DATA_KEY, &elem_item);
 
                if (elem_item.compare(key) == 0) {
                        int elem_val;
                        std::string elem_op;
-                       for (int j = 0; elem.getAt(NULL, TRIG_RULE_DATA_VALUE_ARR, j, &elem_val); j++) {
-                               elem.getAt(NULL, TRIG_RULE_DATA_VALUE_OPERATOR_ARR, j, &elem_op);
+                       for (int j = 0; elem.getAt(NULL, OLD_TRIG_RULE_KEY_DATA_VALUE_ARR, j, &elem_val); j++) {
+                               elem.getAt(NULL, OLD_TRIG_RULE_KEY_DATA_VALUE_OPERATOR_ARR, j, &elem_op);
 
                                // Err: Duplicated <operator, value>
                                if (elem_val == value && elem_op.compare(op) == 0) {
                                        return CONTEXT_TRIGGER_ERROR_INVALID_RULE;
                                }
                        }
-                       elem.append(NULL, TRIG_RULE_DATA_VALUE_ARR, value);
-                       elem.append(NULL, TRIG_RULE_DATA_VALUE_OPERATOR_ARR, op);
-                       (entry->jentry).setAt(NULL, TRIG_RULE_DATA_ARR, i, elem);
+                       elem.append(NULL, OLD_TRIG_RULE_KEY_DATA_VALUE_ARR, value);
+                       elem.append(NULL, OLD_TRIG_RULE_KEY_DATA_VALUE_OPERATOR_ARR, op);
+                       (entry->jentry).setAt(NULL, OLD_TRIG_RULE_KEY_DATA_ARR, i, elem);
 
                        return CONTEXT_TRIGGER_ERROR_NONE;
                }
@@ -853,7 +855,7 @@ SO_EXPORT int context_trigger_rule_entry_add_comparison(context_trigger_rule_ent
        }
 
        std::string name;
-       (entry->jentry).get(NULL, TRIG_RULE_CONDITION_ITEM, &name);
+       (entry->jentry).get(NULL, OLD_TRIG_RULE_KEY_CONDITION_ITEM, &name);
 
        // Err: Check if key is valid
        bool ret = ctx::rule_validator::check_valid_key(TYPE_ATTRIBUTE, name, key);
@@ -880,7 +882,7 @@ SO_EXPORT int context_trigger_rule_entry_add_comparison_int(context_trigger_rule
        ASSERT_NOT_NULL(entry && key && op);
 
        std::string name;
-       (entry->jentry).get(NULL, TRIG_RULE_EVENT_ITEM, &name);
+       (entry->jentry).get(NULL, OLD_TRIG_RULE_KEY_EVENT_ITEM, &name);
 
        bool ret = ctx::rule_validator::check_comparison_int(name, key, op, value);
        IF_FAIL_RETURN(ret, CONTEXT_TRIGGER_ERROR_INVALID_RULE);
@@ -895,7 +897,7 @@ SO_EXPORT int context_trigger_rule_entry_add_comparison_double(context_trigger_r
        ASSERT_NOT_NULL(entry && key && op);
 
        std::string name;
-       (entry->jentry).get(NULL, TRIG_RULE_EVENT_ITEM, &name);
+       (entry->jentry).get(NULL, OLD_TRIG_RULE_KEY_EVENT_ITEM, &name);
 
        // TODO: check_comparison_double()
        bool ret = ctx::rule_validator::check_comparison_double(name, key, op, value);
@@ -911,7 +913,7 @@ SO_EXPORT int context_trigger_rule_entry_add_comparison_string(context_trigger_r
        ASSERT_NOT_NULL(entry && key && op && value);
 
        std::string name;
-       (entry->jentry).get(NULL, TRIG_RULE_EVENT_ITEM, &name);
+       (entry->jentry).get(NULL, OLD_TRIG_RULE_KEY_EVENT_ITEM, &name);
 
        bool ret = ctx::rule_validator::check_comparison_string(name, key, op, value);
        IF_FAIL_RETURN(ret, CONTEXT_TRIGGER_ERROR_INVALID_RULE);
@@ -1099,10 +1101,10 @@ std::string convert_logical_type_to_string(context_trigger_logical_type_e logica
        std::string str;
        switch (logical_type) {
        case CONTEXT_TRIGGER_LOGICAL_CONJUNCTION:
-               str = TRIG_RULE_LOGICAL_CONJUNCTION;
+               str = OLD_TRIG_RULE_KEY_LOGICAL_CONJUNCTION;
                break;
        case CONTEXT_TRIGGER_LOGICAL_DISJUNCTION:
-               str = TRIG_RULE_LOGICAL_CONJUNCTION;
+               str = OLD_TRIG_RULE_KEY_LOGICAL_DISJUNCTION;
                break;
        default:
                break;

diff --git a/src/rule_validator.cpp b/src/rule_validator.cpp
index f2dd096..cdbb9eb 100644 (file)
--- a/src/rule_validator.cpp
+++ b/src/rule_validator.cpp
@@ -94,7 +94,7 @@ void ctx::rule_validator::remove_template(std::string name)
 bool ctx::rule_validator::check_option(ctx::Json& item)
 {
        std::string name;
-       item.get(NULL, TRIG_RULE_EVENT_ITEM, &name);
+       item.get(NULL, OLD_TRIG_RULE_KEY_EVENT_ITEM, &name);
 
        ctx::Json tmpl = get_template(name);
        IF_FAIL_RETURN(tmpl != EMPTY_JSON_OBJECT, false);
@@ -113,13 +113,13 @@ bool ctx::rule_validator::check_option(ctx::Json& item)
        std::string val_str;
        int val;
        if (name == SUBJ_PLACE_GEOFENCE) {
-               if (!(item.get(TRIG_RULE_EVENT_OPTION, CONTEXT_TRIGGER_PLACE_ID, &val)))
+               if (!(item.get(OLD_TRIG_RULE_KEY_EVENT_OPTION, CONTEXT_TRIGGER_PLACE_ID, &val)))
                        return false;
        } else if (name == SUBJ_APP_FREQUENCY) {
-               if (!(item.get(TRIG_RULE_CONDITION_OPTION, CONTEXT_TRIGGER_APP_ID, &val_str)))
+               if (!(item.get(OLD_TRIG_RULE_KEY_CONDITION_OPTION, CONTEXT_TRIGGER_APP_ID, &val_str)))
                        return false;
        } else if (name == SUBJ_SOCIAL_FREQUENCY) {
-               if (!(item.get(TRIG_RULE_CONDITION_OPTION, CONTEXT_TRIGGER_ADDRESS, &val_str)))
+               if (!(item.get(OLD_TRIG_RULE_KEY_CONDITION_OPTION, CONTEXT_TRIGGER_ADDRESS, &val_str)))
                        return false;
        }