@ind-rcg/backend 246.1008.0

package/nativeSrc/common/LogAdapter/LogAdapter.cpp

@@ -0,0 +1,25 @@
+/*
+ * FILE_HEADER
+ */
+
+#include "../stdngm.h"
+#include "LogAdapter.h"
+#include "../Utils/StringFormat.h"
+
+static std::vector<std::string> logMessages;
+
+void LogAdapter::Console(const char *text)
+{
+  logMessages.push_back(text);
+}
+
+std::vector<std::string> LogAdapter::getInternalLogLines()
+{
+    std::vector<std::string>logs = logMessages;
+    logMessages.clear();
+    return logs;
+}
+
+bool LogAdapter::logConsole() { return true; }
+bool LogAdapter::logDebug() { return true; }
+bool LogAdapter::logPerformance() { return true; }

package/nativeSrc/common/LogAdapter/LogAdapter.h

@@ -0,0 +1,20 @@
+/*
+ * FILE_HEADER
+ */
+
+#ifndef NGM_LOG_ADAPTER_H
+#define NGM_LOG_ADAPTER_H
+
+#include "../stdngm.h"
+
+class LogAdapter {
+    public:
+        static void Console(const char *text);
+        static std::vector<std::string> getInternalLogLines();
+        
+        // same function getting used in mobile side
+        static bool logConsole();
+        static bool logDebug();
+        static bool logPerformance();
+};
+#endif

package/nativeSrc/common/PriceEngine/PriceEngine.cpp

