Z991239-5890 #comment 客户感知事件转换逻辑调整为代码实现

Module/mod_evtconverter/evtengine.cpp

@@ -11,6 +11,7 @@
 #include "scew.h"
 
 #include "SipphoneEvent.hpp"
+#include "CustomerApproachEvent.hpp"
 
 #if 0
 <?xml version="1.0" encoding="utf-8"?>
@@ -1381,6 +1382,94 @@ static char *parse_code(const char *ns, const char *s)
 	}
 }
 
+
+static int extract_filter_element(evt_engine_t* engine, rvc_slotfilter_t* filter_elem, int* p_log_type, int* p_ent_id, const char** p_entity, int* p_severity, int* p_sys_code, int* p_usr_code, const char** p_slotvar)
+{
+	int log_type, ent_id, severity, sys_code, usr_code;
+	const char* entity = NULL;
+	const char* slotvar = NULL;
+
+	if (filter_elem->strLogType) {
+		log_type = parse_log_type(filter_elem->strLogType);
+		if (log_type == -1) {
+			if (nIslog) {
+				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("parse log type failed!");
+			}
+			return Error_Unexpect;
+		}
+	}
+	else {
+		log_type = Log_Ignore;
+	}
+
+	if (filter_elem->strEntity) {
+		ent_id = parse_ent_id(engine, filter_elem->strEntity);
+		if (ent_id == -1) {
+			if (nIslog) {
+				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("parse entity id failed!");
+			}
+			return Error_Unexpect;
+		}
+		else {
+			entity = filter_elem->strEntity;
+		}
+	}
+	else {
+		ent_id = -1;
+	}
+
+	if (filter_elem->strSeverityLevel) {
+		severity = parse_severity(filter_elem->strSeverityLevel);
+		if (severity == -1) {
+			if (nIslog) {
+				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("parse severity level failed!");
+			}
+			return Error_Unexpect;
+		}
+	}
+	else {
+		severity = Severity_None;
+	}
+
+	if (filter_elem->strSysError) {
+		sys_code = parse_sys_code(filter_elem->strSysError);
+		if (sys_code == -1) {
+			if (nIslog) {
+				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("parse sys code failed! sys_code: %s", filter_elem->strSysError);
+			}
+			return Error_Unexpect;
+		}
+	}
+	else {
+		sys_code = Error_IgnoreAll;
+	}
+
+	if (filter_elem->strUserCode) {
+		usr_code = parse_usr_code(filter_elem->strUserCode);
+	}
+	else {
+		usr_code = -2;
+	}
+
+	if (filter_elem->strContentToVar) {
+		slotvar = filter_elem->strContentToVar;
+	}
+	else {
+		slotvar = NULL;
+	}
+
+	*p_log_type = log_type;
+	*p_ent_id = ent_id;
+	*p_severity = severity;
+	*p_sys_code = sys_code;
+	*p_usr_code = usr_code;
+	*p_entity = entity;
+	*p_slotvar = slotvar;
+
+	return 0;
+}
+
+
 static int extract_filter(evt_engine_t *engine, scew_element *filter_elem, int *p_log_type, int *p_ent_id, const char **p_entity, int *p_severity, int *p_sys_code, int *p_usr_code, const char **p_slotvar)
 {
 	int log_type, ent_id, severity, sys_code, usr_code;
@@ -1472,6 +1561,42 @@ static int extract_filter(evt_engine_t *engine, scew_element *filter_elem, int *
 	return 0;
 }
 
+static int load_filter_element(evt_engine_t* engine, evt_slot_t* slot, rvc_slotfilter_t* filter_elem)
+{
+	evt_filter_t* filter = ZALLOC_T(evt_filter_t);
+	const char* entity = NULL;
+	const char* slotvar = NULL;
+	int rc = extract_filter_element(engine, filter_elem, &filter->log_type, &filter->ent_id, (const char**)&entity, &filter->severity, &filter->sys_code, &filter->user_code, &slotvar);
+	if (rc != 0) {
+		if (nIslog) {
+			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("extract filter failed!");
+		}
+		return rc;
+	}
+	if (slotvar) {
+		int i;
+		for (i = 0; i < slot->arr_slotvar->nelts; ++i) {
+			evt_slotvar_t* var = ARRAY_IDX(slot->arr_slotvar, i, evt_slotvar_t*);
+			if (_stricmp(var->name, slotvar) == 0) {
+				filter->content_to_var = var;
+				break;
+			}
+		}
+		if (!filter->content_to_var) {
+			if (nIslog) {
+				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("cannot find %s slotvar!", slotvar);
+			}
+			return -1;
+		}
+	}
+	filter->entity = entity ? _strdup(entity) : NULL;
+	filter->key.listen_id = 0;
+	filter->owner = slot;
+	ARRAY_PUSH(slot->arr_filter, evt_filter_t*) = filter;
+
+	return 0;
+}
+
 static int load_filter(evt_engine_t *engine, evt_slot_t *slot, scew_element *filter_elem)
 {
 	evt_filter_t *filter = ZALLOC_T(evt_filter_t);
@@ -1536,6 +1661,177 @@ static int load_slotvar(evt_engine_t *engine, evt_slot_t *slot, scew_element *sl
 	return 0;
 }
 
+static int load_slotvar_element(evt_engine_t* engine, evt_slot_t* slot, rvc_slotvar_t* slotvar_elem)
+{
+	evt_slotvar_t* slotvar = ZALLOC_T(evt_slotvar_t);
+
+	if (slotvar_elem->strName) {
+		slotvar->name = _strdup(slotvar_elem->strName);
+	}
+	else {
+		if (nIslog) {
+			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("not found slot var Name property!");
+		}
+		return -1;
+	}
+
+	if (slotvar_elem->strValue) {
+		slotvar->init_value = _strdup(slotvar_elem->strValue);
+		slotvar->current_value = _strdup(slotvar->init_value);
+	}
+	else {
+		if (nIslog) {
+			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("not found slot var Value property!");
+		}
+		return -1;
+	}
+	ARRAY_PUSH(slot->arr_slotvar, evt_slotvar_t*) = slotvar;
+
+	return 0;
+}
+
+
+static int load_slot_arrays(evt_engine_t* engine, const char* ns, rvc_slot_t* tnode)
+{
+	evt_slot_t* slot = ZALLOC_T(evt_slot_t);
+	if (!slot) {
+		return Error_Resource;
+	}
+	INIT_HLIST_NODE(&slot->hentry);
+	slot->arr_filter = array_make(-1, sizeof(evt_filter_t*));
+	slot->arr_reset = array_make(-1, sizeof(char*));
+	slot->arr_rref_reset = array_make(-1, sizeof(evt_slot_t*));
+	slot->arr_ref_reset = array_make(-1, sizeof(evt_slot_t*));
+	slot->arr_ref_trigger = array_make(-1, sizeof(evt_trigger_t*));
+	slot->arr_slotvar = array_make(-1, sizeof(evt_slotvar_t*));
+	slot->parent = engine;
+
+	char* code = NULL;
+
+	if (!tnode->strCode) {
+		if (nIslog) {
+			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("slot miss attribute code!");
+		}
+		goto on_error;
+	}
+	else {
+		code = parse_code(ns, tnode->strCode);
+		if (!code) {
+			if (nIslog) {
+				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("parse code failed!");
+			}
+			goto on_error;
+		}
+		else {
+			slot->key.code = code;
+			slot->key.index_hash_code = hash32_str(code, HASH32_STR_INIT);
+		}
+	}
+
+	if (tnode->strTimeout) {
+		evt_expire_t* expire = ZALLOC_T(evt_expire_t);
+		if (!expire) {
+			goto on_error;
+		}
+		expire->timeout = parse_timeout_value(tnode->strTimeout);
+		if (expire->timeout < 0) {
+			FREE(expire);
+			goto on_error;
+		}
+
+		if (expire->timeout == 0) {
+			FREE(expire);
+		}
+		else {
+			expire->parent = slot;
+			expire->timer_id = 0;
+			slot->timer = expire;
+		}
+	}
+
+	if (tnode->strOneTrigger) {
+		slot->once = parse_bool(tnode->strOneTrigger);
+	}
+	else {
+		slot->once = 0;
+	}
+
+	int vars_arr_length = sizeof(tnode->Vars) / sizeof(rvc_slotvar_t);
+	if (vars_arr_length > 0) {
+		for (int ivar = 0; ivar < vars_arr_length; ivar++) {
+			int rc = load_slotvar_element(engine, slot, &tnode->Vars[ivar]);
+			if (rc != 0) {
+				if (nIslog) {
+					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("load slot var failed!%s", slot->key.code);
+				}
+				goto on_error;
+			}
+		}
+	}
+
+	int filters_arr_length = sizeof(tnode->Filters) / sizeof(rvc_slotfilter_t);
+	if (filters_arr_length > 0) {
+		for (int ifilter = 0; ifilter < filters_arr_length; ifilter++) {
+			int rc = load_filter_element(engine, slot, &tnode->Filters[ifilter]);
+			if (rc != 0) {
+				if (nIslog) {
+					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("load filter failed!");
+				}
+				goto on_error;
+			}
+		}
+	}
+
+	int reset_arr_length = sizeof(tnode->Reset) / sizeof(rvc_slotreset_t);
+	if (reset_arr_length > 0) {
+		for (int ireset = 0; ireset < reset_arr_length; ireset++) {
+			if (tnode->Reset[ireset].strSource) {
+				char* source = parse_code(ns, tnode->Reset[ireset].strSource);
+				if (!source) {
+					if (nIslog) {
+						DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("parse code of Reset tag Source attribute failed!");
+					}
+					goto on_error;
+				}
+				else {
+					ARRAY_PUSH(slot->arr_reset, char*) = source;
+				}
+			}
+			else {
+				if (nIslog) {
+					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Reset tag miss source attribute!");
+				}
+				goto on_error;
+			}
+		}
+	}
+	if (!slot->timer) {
+		slot->once = 1;
+	}
+
+	if (slot_find(engine->slot_ht, &slot->key)) {
+		if (nIslog) {
+			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("duplicate slot %s", slot->key.code);
+		}
+		goto on_error;
+	}
+
+	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("%s:%d engine->slot_ht->size = %d, engine->slot_ht count = %d.", __FUNCTION__, __LINE__, engine->slot_ht->size, htable_get_count(engine->slot_ht));
+
+	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("slot->key.code = %s, slot->key.index_hash_code = %d.", slot->key.code, slot->key.index_hash_code);
+
+	slot_add(engine->slot_ht, slot);
+
+	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("%s:%d engine->slot_ht->size = %d, engine->slot_ht count = %d.", __FUNCTION__, __LINE__, engine->slot_ht->size, htable_get_count(engine->slot_ht));
+
+	return 0;
+
+on_error:
+	slot_free(slot);
+	return Error_Unexpect;
+}
+
+
 static int load_slot(evt_engine_t *engine, const char *ns, scew_element *slot_elem)
 {
 	evt_slot_t *slot = ZALLOC_T(evt_slot_t);
@@ -1585,12 +1881,12 @@ static int load_slot(evt_engine_t *engine, const char *ns, scew_element *slot_el
 		}
 		expire->timeout = parse_timeout_value(scew_attribute_value(attr));
 		if (expire->timeout < 0) {
-			free(expire);
+			FREE(expire);
 			goto on_error;
 		}
 
 		if (expire->timeout == 0) {
-			free(expire);
+			FREE(expire);
 		} 
 		else {
 			expire->parent = slot;
@@ -1800,6 +2096,137 @@ void SetLogType(int nIslog)
 	nIslog = nIslog;
 }
 
+
+static int load_trigger_arrays(evt_engine_t* engine, const char* ns, rvc_trigger_t* trigger_elem)
+{
+	evt_trigger_t* trigger = ZALLOC_T(evt_trigger_t);
+
+	INIT_LIST_HEAD(&trigger->slot_rule_list);
+	INIT_LIST_HEAD(&trigger->sysvar_list);
+
+	if (trigger_elem->strLogType) {
+		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("LogType value is %s.", trigger_elem->strLogType);
+		trigger->log_type = parse_log_type(trigger_elem->strLogType);
+		if (trigger->log_type == -1) {
+			if (nIslog) {
+				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("trigger log type parse failed!");
+			}
+			goto on_error;
+		}
+	}
+	else {
+		if (nIslog) {
+			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("trigger LogType undefined!");
+		}
+		goto on_error;
+	}
+
+	if (trigger_elem->strSeverityLevel) {
+		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("SeverityLevel value is %s.", trigger_elem->strSeverityLevel);
+		trigger->severity_level = parse_severity(trigger_elem->strSeverityLevel);
+		if (trigger->severity_level == -1) {
+			if (nIslog) {
+				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("trigger parse severity level failed!");
+			}
+			goto on_error;
+		}
+	}
+	else {
+		if (trigger->log_type == Log_Event || trigger->log_type == Log_Error) {
+			if (nIslog) {
+				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("trigger LogType undefined!");
+			}
+			goto on_error;
+		}
+	}
+
+	if (trigger_elem->strSysError) {
+		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("SysError value is %s.", trigger_elem->strSysError);
+		trigger->sys_code = parse_sys_code(trigger_elem->strSysError);
+		if (trigger->sys_code == -1) {
+			if (nIslog) {
+				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("trigger parse sys code failed! sys_code: %s", trigger_elem->strSysError);
+			}
+			goto on_error;
+		}
+	}
+	else {
+		if (trigger->log_type == Log_Error || trigger->log_type == Log_Warning) {
+			if (nIslog) {
+				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("trigger parse sys code undefined!");
+			}
+			goto on_error;
+		}
+	}
+
+	if (trigger_elem->strUserCode) {
+		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("UserCode value is %s.", trigger_elem->strUserCode);
+		trigger->user_code = parse_usr_code(trigger_elem->strUserCode);
+	}
+	else {
+		if (trigger->log_type == Log_Event || trigger->log_type == Log_Error || trigger->log_type == Log_Warning) {
+			if (nIslog) {
+				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("trigger parse user code undefined!");
+			}
+			goto on_error;
+		}
+	}
+
+	if (trigger_elem->strMessage) {
+		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Message value is %s.", trigger_elem->strMessage);
+		trigger->msg = _strdup(trigger_elem->strMessage);
+	}
+
+	slot_list = scew_element_list_by_name(trigger_elem, "Slot");
+	if (slot_list) {
+		for (scew_list* it = scew_list_first(slot_list); it; it = scew_list_next(it)) {
+			scew_element* slot_elem = (scew_element*)scew_list_data(it);
+			int rc = load_slot_rule(trigger, ns, slot_elem);
+			if (rc != 0) {
+				if (nIslog) {
+					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("load slot rule failed!");
+				}
+				scew_list_free(slot_list);
+				goto on_error;
+			}
+		}
+		scew_list_free(slot_list);
+	}
+
+	sysvar_list = scew_element_list_by_name(trigger_elem, "SysVar");
+	if (sysvar_list) {
+		for (scew_list* it = scew_list_first(sysvar_list); it; it = scew_list_next(it)) {
+			scew_element* sysvar_elem = (scew_element*)scew_list_data(it);
+			int rc = load_sysvar_rule(engine, trigger, sysvar_elem);
+			if (rc != 0) {
+				if (nIslog) {
+					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("load sysvar rule failed!");
+				}
+				scew_list_free(sysvar_list);
+				goto on_error;
+			}
+		}
+		scew_list_free(sysvar_list);
+	}
+
+	if (trigger_elem->strDelayer) {
+		trigger->delay_ms = parse_timeout_value(trigger_elem->strDelayer);
+		trigger->delay_timer_id = -1;
+	}
+	else {
+		trigger->delay_ms = 0;
+		trigger->delay_timer_id = -1;
+	}
+	trigger->parent = engine;
+	list_add_tail(&trigger->entry, &engine->trigger_list);
+
+	return 0;
+
+on_error:
+	trigger_free(trigger);
+	return Error_Unexpect;
+}
+
 static int load_trigger(evt_engine_t *engine, const char *ns, scew_element *trigger_elem)
 {
 	evt_trigger_t *trigger = ZALLOC_T(evt_trigger_t);

Module/mod_evtconverter/slot.h

@@ -32,5 +32,5 @@ typedef struct rvc_slot_s {
 	char* strOneTrigger;
 	rvc_slotvar_t Vars[RVC_SLOT_MAX_NUM];
 	rvc_slotfilter_t Filters[RVC_SLOT_MAX_NUM];
-	rvc_slotreset_t Reset;
+	rvc_slotreset_t Reset[RVC_SLOT_MAX_NUM];
 }rvc_slot_t;