Internal rule conversion

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

diff --git a/src/trigger/ActionManager.cpp b/src/trigger/ActionManager.cpp
index 34d1dc2..242a273 100644 (file)
--- a/src/trigger/ActionManager.cpp
+++ b/src/trigger/ActionManager.cpp
@@ -34,13 +34,13 @@ static void __triggerActionDbusCall(ctx::Json& action);
 void ctx::trigger::action_manager::triggerAction(ctx::Json& action, std::string pkgId)
 {
        std::string type;
-       action.get(NULL, TRIG_RULE_ACTION_TYPE, &type);
+       action.get(NULL, OLD_TRIG_RULE_KEY_ACTION_TYPE, &type);
 
-       if (type.compare(TRIG_RULE_ACTION_TYPE_APP_CONTROL) == 0) {
+       if (type.compare(OLD_TRIG_RULE_KEY_ACTION_TYPE_APP_CONTROL) == 0) {
                __triggerActionAppControl(action);
-       } else if (type.compare(TRIG_RULE_ACTION_TYPE_NOTIFICATION) == 0) {
+       } else if (type.compare(OLD_TRIG_RULE_KEY_ACTION_TYPE_NOTIFICATION) == 0) {
                __triggerActionNotification(action, pkgId);
-       } else if (type.compare(TRIG_RULE_ACTION_TYPE_DBUS_CALL) == 0) {
+       } else if (type.compare(OLD_TRIG_RULE_KEY_ACTION_TYPE_DBUS_CALL) == 0) {
                __triggerActionDbusCall(action);
        }
 }
@@ -49,7 +49,7 @@ void __triggerActionAppControl(ctx::Json& action)
 {
        int error;
        std::string appctlStr;
-       action.get(NULL, TRIG_RULE_ACTION_APP_CONTROL, &appctlStr);
+       action.get(NULL, OLD_TRIG_RULE_KEY_ACTION_APP_CONTROL, &appctlStr);
 
        char* str = static_cast<char*>(malloc(appctlStr.length()));
        if (str == NULL) {
@@ -85,7 +85,7 @@ void __triggerActionNotification(ctx::Json& action, std::string pkgId)
        int error;
        notification_h notification = notification_create(NOTIFICATION_TYPE_NOTI);
        std::string title;
-       if (action.get(NULL, TRIG_RULE_ACTION_NOTI_TITLE, &title)) {
+       if (action.get(NULL, OLD_TRIG_RULE_KEY_ACTION_NOTI_TITLE, &title)) {
                error = notification_set_text(notification, NOTIFICATION_TEXT_TYPE_TITLE, title.c_str(), NULL, NOTIFICATION_VARIABLE_TYPE_NONE);
                if (error != NOTIFICATION_ERROR_NONE) {
                        _E("Set notification title failed(%d)", error);
@@ -93,7 +93,7 @@ void __triggerActionNotification(ctx::Json& action, std::string pkgId)
        }
 
        std::string content;
-       if (action.get(NULL, TRIG_RULE_ACTION_NOTI_CONTENT, &content)) {
+       if (action.get(NULL, OLD_TRIG_RULE_KEY_ACTION_NOTI_CONTENT, &content)) {
                error = notification_set_text(notification, NOTIFICATION_TEXT_TYPE_CONTENT, content.c_str(), NULL, NOTIFICATION_VARIABLE_TYPE_NONE);
                if (error != NOTIFICATION_ERROR_NONE) {
                        _E("Set notification contents failed(%d)", error);
@@ -101,7 +101,7 @@ void __triggerActionNotification(ctx::Json& action, std::string pkgId)
        }
 
        std::string imagePath;
-       if (action.get(NULL, TRIG_RULE_ACTION_NOTI_ICON_PATH, &imagePath)) {
+       if (action.get(NULL, OLD_TRIG_RULE_KEY_ACTION_NOTI_ICON_PATH, &imagePath)) {
                error = notification_set_image(notification, NOTIFICATION_IMAGE_TYPE_ICON, imagePath.c_str());
                if (error != NOTIFICATION_ERROR_NONE) {
                        _E("Set notification icon image failed(%d)", error);
@@ -113,7 +113,7 @@ void __triggerActionNotification(ctx::Json& action, std::string pkgId)
        bundle_raw* encoded = NULL;
        bundle* appctlBundle = NULL;
        app_control_h app = NULL;
-       if (action.get(NULL, TRIG_RULE_ACTION_APP_CONTROL, &appctlStr)) {
+       if (action.get(NULL, OLD_TRIG_RULE_KEY_ACTION_APP_CONTROL, &appctlStr)) {
                str = static_cast<char*>(malloc(appctlStr.length()));
                if (str == NULL) {
                        _E("Memory allocation failed");
@@ -187,19 +187,19 @@ void __triggerActionDbusCall(ctx::Json& action)
        std::string busName, object, iface, method;
        GVariant *param = NULL;
 
-       action.get(NULL, TRIG_RULE_ACTION_DBUS_NAME, &busName);
+       action.get(NULL, OLD_TRIG_RULE_KEY_ACTION_DBUS_NAME, &busName);
        IF_FAIL_VOID_TAG(!busName.empty(), _E, "No target bus name");
 
-       action.get(NULL, TRIG_RULE_ACTION_DBUS_OBJECT, &object);
+       action.get(NULL, OLD_TRIG_RULE_KEY_ACTION_DBUS_OBJECT, &object);
        IF_FAIL_VOID_TAG(!object.empty(), _E, "No object path");
 
-       action.get(NULL, TRIG_RULE_ACTION_DBUS_INTERFACE, &iface);
+       action.get(NULL, OLD_TRIG_RULE_KEY_ACTION_DBUS_INTERFACE, &iface);
        IF_FAIL_VOID_TAG(!iface.empty(), _E, "No interface name");
 
-       action.get(NULL, TRIG_RULE_ACTION_DBUS_METHOD, &method);
+       action.get(NULL, OLD_TRIG_RULE_KEY_ACTION_DBUS_METHOD, &method);
        IF_FAIL_VOID_TAG(!method.empty(), _E, "No method name");
 
-       action.get(NULL, TRIG_RULE_ACTION_DBUS_PARAMETER, &param);
+       action.get(NULL, OLD_TRIG_RULE_KEY_ACTION_DBUS_PARAMETER, &param);
 
        ctx::DBusServer::call(busName, object, iface, method, param);
 }

diff --git a/src/trigger/Rule.cpp b/src/trigger/Rule.cpp
index abffa68..b09cba4 100644 (file)
--- a/src/trigger/Rule.cpp
+++ b/src/trigger/Rule.cpp
@@ -42,20 +42,20 @@ Rule::Rule(int i, Json& d, const char* p, RuleManager* rm) :
 
        // Event
        Json e;
-       d.get(NULL, TRIG_RULE_EVENT, &e);
+       d.get(NULL, OLD_TRIG_RULE_KEY_EVENT, &e);
        __event = new(std::nothrow) ContextItem(e);
 
        // Condition
-       int cond_num = d.getSize(NULL, TRIG_RULE_CONDITION);
+       int cond_num = d.getSize(NULL, OLD_TRIG_RULE_KEY_CONDITION);
        for (int j = 0; j < cond_num; j++) {
                Json c;
-               d.getAt(NULL, TRIG_RULE_CONDITION, j, &c);
+               d.getAt(NULL, OLD_TRIG_RULE_KEY_CONDITION, j, &c);
                __condition.push_back(new(std::nothrow) ContextItem(c));
        }
 
        // Action
        Json a;
-       d.get(NULL, TRIG_RULE_ACTION, &a);
+       d.get(NULL, OLD_TRIG_RULE_KEY_ACTION, &a);
        __action = a.str();
 }
 

diff --git a/src/trigger/Rule.h b/src/trigger/Rule.h
index bb90926..06475db 100644 (file)
--- a/src/trigger/Rule.h
+++ b/src/trigger/Rule.h
@@ -34,11 +34,11 @@ namespace trigger {
                                ctx::Json option;
                                ContextItem(ctx::Json item) {
                                        std::string n;
-                                       item.get(NULL, TRIG_RULE_EVENT_ITEM, &n);
+                                       item.get(NULL, OLD_TRIG_RULE_KEY_EVENT_ITEM, &n);
                                        name = n;
 
                                        ctx::Json o;
-                                       if (item.get(NULL, TRIG_RULE_EVENT_OPTION, &o))
+                                       if (item.get(NULL, OLD_TRIG_RULE_KEY_EVENT_OPTION, &o))
                                                option = o.str();
                                }
                        };

diff --git a/src/trigger/RuleEvaluator.cpp b/src/trigger/RuleEvaluator.cpp
index 1f85688..c4462b0 100644 (file)
--- a/src/trigger/RuleEvaluator.cpp
+++ b/src/trigger/RuleEvaluator.cpp
@@ -73,8 +73,8 @@ bool RuleEvaluator::__replaceDataReferences(Json& ruleDataArr, Json eventFactDat
        std::string eventRefStr;
        int eventRefInt;
 
-       for (int i = 0; i < ruleDataArr.getSize(NULL, TRIG_RULE_DATA_VALUE_ARR); i++) {
-               if (!ruleDataArr.getAt(NULL, TRIG_RULE_DATA_VALUE_ARR, i, &refVal)) {
+       for (int i = 0; i < ruleDataArr.getSize(NULL, OLD_TRIG_RULE_KEY_DATA_VALUE_ARR); i++) {
+               if (!ruleDataArr.getAt(NULL, OLD_TRIG_RULE_KEY_DATA_VALUE_ARR, i, &refVal)) {
                        continue;
                }
                if (refVal.substr(0, 1) != TRIG_RULE_REF_KEY_PREFIX) {
@@ -83,9 +83,9 @@ bool RuleEvaluator::__replaceDataReferences(Json& ruleDataArr, Json eventFactDat
 
                std::string eventKey = refVal.substr(1, refVal.length() - 1);
                if (eventFactData.get(NULL, eventKey.c_str(), &eventRefStr)) {
-                       ruleDataArr.setAt(NULL, TRIG_RULE_DATA_VALUE_ARR, i, eventRefStr);
+                       ruleDataArr.setAt(NULL, OLD_TRIG_RULE_KEY_DATA_VALUE_ARR, i, eventRefStr);
                } else if (eventFactData.get(NULL, eventKey.c_str(), &eventRefInt)) {
-                       ruleDataArr.setAt(NULL, TRIG_RULE_DATA_VALUE_ARR, i, eventRefInt);
+                       ruleDataArr.setAt(NULL, OLD_TRIG_RULE_KEY_DATA_VALUE_ARR, i, eventRefInt);
                } else {
                        _W("Option %s not found in event_data", eventKey.c_str());
                }
@@ -138,14 +138,14 @@ bool RuleEvaluator::__replaceEventReferences(Json& rule, Json& fact)
        }
 
        Json ruleCond;
-       for (int i = 0; rule.getAt(NULL, TRIG_RULE_CONDITION, i, &ruleCond); i++) {
+       for (int i = 0; rule.getAt(NULL, OLD_TRIG_RULE_KEY_CONDITION, i, &ruleCond); i++) {
                Json ruleDataArr;
-               for (int j = 0; ruleCond.getAt(NULL, TRIG_RULE_DATA_ARR, j, &ruleDataArr); j++) {
+               for (int j = 0; ruleCond.getAt(NULL, OLD_TRIG_RULE_KEY_DATA_ARR, j, &ruleDataArr); j++) {
                        __replaceDataReferences(ruleDataArr, eventFactData);
                }
 
                Json ruleOption;
-               if (ruleCond.get(NULL, TRIG_RULE_CONDITION_OPTION, &ruleOption)) {
+               if (ruleCond.get(NULL, OLD_TRIG_RULE_KEY_CONDITION_OPTION, &ruleOption)) {
                        __replaceOptionReferences(ruleOption, eventFactData);
                }
        }
@@ -156,14 +156,14 @@ bool RuleEvaluator::__replaceEventReferences(Json& rule, Json& fact)
 bool RuleEvaluator::__evaluateDataString(Json& ruleDataArr, std::string factValStr)
 {
        std::string opVal;
-       ruleDataArr.get(NULL, TRIG_RULE_DATA_KEY_OPERATOR, &opVal);
-       bool conjunction = (TRIG_RULE_LOGICAL_CONJUNCTION == opVal);
+       ruleDataArr.get(NULL, OLD_TRIG_RULE_KEY_DATA_KEY_OPERATOR, &opVal);
+       bool conjunction = (OLD_TRIG_RULE_KEY_LOGICAL_CONJUNCTION == opVal);
 
        std::string op;
-       for (int i = 0; ruleDataArr.getAt(NULL, TRIG_RULE_DATA_VALUE_OPERATOR_ARR, i, &op); i++) {
+       for (int i = 0; ruleDataArr.getAt(NULL, OLD_TRIG_RULE_KEY_DATA_VALUE_OPERATOR_ARR, i, &op); i++) {
                bool result;
                std::string valStr;
-               ruleDataArr.getAt(NULL, TRIG_RULE_DATA_VALUE_ARR, i, &valStr);
+               ruleDataArr.getAt(NULL, OLD_TRIG_RULE_KEY_DATA_VALUE_ARR, i, &valStr);
                result = __compareString(op, factValStr, valStr);
 
                if (conjunction && !result) {
@@ -178,14 +178,14 @@ bool RuleEvaluator::__evaluateDataString(Json& ruleDataArr, std::string factValS
 bool RuleEvaluator::__evaluateDataInt(Json& ruleDataArr, int factValInt)
 {
        std::string opVal;
-       ruleDataArr.get(NULL, TRIG_RULE_DATA_KEY_OPERATOR, &opVal);
-       bool conjunction = (TRIG_RULE_LOGICAL_CONJUNCTION == opVal);
+       ruleDataArr.get(NULL, OLD_TRIG_RULE_KEY_DATA_KEY_OPERATOR, &opVal);
+       bool conjunction = (OLD_TRIG_RULE_KEY_LOGICAL_CONJUNCTION == opVal);
 
        std::string op;
-       for (int i = 0; ruleDataArr.getAt(NULL, TRIG_RULE_DATA_VALUE_OPERATOR_ARR, i, &op); i++) {
+       for (int i = 0; ruleDataArr.getAt(NULL, OLD_TRIG_RULE_KEY_DATA_VALUE_OPERATOR_ARR, i, &op); i++) {
                bool result;
                int valInt;
-               if (!ruleDataArr.getAt(NULL, TRIG_RULE_DATA_VALUE_ARR, i, &valInt)) {
+               if (!ruleDataArr.getAt(NULL, OLD_TRIG_RULE_KEY_DATA_VALUE_ARR, i, &valInt)) {
                        result = false;
                }
                result = __compareInt(op, factValInt, valInt);
@@ -202,17 +202,17 @@ bool RuleEvaluator::__evaluateDataInt(Json& ruleDataArr, int factValInt)
 bool RuleEvaluator::__evaluateItem(Json& ruleItem, Json& factItem)
 {
        Json ruleDataArr;
-       if (ruleItem.getSize(NULL, TRIG_RULE_DATA_ARR) == 0) {
+       if (ruleItem.getSize(NULL, OLD_TRIG_RULE_KEY_DATA_ARR) == 0) {
                return true;
        }
 
        std::string opKey;
-       ruleItem.get(NULL, TRIG_RULE_CONDITION_OPERATOR, &opKey);
-       bool conjunction = (TRIG_RULE_LOGICAL_CONJUNCTION == opKey);
+       ruleItem.get(NULL, OLD_TRIG_RULE_KEY_CONDITION_OPERATOR, &opKey);
+       bool conjunction = (OLD_TRIG_RULE_KEY_LOGICAL_CONJUNCTION == opKey);
 
-       for (int i = 0; ruleItem.getAt(NULL, TRIG_RULE_DATA_ARR, i, &ruleDataArr); i++) {
+       for (int i = 0; ruleItem.getAt(NULL, OLD_TRIG_RULE_KEY_DATA_ARR, i, &ruleDataArr); i++) {
                std::string dataKey;
-               ruleDataArr.get(NULL, TRIG_RULE_DATA_KEY, &dataKey);
+               ruleDataArr.get(NULL, OLD_TRIG_RULE_KEY_DATA_KEY, &dataKey);
                std::string factValStr;
                int factValInt;
 
@@ -240,7 +240,7 @@ bool RuleEvaluator::__evaluateRuleEvent(Json& rule, Json& fact)
        Json factItem;
        Json ruleItem;
        fact.get(NULL, FACT_KEY_EVENT, &factItem);
-       rule.get(NULL, TRIG_RULE_EVENT, &ruleItem);
+       rule.get(NULL, OLD_TRIG_RULE_KEY_EVENT, &ruleItem);
 
        return __evaluateItem(ruleItem, factItem);
 }
@@ -248,7 +248,7 @@ bool RuleEvaluator::__evaluateRuleEvent(Json& rule, Json& fact)
 Json RuleEvaluator::__getConditionFact(Json& ruleCond, Json& fact)
 {
        std::string ruleCondName;
-       ruleCond.get(NULL, TRIG_RULE_CONDITION_ITEM, &ruleCondName);
+       ruleCond.get(NULL, OLD_TRIG_RULE_KEY_CONDITION_ITEM, &ruleCondName);
 
        Json factCond;
        for (int i = 0; fact.getAt(NULL, FACT_KEY_CONDITION, i, &factCond); i++) {
@@ -262,7 +262,7 @@ Json RuleEvaluator::__getConditionFact(Json& ruleCond, Json& fact)
                // Check if fact item option is mathced with condition
                Json ruleCondOption;
                Json factCondOption;
-               ruleCond.get(NULL, TRIG_RULE_CONDITION_OPTION, &ruleCondOption);
+               ruleCond.get(NULL, OLD_TRIG_RULE_KEY_CONDITION_OPTION, &ruleCondOption);
                factCond.get(NULL, FACT_KEY_OPTION, &factCondOption);
                if (factCondOption == ruleCondOption) {
                        return factCond;
@@ -279,10 +279,10 @@ bool RuleEvaluator::__evaluateRuleCondition(Json& rule, Json& fact)
        Json factCond;
 
        std::string opCond;
-       rule.get(NULL, TRIG_RULE_OPERATOR, &opCond);
-       bool conjunction = (TRIG_RULE_LOGICAL_CONJUNCTION == opCond);
+       rule.get(NULL, OLD_TRIG_RULE_KEY_OPERATOR, &opCond);
+       bool conjunction = (OLD_TRIG_RULE_KEY_LOGICAL_CONJUNCTION == opCond);
 
-       for (int i = 0; rule.getAt(NULL, TRIG_RULE_CONDITION, i, &ruleCond); i++) {
+       for (int i = 0; rule.getAt(NULL, OLD_TRIG_RULE_KEY_CONDITION, i, &ruleCond); i++) {
                factCond = __getConditionFact(ruleCond, fact);
                bool result;
                if (factCond == EMPTY_JSON_OBJECT) {
@@ -309,7 +309,7 @@ bool RuleEvaluator::evaluateRule(Json rule, Json fact)
        RuleEvaluator eval;
        bool ret;
        Json tempJson;
-       if (fact.get(NULL, TRIG_RULE_CONDITION, &tempJson)) {
+       if (fact.get(NULL, OLD_TRIG_RULE_KEY_CONDITION, &tempJson)) {
                Json ruleCopy(rule.str());
                if (!eval.__replaceEventReferences(ruleCopy, fact)) {
                        _W("Replace failed");

diff --git a/src/trigger/RuleManager.cpp b/src/trigger/RuleManager.cpp
index 8b4cca7..33ac666 100644 (file)
--- a/src/trigger/RuleManager.cpp
+++ b/src/trigger/RuleManager.cpp
@@ -280,23 +280,23 @@ bool RuleManager::__reenableRule(void)
 bool RuleManager::__ruleDataArrElemEquals(Json& lElem, Json& rElem)
 {
        std::string lKey, rKey;
-       lElem.get(NULL, TRIG_RULE_DATA_KEY, &lKey);
-       rElem.get(NULL, TRIG_RULE_DATA_KEY, &rKey);
+       lElem.get(NULL, OLD_TRIG_RULE_KEY_DATA_KEY, &lKey);
+       rElem.get(NULL, OLD_TRIG_RULE_KEY_DATA_KEY, &rKey);
        if (lKey.compare(rKey))
                return false;
 
        int lValCnt, rValCnt, lValOpCnt, rValOpCnt;
-       lValCnt = lElem.getSize(NULL, TRIG_RULE_DATA_VALUE_ARR);
-       rValCnt = rElem.getSize(NULL, TRIG_RULE_DATA_VALUE_ARR);
-       lValOpCnt = lElem.getSize(NULL, TRIG_RULE_DATA_VALUE_OPERATOR_ARR);
-       rValOpCnt = rElem.getSize(NULL, TRIG_RULE_DATA_VALUE_OPERATOR_ARR);
+       lValCnt = lElem.getSize(NULL, OLD_TRIG_RULE_KEY_DATA_VALUE_ARR);
+       rValCnt = rElem.getSize(NULL, OLD_TRIG_RULE_KEY_DATA_VALUE_ARR);
+       lValOpCnt = lElem.getSize(NULL, OLD_TRIG_RULE_KEY_DATA_VALUE_OPERATOR_ARR);
+       rValOpCnt = rElem.getSize(NULL, OLD_TRIG_RULE_KEY_DATA_VALUE_OPERATOR_ARR);
        if (!((lValCnt == rValCnt) && (lValCnt == lValOpCnt) && (lValCnt && rValOpCnt)))
                return false;
 
        if (lValCnt > 1) {
                std::string lOp, rOp;
-               lElem.get(NULL, TRIG_RULE_DATA_KEY_OPERATOR, &lOp);
-               rElem.get(NULL, TRIG_RULE_DATA_KEY_OPERATOR, &rOp);
+               lElem.get(NULL, OLD_TRIG_RULE_KEY_DATA_KEY_OPERATOR, &lOp);
+               rElem.get(NULL, OLD_TRIG_RULE_KEY_DATA_KEY_OPERATOR, &rOp);
                if (lOp.compare(rOp))
                        return false;
        }
@@ -304,13 +304,13 @@ bool RuleManager::__ruleDataArrElemEquals(Json& lElem, Json& rElem)
        for (int i = 0; i < lValCnt; i++) {
                bool found = false;
                std::string lVal, lValOp;
-               lElem.getAt(NULL, TRIG_RULE_DATA_VALUE_ARR, i, &lVal);
-               lElem.getAt(NULL, TRIG_RULE_DATA_VALUE_OPERATOR_ARR, i, &lValOp);
+               lElem.getAt(NULL, OLD_TRIG_RULE_KEY_DATA_VALUE_ARR, i, &lVal);
+               lElem.getAt(NULL, OLD_TRIG_RULE_KEY_DATA_VALUE_OPERATOR_ARR, i, &lValOp);
 
                for (int j = 0; j < lValCnt; j++) {
                        std::string rVal, rValOp;
-                       rElem.getAt(NULL, TRIG_RULE_DATA_VALUE_ARR, j, &rVal);
-                       rElem.getAt(NULL, TRIG_RULE_DATA_VALUE_OPERATOR_ARR, j, &rValOp);
+                       rElem.getAt(NULL, OLD_TRIG_RULE_KEY_DATA_VALUE_ARR, j, &rVal);
+                       rElem.getAt(NULL, OLD_TRIG_RULE_KEY_DATA_VALUE_OPERATOR_ARR, j, &rValOp);
 
                        if (!lVal.compare(rVal) && !lValOp.compare(rValOp)) {
                                found = true;
@@ -328,29 +328,29 @@ bool RuleManager::__ruleItemEquals(Json& lItem, Json& rItem)
 {
        // Compare item name
        std::string lItemName, rItemName;
-       lItem.get(NULL, TRIG_RULE_EVENT_ITEM, &lItemName);
-       rItem.get(NULL, TRIG_RULE_EVENT_ITEM, &rItemName);
+       lItem.get(NULL, OLD_TRIG_RULE_KEY_EVENT_ITEM, &lItemName);
+       rItem.get(NULL, OLD_TRIG_RULE_KEY_EVENT_ITEM, &rItemName);
        if (lItemName.compare(rItemName))
                return false;
 
        // Compare option
        Json lOption, rOption;
-       lItem.get(NULL, TRIG_RULE_EVENT_OPTION, &lOption);
-       rItem.get(NULL, TRIG_RULE_EVENT_OPTION, &rOption);
+       lItem.get(NULL, OLD_TRIG_RULE_KEY_EVENT_OPTION, &lOption);
+       rItem.get(NULL, OLD_TRIG_RULE_KEY_EVENT_OPTION, &rOption);
        if (lOption != rOption)
                return false;
 
        int lDataArrCnt, rDataArrCnt;
-       lDataArrCnt = lItem.getSize(NULL, TRIG_RULE_DATA_ARR);
-       rDataArrCnt = rItem.getSize(NULL, TRIG_RULE_DATA_ARR);
+       lDataArrCnt = lItem.getSize(NULL, OLD_TRIG_RULE_KEY_DATA_ARR);
+       rDataArrCnt = rItem.getSize(NULL, OLD_TRIG_RULE_KEY_DATA_ARR);
        if (lDataArrCnt != rDataArrCnt)
                return false;
 
        // Compare item operator;
        if (lDataArrCnt > 1) {
                std::string lOp, rOp;
-               lItem.get(NULL, TRIG_RULE_EVENT_OPERATOR, &lOp);
-               rItem.get(NULL, TRIG_RULE_EVENT_OPERATOR, &rOp);
+               lItem.get(NULL, OLD_TRIG_RULE_KEY_EVENT_OPERATOR, &lOp);
+               rItem.get(NULL, OLD_TRIG_RULE_KEY_EVENT_OPERATOR, &rOp);
                if (lOp.compare(rOp))
                        return false;
        }
@@ -358,11 +358,11 @@ bool RuleManager::__ruleItemEquals(Json& lItem, Json& rItem)
        for (int i = 0; i < lDataArrCnt; i++) {
                bool found = false;
                Json lElem;
-               lItem.getAt(NULL, TRIG_RULE_DATA_ARR, i, &lElem);
+               lItem.getAt(NULL, OLD_TRIG_RULE_KEY_DATA_ARR, i, &lElem);
 
                for (int j = 0; j < lDataArrCnt; j++) {
                        Json rElem;
-                       rItem.getAt(NULL, TRIG_RULE_DATA_ARR, j, &rElem);
+                       rItem.getAt(NULL, OLD_TRIG_RULE_KEY_DATA_ARR, j, &rElem);
 
                        if (__ruleDataArrElemEquals(lElem, rElem)) {
                                found = true;
@@ -380,22 +380,22 @@ bool RuleManager::__ruleEquals(Json& lRule, Json& rRule)
 {
        // Compare event
        Json lEvent, rEvent;
-       lRule.get(NULL, TRIG_RULE_EVENT, &lEvent);
-       rRule.get(NULL, TRIG_RULE_EVENT, &rEvent);
+       lRule.get(NULL, OLD_TRIG_RULE_KEY_EVENT, &lEvent);
+       rRule.get(NULL, OLD_TRIG_RULE_KEY_EVENT, &rEvent);
        if (!__ruleItemEquals(lEvent, rEvent))
                return false;
 
        // Compare conditions
        int lCondCnt, rCondCnt;
-       lCondCnt = lRule.getSize(NULL, TRIG_RULE_CONDITION);
-       rCondCnt = rRule.getSize(NULL, TRIG_RULE_CONDITION);
+       lCondCnt = lRule.getSize(NULL, OLD_TRIG_RULE_KEY_CONDITION);
+       rCondCnt = rRule.getSize(NULL, OLD_TRIG_RULE_KEY_CONDITION);
        if (lCondCnt != rCondCnt)
                return false;
 
        if (lCondCnt > 1) {
                std::string lOp, rOp;
-               lRule.get(NULL, TRIG_RULE_OPERATOR, &lOp);
-               rRule.get(NULL, TRIG_RULE_OPERATOR, &rOp);
+               lRule.get(NULL, OLD_TRIG_RULE_KEY_OPERATOR, &lOp);
+               rRule.get(NULL, OLD_TRIG_RULE_KEY_OPERATOR, &rOp);
                if (lOp.compare(rOp))
                        return false;
        }
@@ -403,11 +403,11 @@ bool RuleManager::__ruleEquals(Json& lRule, Json& rRule)
        for (int i = 0; i < lCondCnt; i++) {
                bool found = false;
                Json lCond;
-               lRule.getAt(NULL, TRIG_RULE_CONDITION, i, &lCond);
+               lRule.getAt(NULL, OLD_TRIG_RULE_KEY_CONDITION, i, &lCond);
 
                for (int j = 0; j < lCondCnt; j++) {
                        Json rCond;
-                       rRule.getAt(NULL, TRIG_RULE_CONDITION, j, &rCond);
+                       rRule.getAt(NULL, OLD_TRIG_RULE_KEY_CONDITION, j, &rCond);
 
                        if (__ruleItemEquals(lCond, rCond)) {
                                found = true;
@@ -420,8 +420,8 @@ bool RuleManager::__ruleEquals(Json& lRule, Json& rRule)
 
        // Compare action
        Json lAction, rAction;
-       lRule.get(NULL, TRIG_RULE_ACTION, &lAction);
-       rRule.get(NULL, TRIG_RULE_ACTION, &rAction);
+       lRule.get(NULL, OLD_TRIG_RULE_KEY_ACTION, &lAction);
+       rRule.get(NULL, OLD_TRIG_RULE_KEY_ACTION, &rAction);
        if (lAction != rAction)
                return false;
 
@@ -439,9 +439,9 @@ int64_t RuleManager::__getDuplicatedRuleId(std::string pkgId, Json& rule)
        IF_FAIL_RETURN_TAG(ret, false, _E, "Query rowId, details by package id failed");
 
        Json rDetails;
-       rule.get(NULL, TRIG_RULE_DETAILS, &rDetails);
+       rule.get(NULL, OLD_TRIG_RULE_KEY_DETAILS, &rDetails);
        std::string rDesc;
-       rule.get(NULL, TRIG_RULE_DESCRIPTION, &rDesc);
+       rule.get(NULL, OLD_TRIG_RULE_KEY_DESCRIPTION, &rDesc);
        std::vector<Json>::iterator vecEnd = record.end();
 
        for (std::vector<Json>::iterator vecPos = record.begin(); vecPos != vecEnd; ++vecPos) {
@@ -482,10 +482,10 @@ int64_t RuleManager::__getDuplicatedRuleId(std::string pkgId, Json& rule)
 int RuleManager::__verifyRule(Json& rule, const char* creator)
 {
        Json details;
-       rule.get(NULL, TRIG_RULE_DETAILS, &details);
+       rule.get(NULL, OLD_TRIG_RULE_KEY_DETAILS, &details);
 
        std::string eventName;
-       rule.get(TRIG_RULE_DETAILS "." TRIG_RULE_EVENT, TRIG_RULE_EVENT_ITEM, &eventName);
+       rule.get(OLD_TRIG_RULE_KEY_DETAILS "." OLD_TRIG_RULE_KEY_EVENT, OLD_TRIG_RULE_KEY_EVENT_ITEM, &eventName);
 
        ContextMonitor* ctxMonitor = ContextMonitor::getInstance();
        IF_FAIL_RETURN_TAG(ctxMonitor, ERR_OUT_OF_MEMORY, _E, "Memory allocation failed");
@@ -500,9 +500,9 @@ int RuleManager::__verifyRule(Json& rule, const char* creator)
        }
 
        Json it;
-       for (int i = 0; rule.getAt(TRIG_RULE_DETAILS, TRIG_RULE_CONDITION, i, &it); i++) {
+       for (int i = 0; rule.getAt(OLD_TRIG_RULE_KEY_DETAILS, OLD_TRIG_RULE_KEY_CONDITION, i, &it); i++) {
                std::string condName;
-               it.get(NULL, TRIG_RULE_CONDITION_ITEM, &condName);
+               it.get(NULL, OLD_TRIG_RULE_KEY_CONDITION_ITEM, &condName);
 
                IF_FAIL_RETURN_TAG(ctxMonitor->isSupported(condName), ERR_NOT_SUPPORTED, _I, "Condition(%s) is not supported", condName.c_str());
 
@@ -536,8 +536,8 @@ int RuleManager::addRule(std::string creator, const char* pkgId, Json rule, Json
        Json record;
        std::string description;
        Json details;
-       rule.get(NULL, TRIG_RULE_DESCRIPTION, &description);
-       rule.get(NULL, TRIG_RULE_DETAILS, &details);
+       rule.get(NULL, OLD_TRIG_RULE_KEY_DESCRIPTION, &description);
+       rule.get(NULL, OLD_TRIG_RULE_KEY_DETAILS, &details);
        record.set(NULL, "creator", creator);
        if (pkgId) {
                record.set(NULL, "packageId", pkgId);
@@ -747,7 +747,7 @@ int RuleManager::getRuleById(std::string pkgId, int ruleId, Json* requestResult)
        record[0].get(NULL, "description", &description);
 
        (*requestResult).set(NULL, TRIG_KEY_RULE_ID, ruleId);
-       (*requestResult).set(NULL, TRIG_RULE_DESCRIPTION, description);
+       (*requestResult).set(NULL, OLD_TRIG_RULE_KEY_DESCRIPTION, description);
 
        return ERR_NONE;
 }

diff --git a/src/trigger/Timer.cpp b/src/trigger/Timer.cpp
index 33f4721..f82dfa8 100644 (file)
--- a/src/trigger/Timer.cpp
+++ b/src/trigger/Timer.cpp
@@ -29,7 +29,7 @@ static int __arrangeDayOfWeek(Json dayInfo)
        int result = 0;
 
        std::string key_op;
-       if (!dayInfo.get(NULL, TRIG_RULE_DATA_KEY_OPERATOR, &key_op)) {
+       if (!dayInfo.get(NULL, OLD_TRIG_RULE_KEY_DATA_KEY_OPERATOR, &key_op)) {
                result = TimerManager::dowToInt(DOW_EVERYDAY);
                return result;
        }
@@ -39,10 +39,10 @@ static int __arrangeDayOfWeek(Json dayInfo)
        }
 
        std::string tmp_d;
-       for (int i = 0; dayInfo.getAt(NULL, TRIG_RULE_DATA_VALUE_ARR, i, &tmp_d); i++) {
+       for (int i = 0; dayInfo.getAt(NULL, OLD_TRIG_RULE_KEY_DATA_VALUE_ARR, i, &tmp_d); i++) {
                int dow = TimerManager::dowToInt(tmp_d);
                std::string op;
-               dayInfo.getAt(NULL, TRIG_RULE_DATA_VALUE_OPERATOR_ARR, i, &op);
+               dayInfo.getAt(NULL, OLD_TRIG_RULE_KEY_DATA_VALUE_OPERATOR_ARR, i, &op);
 
                if (op.compare(CONTEXT_TRIGGER_NOT_EQUAL_TO) == 0) {
                        dow = TimerManager::dowToInt(DOW_EVERYDAY) & ~dow;
@@ -62,10 +62,10 @@ static int __arrangeDayOfWeek(Json dayInfo)
 void timer::handleTimerEvent(Json& rule)
 {
        Json event;
-       rule.get(NULL, TRIG_RULE_EVENT, &event);
+       rule.get(NULL, OLD_TRIG_RULE_KEY_EVENT, &event);
 
        std::string eventName;
-       event.get(NULL, TRIG_RULE_EVENT_ITEM, &eventName);
+       event.get(NULL, OLD_TRIG_RULE_KEY_EVENT_ITEM, &eventName);
        if (eventName.compare(SUBJ_STATE_ALARM) != 0) {
                return;
        }
@@ -73,35 +73,35 @@ void timer::handleTimerEvent(Json& rule)
        Json dayInfo;
        Json it;
        int dow;
-       for (int i = 0; event.getAt(NULL, TRIG_RULE_DATA_ARR, i, &it); i++) {
+       for (int i = 0; event.getAt(NULL, OLD_TRIG_RULE_KEY_DATA_ARR, i, &it); i++) {
                std::string key;
-               it.get(NULL, TRIG_RULE_DATA_KEY, &key);
+               it.get(NULL, OLD_TRIG_RULE_KEY_DATA_KEY, &key);
 
                if (key.compare(KEY_DAY_OF_WEEK) == 0) {
                        dow = __arrangeDayOfWeek(it);
 
-                       dayInfo.set(NULL, TRIG_RULE_DATA_KEY, KEY_DAY_OF_WEEK);
-                       dayInfo.set(NULL, TRIG_RULE_DATA_KEY_OPERATOR, "or");
+                       dayInfo.set(NULL, OLD_TRIG_RULE_KEY_DATA_KEY, KEY_DAY_OF_WEEK);
+                       dayInfo.set(NULL, OLD_TRIG_RULE_KEY_DATA_KEY_OPERATOR, "or");
 
                        for (int j = 0; j < DAYS_PER_WEEK; j++) {
                                int d = 0x01 << j;
                                if (dow & d) {
                                        std::string day = TimerManager::dowToStr(d);
-                                       dayInfo.append(NULL, TRIG_RULE_DATA_VALUE_ARR, day);
-                                       dayInfo.append(NULL, TRIG_RULE_DATA_VALUE_OPERATOR_ARR, CONTEXT_TRIGGER_EQUAL_TO);
+                                       dayInfo.append(NULL, OLD_TRIG_RULE_KEY_DATA_VALUE_ARR, day);
+                                       dayInfo.append(NULL, OLD_TRIG_RULE_KEY_DATA_VALUE_OPERATOR_ARR, CONTEXT_TRIGGER_EQUAL_TO);
 
                                        // Set option
-                                       event.append(TRIG_RULE_EVENT_OPTION, KEY_DAY_OF_WEEK, day);
+                                       event.append(OLD_TRIG_RULE_KEY_EVENT_OPTION, KEY_DAY_OF_WEEK, day);
                                }
                        }
-                       event.setAt(NULL, TRIG_RULE_DATA_ARR, i, dayInfo);
+                       event.setAt(NULL, OLD_TRIG_RULE_KEY_DATA_ARR, i, dayInfo);
                } else if (key.compare(KEY_TIME_OF_DAY) == 0) {
                        int time;
-                       for (int j = 0; it.getAt(NULL, TRIG_RULE_DATA_VALUE_ARR, j, &time); j++) {
-                               event.append(TRIG_RULE_EVENT_OPTION, KEY_TIME_OF_DAY, time);
+                       for (int j = 0; it.getAt(NULL, OLD_TRIG_RULE_KEY_DATA_VALUE_ARR, j, &time); j++) {
+                               event.append(OLD_TRIG_RULE_KEY_EVENT_OPTION, KEY_TIME_OF_DAY, time);
                        }
                }
        }
 
-       rule.set(NULL, TRIG_RULE_EVENT, event);
+       rule.set(NULL, OLD_TRIG_RULE_KEY_EVENT, event);
 }