@@ -0,0 +1,251 @@
+//
+//  PriceEngine.cpp
+//  NGM
+//
+//  Created by Yanbo on 29/05/14.
+/*
+ * FILE_HEADER
+ */
+
+#include "PriceEngine.h"
+#include "../Utils/miniz/timer.h"
+#include "../Utils/StringFormat.h"
+#include "../LogAdapter/LogAdapter.h"
+
+char *PriceEngine::conditionSearch(char* jRequest)
+{
+	bool bParseReq = false;
+	std::string json_req;
+	if (jRequest == NULL || strlen(jRequest) == 0) {
+		if (LogAdapter::logConsole()) LogAdapter::Console("The condition is empty. Specify valid values and try the request again.");
+		return NULL;
+	}
+
+	//check whether request is starting with space or new line
+	if(jRequest[0] == ' ' || jRequest[0] == '\n' || jRequest[0] == '\t') { 
+		if (LogAdapter::logConsole()) LogAdapter::Console("Looks like there is a leading whitespace in the request. Remove the whitespace, then pass the request.");
+		return NULL;
+	}
+	    
+	if (jRequest[0] == '{') {
+		json_req = jRequest;
+	}
+	else if (jRequest[0] == '[') {
+		json_req = "{ \"req\" :"; json_req.append(jRequest); json_req.append("}");
+	}
+	else {
+		json_req = "{"; json_req.append(jRequest); json_req.append("}");
+	}
+	//Parse the request
+
+	/* Performance optimization done:
+	 *  cJSON is slow when using the index to read an item from an array while iterating it.
+	 *  This is the case because cJSON reads an index by iterating through the array from the beginning.
+	 *  To work around this the "next" pointer of the array item is used to get the next item until there is no next item.
+	*/
+
+	m_Request = cJSON_Parse(json_req.c_str());
+	if (!m_Request){	
+		if (LogAdapter::logConsole()) LogAdapter::Console("The JSON input couldn't be parsed. Specify valid search values and try again.");
+		return NULL;
+	}
+	if(m_Request->child == NULL){
+		cJSON_Delete(m_Request);
+		m_Request = NULL;
+		if (LogAdapter::logConsole()) LogAdapter::Console("Something went wrong. Try passing the request again or contact Salesforce Support for help.");
+		return NULL;
+	}
+	cJSON* root = m_Request->child;
+	if (root->type == cJSON_Array)  {
+		cJSON* jsr = cJSON_GetArrayItem(root, 0);
+		while (jsr != NULL && jsr->child != NULL) {
+			// SearchRequest.
+			SearchRequest sr;
+			sr.ConditionKey = jsr->child;
+			cJSON* jsreq = jsr->child->next;
+			if (jsreq->type == cJSON_Array) {
+			    cJSON* jSSReq = cJSON_GetArrayItem(jsreq, 0);
+				while (jSSReq != NULL) {
+					//get SR search steps.
+					SearchStepsRequest ssReq;
+					ssReq.Exclusive = cJSON_GetArrayItem(jSSReq, 1);
+					ssReq.KeyType = cJSON_GetArrayItem(jSSReq, 0);
+					cJSON* jMergeKeys = cJSON_GetArrayItem(jSSReq, 2);
+					if (jMergeKeys->type == cJSON_Array) {
+                        cJSON* mergedKey = cJSON_GetArrayItem(jMergeKeys, 0);
+                        while (mergedKey != NULL) {
+							if (!bParseReq) bParseReq = true;
+							ssReq.MergedKeys.push_back(mergedKey);
+							mergedKey = mergedKey->next;
+						}
+					}
+					sr.SearchSteps.push_back(ssReq);
+					jSSReq = jSSReq->next;
+				}
+			}
+			m_searchRequests.push_back(sr);
+			jsr = jsr->next;
+		}
+	}
+
+	if (!bParseReq) {
+		if (LogAdapter::logConsole()) LogAdapter::Console("Something went wrong. Try passing the request again or contact Salesforce Support for help.");
+		return NULL;
+	}
+		
+
+	cJSON *m_Results = cJSON_CreateArray();
+	cJSON *previous_result = NULL;
+
+	std::string tableName;
+	std::string metaPKeyName;
+	std::string keyTypeName;
+	std::string mergedKeyName;
+	std::string contentName;
+	bool isSalesforce = true;
+    
+	if (isSalesforce) {
+		tableName = "CP_Pricing_Condition__c";
+		metaPKeyName = "Pricing_Condition_Template__c";
+		keyTypeName = "Key_Type__c";
+		mergedKeyName = "Merged_Key__c";
+		contentName = "Content__c";
+	} else {
+		//CndCpMetaPKey = '00100000006mjc9q' AND CndCpKeyTypePKey = '00100000006mk6tl' AND MergedKey = '00100000006nlp1y'
+		tableName = "CndCpMain";
+		metaPKeyName = "CndCpMetaPKey";
+		keyTypeName = "CndCpKeyTypePKey";
+		mergedKeyName = "MergedKey";
+		contentName = "Content";
+	}
+    
+	//build the SQL statement
+	for (int i = 0; i<(int)m_searchRequests.size(); i++) {
+		SearchRequest sr = m_searchRequests[i];
+		//get table name from contion PKEY.
+		std::string sql = "select " + mergedKeyName + ", " + contentName + " from " + tableName + " where " + metaPKeyName + "= ?";
+
+		bool bSelect = false;
+		for (int j = 0; j < (int)sr.SearchSteps.size(); j++) {
+			// initialize query and add searchRequest param to query
+			cJSON * pQuery = m_conn->CreateJSONQuery();
+			cJSON * parameterArray = m_conn->AddJSONQueryItem(pQuery, sql.c_str());
+			m_conn->AddJSONQueryItemParam(parameterArray, sr.ConditionKey->valuestring);
+
+			SearchStepsRequest ssReq = sr.SearchSteps[j];
+			std::string sqlStep = " and ";
+			sqlStep.append(keyTypeName).append(" = ?");
+			m_conn->AddJSONQueryItemParam(parameterArray, ssReq.KeyType->valuestring);
+			
+			timer t;
+			t.start();
+			std::string sqlMerge = " and " + mergedKeyName + " in (";
+			for (int k = 0; k < (int)ssReq.MergedKeys.size(); k++) {
+				/*
+				std::string sqlMerge = " and (";
+				std::string multipleKeys = ssReq.MergedKeys[k]->valuestring;
+				int foundPlus = std::string::npos;
+				while ((found = multipleKeys.find("+")) != std::string::npos) {
+				std::string key = multipleKeys.substr(0, found);
+				sqlMerge.append(mergedKeyName).append(" = ").append("'").append(key).append("'");
+				sqlMerge.append(" or ");
+				multipleKeys = multipleKeys.substr(found + 1);
+				}
+				sqlMerge.append(mergedKeyName).append(" = ").append("'").append(multipleKeys).append("')");
+				*/
+				//changed by Joshua, Xu, to convert the OR conditions to in clause for better performance in SQLite
+				//changed by Joshua, Xu, as "abc+def+gfsds" is considered one key in database
+				if (k == 0)
+					sqlMerge.append("?");
+				else
+					sqlMerge.append(", ?");
+
+				m_conn->AddJSONQueryItemParam(parameterArray, ssReq.MergedKeys[k]->valuestring);
+			}
+			sqlMerge.append(")");
+
+			std::string selectSql = sql + sqlStep + sqlMerge;
+
+			// reassign sql statement
+			m_conn->ReplaceJSONSqlStatement(pQuery, selectSql.c_str());
+
+			cJSON* data = m_conn->universalParameterizedBatch(pQuery, false, false, true);
+
+			//add executeTime.
+			t.stop();
+			timer_ticks ticks = t.get_elapsed_us();
+			int executeTime = (int)t.ticks_to_ms(ticks) / ssReq.MergedKeys.size();
+
+			for (int k = 0; k < (int)ssReq.MergedKeys.size(); k++) {
+				//put in result list.
+				cJSON* result = cJSON_CreateArray();
+
+				cJSON_AddItemReferenceToArray(result, sr.ConditionKey);
+				cJSON_AddItemReferenceToArray(result, ssReq.KeyType);
+				// cJSON_AddItemReferenceToArray(result, ssReq.Exclusive);
+				cJSON_AddItemReferenceToArray(result, ssReq.MergedKeys[k]);
+
+				cJSON* cJsonSqlResult = NULL;
+				std::string sqlResult;
+				std::string mkName;
+
+				cJSON *queryResult = cJSON_GetArrayItem(data, 0);
+        std::string type = cJSON_GetObjectItem(queryResult, "type")->valuestring;
+
+				if (NULL != queryResult && type == "success") {
+          cJSON *result = cJSON_GetObjectItem(queryResult, "result");
+          cJSON *rows = cJSON_GetObjectItem(result, "rows");
+
+          cJSON *currRow = rows->child;
+          while (currRow) {
+            mkName = cJSON_GetObjectItem(currRow, "Merged_Key__c")->valuestring;
+            if (!mkName.compare(ssReq.MergedKeys[k]->valuestring)) {
+                sqlResult = cJSON_GetObjectItem(currRow, "Content__c")->valuestring;;
+                bSelect = true;
+                break;
+            }
+            currRow = currRow->next;
+          }
+				}
+
+				if (sqlResult.length()>0) {
+					//Parse the SQL result to JSON
+					cJsonSqlResult = cJSON_Parse(sqlResult.c_str());
+
+					if(!cJsonSqlResult){
+						//Parse failed
+						m_conn->LogError("PriceEngine", "PriceEngine", "conditionSearch", StringFormat("Error parsing complex pricing condition content to JSON for merged key: %s", mkName.c_str()).c_str());
+					}
+        }
+
+				cJSON_AddItemToArray(result, cJSON_CreateNumber((double)executeTime));
+				if (cJsonSqlResult) //add sqlResult to resultObj...
+					cJSON_AddItemToArray(result, cJsonSqlResult);
+
+        // Performance optimization done:
+        //  cJSON is slow when adding an item at the end of an array, especialy if this array has many items.
+        //  This is the case because cJSON searches the end of the array by iterating through the array from the beginning.
+        //  To work around this the last item is cached and the new item is added by manually setting the "next" and "prev" pointers.
+        //
+				if (previous_result == NULL) {
+          cJSON_AddItemToArray(m_Results, result);
+        } else {
+          previous_result->next = result;
+          result->prev = previous_result;
+        }
+        previous_result = result;
+			}
+
+			if (NULL != data)
+				delete data;
+
+			// Check Exclusive
+			//int exclusive = ssReq.Exclusive->valueint;
+			if (strcmp(ssReq.Exclusive->valuestring, "0") != 0 && (bSelect)) {
+				break; //break current search request, continue next search request.
+			}
+		}
+	}
+
+	return cJSON_PrintUnformatted(m_Results);
+}

package/nativeSrc/common/PriceEngine/PriceEngine.h

@@ -0,0 +1,67 @@
+//
+//  PriceEngine.h
+//  NGM
+//
+//  Created by Yanbo on 29/05/14.
+/*
+ * FILE_HEADER
+ */
+
+#ifndef NGM_PriceEngine_h
+#define NGM_PriceEngine_h
+
+#include "../stdngm.h"
+#include <cstdlib>
+#include <vector>
+
+#include "../DBAccess/SimpleDBConnection.h"
+#include "../Libs/cJSON/cJSON.h"
+
+
+using namespace std;
+
+typedef struct _SearchStepsRequest {
+	cJSON* KeyType; //
+	cJSON* Exclusive; //
+	vector < cJSON*> MergedKeys; //array of merge Keys.
+}SearchStepsRequest;
+
+typedef struct _SearchRequest {
+	cJSON* ConditionKey; //name value
+	vector <SearchStepsRequest> SearchSteps; //array of SearchSteps.
+}SearchRequest;
+
+
+class PriceEngine {
+	//Input Json array string, output json content array.
+private:
+	vector <SearchRequest> m_searchRequests;
+	cJSON* m_Results;
+	cJSON* m_Request;
+	SimpleDBConnection* m_conn;
+
+public:
+	char* conditionSearch(char* jRequest);
+
+	PriceEngine()
+	{
+		m_Results = NULL;
+		m_Request = NULL;
+		m_conn = NULL;
+	}
+	~PriceEngine() {
+		if (m_Results) {
+			cJSON_Delete(m_Results);
+			m_Results = NULL;
+		}
+		if (m_Request) {
+			cJSON_Delete(m_Request);
+			m_Request = NULL;
+		}
+	}
+public:
+	void SetDBConnection(SimpleDBConnection* conn) { m_conn = conn; }
+};
+
+
+#endif