SmartPDCode/ip/src/appweb_handle.c

#include "http.h"
#include "cJSON.h"
#include "common.h"
#include "json_handle.h"
#include "sqlite_handle.h"
#include "cJSON.h"
#include "switch_ctrl.h"
#include "sys.h"
#include "cfg.h"
#include "cascade.h"


#define WEB_DEBUG 1

typedef void (*http_fn_t)(void *arg);


#ifdef USE_WEBAPP
#include "http.h"
#else
#include "mongoose.h"
#define FN_MAX  30

typedef struct {
    struct mg_connection *c;
    int     ev;
    void    *ev_data;
}mg_stream_t;
typedef struct {
    http_fn_t  f;
    char       *uri;
}mg_fn_t;
typedef struct {
    int        cnt;
    mg_fn_t    fn[FN_MAX];
    char       rootDir[MG_PATH_MAX];

    pthread_t  tid;
}mg_handle_t;
#endif
typedef struct {
#ifndef USE_WEBAPP
    mg_handle_t mg;
#endif

    pthread_t  tid;
}web_handle_t;
static web_handle_t webHandle;


static char* g_product_board_cpu[] = {
    "xxx",
    "T113"
};

static char* g_product_type_str[] = {
    "SmartPdu(DC)",
    "SmartPdu(AC)",
    "SmartPdu(Tree_AC_Tree)",
    "SmartPdu(Tree_AC_One)",
};

static char* g_product_pwr_type_str[] = {
    "xxx",
    "直流",
    "交流单相",
    "交流三相三出",
    "交流三相单出",
};
static int webSetCallback(void);


#ifndef USE_WEBAPP
const char *hdr_str=
"Vary: Accept-Encoding\r\n"
"Keep-Alive: timeout=30 max=394\r\n"
"Content-Type: text/html\r\n" 
"X-Frame-Options: SAMEORIGIN\r\n"
"X-Content-Type-Options: nosniff\r\n"
"X-XSS-Protection: 1; mode=block\r\n"
"Date: Thu, 01 Jan 1970 23:13:59 GMT\r\n"
"Connection: Keep-Alive\r\n"
"Accept-Ranges: bytes\r\n"
"File Data: 238 bytes\r\n"
;
#endif
static int http_reply(void *conn, int status, char *ack)
{
     int r=0;
     
#ifdef USE_WEBAPP
    HttpStream *s=(HttpStream*)conn;
    httpSetStatus(s, status);
    if(ack && strlen(ack)>0) {
        httpWrite(s->writeq, ack);
    }
    httpFinalize(s);
#else
    mg_stream_t *s=(mg_stream_t*)conn;
    //mg_http_reply(s->c, status, ack, "");
    mg_http_reply(s->c, status, hdr_str, "%s", ack);
#endif

    return r;
}

static void httpAddCallback(char *uri, http_fn_t f)
{
#ifdef USE_WEBAPP
    httpDefineAction(uri, f);
#else
    mg_handle_t *h=&webHandle.mg;
    if(h->cnt<FN_MAX-1) {
        h->fn[h->cnt].uri = uri;
        h->fn[h->cnt].f   = f;
        h->cnt++;
    }

#endif
}


#ifdef USE_WEBAPP
static void *web_thread(void *arg)
{
    Mpr  *mpr;
    int  rc;
    char path[MG_PATH_MAX];
    thread_handle_t *h=(thread_handle_t*)arg;
    
    rc = MPR_ERR_CANT_CREATE;
    if ((mpr = mprCreate(0, NULL, MPR_USER_EVENTS_THREAD)) == 0) {
        mprError("Cannot create runtime");
        return -1;
    }
    if (httpCreate(HTTP_CLIENT_SIDE | HTTP_SERVER_SIDE) == 0) {
        mprError("Cannot create the HTTP services");
        return -1;
    }
    
    mprStart();
    
    sys_get_path(path, ME_CONFIG_FILE);
    log_d("____ web root: %s\n", path);
    if (maParseConfig(path) < 0) {
        mprError("Cannot parse the config file %s", ME_CONFIG_FILE);
        return -1;
    }

    webSetCallback();
    //httpAddFileHandler(host);
    
    if (httpStartEndpoints() < 0) {
        mprError("Cannot start the web server");
        return -1;
    }
    mprServiceEvents(-1, 0);
    mprDestroy();
    
    pthread_exit(NULL);
}

#else

static void http_mg_cb(struct mg_connection *c, int ev, void *ev_data)
{
    int i,j;
    mg_handle_t *h=&webHandle.mg;
    mg_stream_t s={c,ev,ev_data};

    if (ev == MG_EV_HTTP_MSG) {
        struct mg_http_message *hm = ev_data;
        for(i=0; i<h->cnt; i++) {
            if (h->fn[i].f && h->fn[i].uri && mg_match(hm->uri, mg_str(h->fn[i].uri), NULL)) {
                h->fn[i].f(&s); c->pfn = NULL;
            }
        } 

        if (c->pfn != NULL) {
            struct mg_http_serve_opts opts = {.root_dir = h->rootDir};
            mg_http_serve_dir(c, ev_data, &opts);
        }
    }
}
static void *web_thread(void *arg)
{
    struct mg_mgr mgr;
    struct mg_connection *c;
    mg_handle_t *mh=&webHandle.mg;
    thread_handle_t *h=(thread_handle_t*)arg;
    const char *listen_addr="http://0.0.0.0:80";

    //mg_log_set(MG_LL_ERROR);
    mg_mgr_init(&mgr);

    //sys_get_path(h->rootDir, WEB_ROOT);
    strcpy(mh->rootDir, "/root/run/web");
    
    if ((c = mg_http_listen(&mgr, listen_addr, http_mg_cb, NULL)) == NULL) {
        MG_ERROR(("cannot listen on %s. use http://address:port or :port\n", listen_addr));
        return -1;
    }
    webSetCallback();
    printf("_____mgHandle.cnt: %d, rootdir: %s\n", mh->cnt, mh->rootDir);

    while(h->quit==0) {
        mg_mgr_poll(&mgr, 50);
    }
    mg_mgr_free(&mgr);
        
 pthread_exit(NULL);
}
#endif
/// @brief 定时更新前端
/// @param arg 
/// @return 
void* update_thread(void* arg)
{
    thread_handle_t *h=(thread_handle_t*)arg;
    GlobalSensorManger* _globalSensorMangerTemp;
    int ret = 0 ;
    GlobalSensorInfo _globalSensorInfo;
    struct tm* t ;
    struct timeval tv;
    struct timezone tz ;
    char* upgrade_msg = NULL ;
    char* ack_str = NULL ;
     GlobalPowerInfo _powerInfo;
    GlobalPowerManger* _globalPowerMangerTemp = NULL ;
    _OverAllPwrAckInfo _over_all_pwr_back_info; //设备电源信息
    GlobalDeviceManager* gdm= &__globalDeviceManage;
    GlobalDeviceManager* gdm2=&__globalDeviceManage2;
	
    //采集线程
    while (h->quit==0)
    {
        if(websocket_isok())
        {
           // pthread_mutex_lock(&Websocketlock); 
            //推送总体信息
            if(gdm->view_page==1)
            { 
                if(gdm->_global_device_info->product_pwr_type==SmartPDU_Tree_AC_Tree ||
                    gdm->_global_device_info->product_pwr_type==SmartPDU_Tree_AC_One)
                {
                    //三相
                    _OverAllPwrAckInfo _over_all_pwr_back_info;
                    dev_search_latest_t_ac_power_statistic_info(0, gdm->nTreeACLshow, &_over_all_pwr_back_info);
                    ack_str = over_all_pwr_monitor_to_json(&_over_all_pwr_back_info);

                    websocket_send(ack_str, strlen(ack_str));
                    cJSON_free((void*)ack_str);
                }
                else
                {
                    if(cur_dev_addr==0) {
                        dev_search_latest_power_statistic_info(gdm);
                    }
                    else {
                        dev_search_latest_power_statistic_info(gdm2);
                    }
                }                
            }
            //推送通道信息
            else if(gdm->view_page==2)
            {
                _OverChnPwrAckInfo _over_chn_pwr_back_info;
                INIT_LIST_HEAD(&_over_chn_pwr_back_info.list);

                GlobalDeviceManager *pgdm=NULL;
                if(cur_dev_addr==0) {
                    pgdm = gdm;
                }
                else {
                    pgdm = gdm2;
                }

                dev_search_latest_power_All_info(pgdm,&_over_chn_pwr_back_info);
                upgrade_msg = ws_chn_status_ack_to_json(1,&_over_chn_pwr_back_info);

                websocket_send(upgrade_msg, strlen(upgrade_msg));
                 
                //释放资源,一定要记得释放json字符串！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
                cJSON_free((void*)upgrade_msg);
                //释放资源,一定要记得释放json字符串！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
                _OverChnPwrAckInfo *node,*next;
                list_for_each_entry_safe(node, next, &_over_chn_pwr_back_info.list, list)
                {
                    list_del(&node->list);
                    free(node);
                } 
            }
            //usleep(400*1000);
           // pthread_mutex_unlock(&Websocketlock); 
            //log_i("ws upload.");
        }
        usleep(500*1000);
    }
    pthread_exit(NULL);
}


/// @brief 系统信息
/// @param stream 
static void systemConfiguration(void* conn)
{
    char* ack_str = NULL ;

    ack_str = json_to_system_config_info();
    http_reply(conn, 200, ack_str);
    cJSON_free((void*)ack_str);
}

/// @brief 多语言切换
/// @param stream 
static void changeLanguages(void* conn)
{
    char* ack_str = NULL;
    char* rx_body_buf = NULL;

#ifdef USE_WEBAPP
    HttpStream *s=(HttpStream*)conn;
    rx_body_buf = httpGetBodyInput(s);
#else
    mg_stream_t *s=(mg_stream_t*)conn;
    struct mg_http_message *msg=s->ev_data;
    rx_body_buf = msg->body.buf;
#endif
    json_to_switch_language(rx_body_buf);
    dev_update_device_genera_info(__globalDeviceManage.db,__globalDeviceManage._global_device_info);
    ack_str = ctrl_sts_ack_to_json();
    http_reply(conn, 200, ack_str);
    cJSON_free((void*)ack_str);
}

/// @brief 登录信息
/// @param stream 
static void loginFunc(void* conn)
{
    char* ack_str = NULL ;
    char g_token[64] = {0};
    cchar* rx_body_buf = NULL;
#ifdef USE_WEBAPP
    HttpStream *s=(HttpStream*)conn;
    rx_body_buf = httpGetBodyInput(s);
#else
    mg_stream_t *s=(mg_stream_t*)conn;
    struct mg_http_message *msg=s->ev_data;
    rx_body_buf = msg->body.buf;
#endif

    _User_Log *_newUserLogin = (_User_Log *)malloc(sizeof(_User_Log));
    memset(_newUserLogin, 0, sizeof(_User_Log));

        //转换json参数
    if(json_to_User_login_info(rx_body_buf,_newUserLogin)!=0)
    {
        httpSetStatus(stream, 400);
        httpFinalize(stream);
        return ;        
    }

    bool LoginFlag = false;

    // 查询用户信息
    UserInfo User_list;
    INIT_LIST_HEAD(&User_list.list);

    if (0 == dev_get_user_info(__globalDeviceManage.db, &User_list))
    {
        UserInfo *_UserInfoTemp = NULL;
        list_for_each_entry(_UserInfoTemp, &User_list.list, list)
        {
            if (_UserInfoTemp == NULL)
                break;

            if (strcmp(_UserInfoTemp->userName,_newUserLogin->user_name)==0 && strcmp(_UserInfoTemp->userPW,_newUserLogin->user_password)==0)
            {
                LoginFlag=true;
                _GlobalUserInfoNew = *_UserInfoTemp;
                break;
            }
        }
    }

    //if (strcmp(_newUserLogin.user_name, "gowone") == 0 && strcmp(_newUserLogin.user_password,"gowone520") == 0)
    //{
    //    LoginFlag = true;
    //}

    //获取随机token
    get_rand_str(g_token,32);

    //记录token
    strcpy(_newUserLogin->user_token,g_token);

    int ack_code=0;
    if (!LoginFlag) 
    {
        ack_str = log_LoginFailedinfo_to_json();
        ack_code = 201;
    }
    else
    {
        strcpy(_GlobalUserToken,g_token);
        list_add_tail(&_newUserLogin->list, &_GlobalUserLoginInfo.list);
        ack_str = log_info_to_json(g_token);
        ack_code = 200;
    }
    http_reply(conn, ack_code, ack_str);
    cJSON_free((void*)ack_str);

}

/// @brief 注销信息
/// @param stream 
static void loginOutFunc(void* conn)
{
    __globalDeviceManage.view_page=-1;
	char* ack_str = NULL ;
    char* rx_body_buf = NULL;
    char* g_token;
	
#ifdef USE_WEBAPP
    HttpStream *s=(HttpStream*)conn;
    rx_body_buf = httpGetBodyInput(s);
#else
    mg_stream_t *s=(mg_stream_t*)conn;
    struct mg_http_message *msg=s->ev_data;
    rx_body_buf = msg->body.buf;
#endif

    //转换json参数
    if(json_to_User_loginOut_info(rx_body_buf,&g_token)!=0)
    {
        http_reply(conn, 400, NULL);
        return ;        
    }
    
    ack_str = log_info_to_json(g_token);
    http_reply(conn, 200, ack_str);
    free(g_token);

    cJSON_free((void*)ack_str);
}


/// @brief 获取用户信息
/// @param stream 
static void getUserInfo(void* conn)
{
    char* ack_str = NULL ;
    char* rx_body_buf = NULL;

    ack_str = user_info_to_json();
    http_reply(conn, 200, ack_str);

    cJSON_free((void*)ack_str);
}


/// @brief 获取菜单数据
/// @param stream 
static void getUserRouters(void* conn)
{
    char* ack_str = NULL ;
    char* rx_body_buf = NULL;

    ack_str = user_routers_info_to_json();
    http_reply(conn, 200, ack_str);

    cJSON_free((void*)ack_str);
}

/// @brief 设备总体信息
/// @param stream 
static void overallStatusMonitoring(void* conn)
{
    int ret = -1 ;
    _Over_All_Sts_Monitor _over_all_sts_monitor;
    _OverBackStsInfo _over_back_sts_info;       //设备总体状态信息
    _OverAllPwrAckInfo _over_all_pwr_back_info; //设备电源信息
    char* rx_body_buf = NULL;
    char* ack_str = "NULL" ;

#ifdef USE_WEBAPP
    HttpStream *s=(HttpStream*)conn;
    rx_body_buf = httpGetBodyInput(s);
    usleep(500000);
#else
    mg_stream_t *s=(mg_stream_t*)conn;
    struct mg_http_message *msg=s->ev_data;
    rx_body_buf = msg->body.buf;
#endif

    #if(1)
    //转换json参数
    if(json_to_overall_status_monitor(rx_body_buf,&_over_all_sts_monitor)!=0)
    {
        http_reply(conn, 400, NULL);
        return ;        
    }
    

    #if(1)
    //总电压电流信息
    // else if(strcmp(_over_all_sts_monitor.type,"listQuery")==0)
    if(strcmp(_over_all_sts_monitor.type,"listQuery")==0)
    {
        //总信息
         __globalDeviceManage.view_page = 1 ;

        cur_dev_addr = _over_all_sts_monitor.product_id;
        if(cur_dev_addr>0) {
            ack_str = ctrl_sts_ack_to_json();
            http_reply(conn, 200, ack_str);
            cJSON_free((void *)ack_str);
            return;
        }

        //参数转换json
        //log_i("over all request:listQuery");
        GlobalPowerInfo __globalPowerInfo;
        memset(&__globalPowerInfo,0,sizeof(GlobalPowerInfo));
        _over_all_pwr_back_info.product_name = __globalDeviceManage._global_device_info->product_name;
        _over_all_pwr_back_info.product_id = __globalDeviceManage._global_device_info->product_id;
        _over_all_pwr_back_info.product_number = __globalDeviceManage._global_device_info->product_number;
        //查询数据库总电源信息
        if (__globalDeviceManage._global_device_info->product_pwr_type == SmartPDU_Tree_AC_Tree ||__globalDeviceManage._global_device_info->product_pwr_type == SmartPDU_Tree_AC_One)
        {
            if (strcmp(_over_all_sts_monitor.product_phOrder, "L1") == 0) // a相
            {
                __globalDeviceManage.nTreeACLshow = 0;
                dev_search_latest_t_ac_power_statistic_info(0, 0, &_over_all_pwr_back_info);
                ack_str = over_all_pwr_monitor_to_json(&_over_all_pwr_back_info);
            }
            else if (strcmp(_over_all_sts_monitor.product_phOrder, "L2") == 0) // b相
            {
                __globalDeviceManage.nTreeACLshow = 1;
                dev_search_latest_t_ac_power_statistic_info(0, 1, &_over_all_pwr_back_info);
                ack_str = over_all_pwr_monitor_to_json(&_over_all_pwr_back_info);
            }
            else if (strcmp(_over_all_sts_monitor.product_phOrder, "L3") == 0) // c相
            {
                __globalDeviceManage.nTreeACLshow = 2;
                dev_search_latest_t_ac_power_statistic_info(0, 2, &_over_all_pwr_back_info);
                ack_str = over_all_pwr_monitor_to_json(&_over_all_pwr_back_info);
            }
        }
        else
        {
            if (dev_search_latest_power_info(__globalDeviceManage.db, __globalDeviceManage._global_device_info->product_id, 0, &__globalPowerInfo) != 0)
            {
                log_e("serach total pwr err.");
            }
#if(WEB_DEBUG==1)
            _over_all_pwr_back_info.voltage = __globalPowerInfo._power_info.voltage ; 
            _over_all_pwr_back_info.current = __globalPowerInfo._power_info.current ;
            _over_all_pwr_back_info.power =  __globalPowerInfo._power_info.power ;
            _over_all_pwr_back_info.freq =  __globalPowerInfo._power_info.freq ;
            _over_all_pwr_back_info.consumption =  __globalPowerInfo._power_info.consumption ;
            _over_all_pwr_back_info.factor = __globalPowerInfo._power_info.factor ;
        #else
            _over_all_pwr_back_info.voltage = 25.4 ;
            _over_all_pwr_back_info.current = 14.2 ;
            _over_all_pwr_back_info.power = 32.4 ;
            _over_all_pwr_back_info.freq = 50.1;
            _over_all_pwr_back_info.consumption = 36.8;
            _over_all_pwr_back_info.factor = 0.23 ;
        #endif
        ack_str = over_all_pwr_monitor_to_json(&_over_all_pwr_back_info);
        }
        //log_i(ack_str);
    }
    //打开所有开关
    else if(strcmp(_over_all_sts_monitor.type,"open")==0)
    {
        log_i("over all request:open");
        //总开
        int nSendAddr=0;
        char buff[256];
        GlobalPowerManger* _globalPowerMangerTemp = NULL ;
        list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
        {
            if(_globalPowerMangerTemp==NULL)
                break;
            if(_globalPowerMangerTemp->product_saddr==nSendAddr)continue;
            nSendAddr=_globalPowerMangerTemp->product_saddr;
            log_i("Open All address Start");
            int rec=g_switch_set_all_ctrl(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp->product_ch_type,_globalPowerMangerTemp->product_saddr,1);
            if(rec<0)log_i("Open All address:%d rec:%d:%s",nSendAddr,rec,modbus_strerror(errno));
            
        }
        sprintf(buff,"$开启$|$所有$|$通道$");
        dev_insert_alarm_ctrl(__globalDeviceManage.db,_globalPowerMangerTemp->product_id,3,buff);
        ack_str = ctrl_sts_ack_to_json();
    }   
    //关闭所有开关
    else if(strcmp(_over_all_sts_monitor.type,"close")==0)
    {
        log_i("over all request:close");
        //总关
        int nSendAddr=0;
        char buff[256];
        GlobalPowerManger* _globalPowerMangerTemp = NULL ;
        list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
        {
            if(_globalPowerMangerTemp==NULL)
                break;
            if(_globalPowerMangerTemp->product_saddr==nSendAddr)continue;
            nSendAddr=_globalPowerMangerTemp->product_saddr;
            log_i("Close All address Start");
            int rec=g_switch_set_all_ctrl(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp->product_ch_type,_globalPowerMangerTemp->product_saddr,0);
            if(rec<0)log_i("Close All address:%d rec:%d:%s",nSendAddr,rec,modbus_strerror(errno));
        }      
        sprintf(buff,"$关闭$|$所有$|$通道$");
        dev_insert_alarm_ctrl(__globalDeviceManage.db,_globalPowerMangerTemp->product_id,3,buff);
        ack_str = ctrl_sts_ack_to_json();
    }
    //查询历史记录   
    //ok
    else if(strcmp(_over_all_sts_monitor.type,"listHisQuery")==0)
    {
        #if 0
        log_i("over all request:listHisQuery");
        int ret = 0 ;
        int size = 0 ;
        int page_num = 0 ;
        int page_size = 0 ;

        page_num = atoi(_over_all_sts_monitor.page_num);
        page_size = atoi(_over_all_sts_monitor.page_size);

        GlobalPowerInfo _globalPowerInfo;
        
        INIT_LIST_HEAD(&_globalPowerInfo.list);
        ret = dev_search_power_info(__globalDeviceManage.db,
                                __globalDeviceManage._global_device_info->product_id,
                                0,
                                _over_all_sts_monitor.start_time,
                                _over_all_sts_monitor.end_time,
                                page_num,
                                page_size,
                                &size,
                                &_globalPowerInfo);
        if(ret!=0)
        {
            log_e("dev all status history get error.\n");
        }
        //返回应答
        ack_str = overall_power_history_to_json(&_globalPowerInfo,&__globalDeviceManage);

        //释放资源
        GlobalPowerInfo* node;
        GlobalPowerInfo* next;
        list_for_each_entry_safe(node, next, &_globalPowerInfo.list, list)
        {
            list_del(&node->list);
            free(node);
        } 
        #endif
    }   
    //电压统计 
    //1分钟1个点 6个小时 共360个点
    else if(strcmp(_over_all_sts_monitor.type,"listDyTotalQuery")==0)
    {
#if DBUG_INFO
        log_i("over all request: listDyTotalQuery\n");
#endif
        //申请电压统计信息参数
        GlobalPowerInfo __globalPowerInfo;
        //清0
        memset(&__globalPowerInfo,0,sizeof(GlobalPowerInfo));
        if (_over_all_sts_monitor.product_pwr_type==SmartPDU_Tree_AC_Tree)
        {
             ack_str = over_all_data_t_ac_to_json(&_over_all_pwr_back_info,&_over_all_sts_monitor, TOTAL_VOLTAGE_TYPE);
        }
        else
        {
        //查询数据库总电源信息 传给所申请的参数结构体
        if(dev_search_time_power_info(__globalDeviceManage.db,__globalDeviceManage._global_device_info->product_id,0,TOTAL_VOLTAGE_TYPE,&__globalPowerInfo,_over_all_sts_monitor.start_time,_over_all_sts_monitor.end_time)!=0)
        {
            log_e("serach total voltage err.");
        }
        //传值给总管理结构体
        #define TOTAL_COUNT 60
        for(int i=0;i< TOTAL_COUNT;i++)
        {
            strcpy(_over_all_pwr_back_info._total_voltage.xAxis[i],__globalPowerInfo._total_voltage.xAxis[i]);
            _over_all_pwr_back_info._total_voltage.ydata[i] = __globalPowerInfo._total_voltage.ydata[i];
        }

        //返回电压统计
        ack_str = over_all_total_info_to_json(&_over_all_pwr_back_info,TOTAL_VOLTAGE_TYPE);
        }
    }
    //电流统计
    else if(strcmp(_over_all_sts_monitor.type,"listDlTotalQuery")==0)
    {
#if DBUG_INFO
        log_i("over all request: listDlTotalQuery\n");
#endif
        //申请电流统计信息参数
        GlobalPowerInfo __globalPowerInfo;
        //清0
        memset(&__globalPowerInfo,0,sizeof(GlobalPowerInfo));
        if (_over_all_sts_monitor.product_pwr_type == SmartPDU_Tree_AC_Tree)
        {
            ack_str = over_all_data_t_ac_to_json(&_over_all_pwr_back_info, &_over_all_sts_monitor, TOTAL_CURRENT_TYPE);
        }
        else
        {
        //查询数据库总电源信息 传给所申请的参数结构体
        if(dev_search_time_power_info(__globalDeviceManage.db,__globalDeviceManage._global_device_info->product_id,0,TOTAL_CURRENT_TYPE,&__globalPowerInfo,_over_all_sts_monitor.start_time,_over_all_sts_monitor.end_time)!=0)
        {
            log_e("serach total current err.");
        }
        //传值给总管理结构体
        for(int i=0;i< TOTAL_COUNT;i++)
        {
            strcpy(_over_all_pwr_back_info._total_current.xAxis[i],__globalPowerInfo._total_current.xAxis[i]);
            _over_all_pwr_back_info._total_current.ydata[i] = __globalPowerInfo._total_current.ydata[i];
        }

        //返回电流统计
        ack_str = over_all_total_info_to_json(&_over_all_pwr_back_info,TOTAL_CURRENT_TYPE);
        }
    }
    //功率统计
    else if(strcmp(_over_all_sts_monitor.type,"listGlTotalQuery")==0)
    {
#if DBUG_INFO
        log_i("over all request: listGlTotalQuery\n");
#endif
        //申请功率统计信息参数
        GlobalPowerInfo __globalPowerInfo;
        //清0
        memset(&__globalPowerInfo,0,sizeof(GlobalPowerInfo));
        if (_over_all_sts_monitor.product_pwr_type == SmartPDU_Tree_AC_Tree)
        {
            ack_str = over_all_data_t_ac_to_json(&_over_all_pwr_back_info, &_over_all_sts_monitor, TOTAL_POWER_TYPE);
        }
        else
        {
        //查询数据库总电源信息 传给所申请的参数结构体
        if(dev_search_time_power_info(__globalDeviceManage.db,__globalDeviceManage._global_device_info->product_id,0,TOTAL_POWER_TYPE,&__globalPowerInfo,_over_all_sts_monitor.start_time,_over_all_sts_monitor.end_time)!=0)
        {
            log_e("serach total power err.");
        }
        //传值给总管理结构体
        for(int i=0;i< TOTAL_COUNT;i++)
        {
            strcpy(_over_all_pwr_back_info._total_power.xAxis[i],__globalPowerInfo._total_power.xAxis[i]);
            _over_all_pwr_back_info._total_power.ydata[i] = __globalPowerInfo._total_power.ydata[i];
        }

        //返回功率统计
        ack_str = over_all_total_info_to_json(&_over_all_pwr_back_info,TOTAL_POWER_TYPE);
        }
    }
    //耗电量统计
    else if(strcmp(_over_all_sts_monitor.type,"listHdlTotalQuery")==0)
    {
#if DBUG_INFO
        log_i("over all request: listHdlTotalQuery\n");
#endif
        //申请耗电量统计信息参数
        GlobalPowerInfo __globalPowerInfo;
        //清0
        memset(&__globalPowerInfo,0,sizeof(GlobalPowerInfo));
        if (_over_all_sts_monitor.product_pwr_type == SmartPDU_Tree_AC_Tree)
        {
            ack_str = over_all_data_t_ac_to_json(&_over_all_pwr_back_info, &_over_all_sts_monitor, TOTAL_POWER_CONS_TYPE);
        }
        else
        {
        //查询数据库总电源信息 传给所申请的参数结构体
        if(dev_search_time_power_info(__globalDeviceManage.db,__globalDeviceManage._global_device_info->product_id,0,TOTAL_POWER_CONS_TYPE,&__globalPowerInfo,_over_all_sts_monitor.start_time,_over_all_sts_monitor.end_time)!=0)
        {
            log_e("serach total power consumption err.");
        }
        //传值给总管理结构体
        for(int i=0;i< TOTAL_COUNT;i++)
        {
            strcpy(_over_all_pwr_back_info._total_consumption.xAxis[i],__globalPowerInfo._total_consumption.xAxis[i]);
            _over_all_pwr_back_info._total_consumption.ydata[i] = __globalPowerInfo._total_consumption.ydata[i];
        }

        //返回耗电量统计
        ack_str = over_all_total_info_to_json(&_over_all_pwr_back_info,TOTAL_POWER_CONS_TYPE);
        }
    }
    //查询系统总数情况
    else if(strcmp(_over_all_sts_monitor.type,"listTotalQuery")==0)
    {
#if DBUG_INFO
        log_i("over all request: listTotalQuery\n");
#endif
        //初始化系统总数结构体
        SystemTotalInfo __system_total_info;
        memset(&__system_total_info, 0, sizeof(SystemTotalInfo));
        struct tm *t;
        struct timeval tv;
        char start_time[32] = {0};
        char stop_time[32] = {0};

        gettimeofday(&tv, NULL);
        t = localtime(&tv.tv_sec);
        sprintf(start_time, "%04d-%02d-%02d %02d:%02d:%02d", t->tm_year + 1900, t->tm_mon+1, t->tm_mday, 0,0,0);
        //sprintf(start_time, "%04d-%02d-%02d %02d:%02d:%02d", 1970, 1, 1, 0,0,0);
        log_d(start_time);

        sprintf(stop_time, "%04d-%02d-%02d %02d:%02d:%02d", t->tm_year + 1900, t->tm_mon+1, t->tm_mday, 23,59, 59);
        //sprintf(stop_time, "%04d-%02d-%02d %02d:%02d:%02d", 1970, 1, 1, 23,59, 59);
        log_d(stop_time);
        //从数据库获取参数信息
        if(dev_get_system_total_info(__globalDeviceManage.db,__globalDeviceManage._global_device_info->product_id,0,&__system_total_info,start_time,stop_time)!=0)
        {
            log_e("serach total System total err.");
        }
        int nSumChannel=0;
        GlobalPowerManger* _globalPowerMangerTemp = NULL ;
        list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
        {
            nSumChannel+=1;
        }
        __system_total_info.channel_total = nSumChannel ;


        //获取通道总数
        // __GetSystemTotalInfo.channel_total = _globalDeviceManager->useSlaveCount;
        //获取系统总数情况
        _over_back_sts_info.system_total.channel_total  = __system_total_info.channel_total;
		_over_back_sts_info.system_total.log_total      = __system_total_info.log_total;
		_over_back_sts_info.system_total.sensor_total   = __system_total_info.sensor_total;
		_over_back_sts_info.system_total.warn_total     = __system_total_info.warn_total;

        //返回系统总数情况
        ack_str = over_system_total_monitor_to_json(&_over_back_sts_info);
    }
    //功率趋势图接口
    else if(strcmp(_over_all_sts_monitor.type,"listGlAllTotalQuery")==0)
    {
#if DBUG_INFO
        log_i("over all request: listGlAllTotalQuery\n");
#endif
        //初始化功率趋势图参数
        GlobalPowerInfo __PowerTrendInfo;
        //清0
        memset(&__PowerTrendInfo,0,sizeof(GlobalPowerInfo));
        #if 1
        //查询数据库总电源信息 传给所申请的参数结构体
        if(dev_search_power_trend_info(__globalDeviceManage.db,__globalDeviceManage._global_device_info->product_id,0,&__PowerTrendInfo,_over_all_sts_monitor.start_time,_over_all_sts_monitor.end_time)!=0)
        {
            log_e("serach total power consumption err.");
        }

        //传值给总管理结构体
        for(int i=0;i< TOTAL_COUNT;i++)
        {
            strcpy(_over_all_pwr_back_info._Power_Trend_Info.xAxis[i],__PowerTrendInfo._power_trend_info.xAxis[i]);
            _over_all_pwr_back_info._Power_Trend_Info.ydata[POWER_MERITORIOUS_TYPE][i] = __PowerTrendInfo._power_trend_info.ydata[POWER_MERITORIOUS_TYPE][i];
            _over_all_pwr_back_info._Power_Trend_Info.ydata[POWER_REACTIVE_TYPE][i] = __PowerTrendInfo._power_trend_info.ydata[POWER_REACTIVE_TYPE][i];
            _over_all_pwr_back_info._Power_Trend_Info.ydata[POWER_APPARENT_TYPE][i] = __PowerTrendInfo._power_trend_info.ydata[POWER_APPARENT_TYPE][i];
        }
      #else   
        for(int i=0;i< TOTAL_COUNT;i++)
        {
            strcpy(_over_all_pwr_back_info._Power_Trend_Info.xAxis[i],"00:00 ");
            _over_all_pwr_back_info._Power_Trend_Info.ydata[POWER_MERITORIOUS_TYPE][i] = 10+i;
            _over_all_pwr_back_info._Power_Trend_Info.ydata[POWER_REACTIVE_TYPE][i] = 20+i;
            _over_all_pwr_back_info._Power_Trend_Info.ydata[POWER_APPARENT_TYPE][i] = 30+i;
        }
#endif
        //返回功率趋势
        ack_str = over_power_trend_to_json(&_over_all_pwr_back_info);
    }
    #endif
    #endif
    
    http_reply(conn, 200, ack_str);

    cJSON_free((void*)ack_str);
}

/// @brief 电源通道
/// @param stream 
static void channelStatusMonitoring(void* conn)
{
    int ret = -1 ;
    _OverChnPwrRequest _over_chn_pwr_request;
    _OverAllPwrAckInfo _over_all_pwr_back_info; //设备电源信息
    char* rx_body_buf = NULL;
    char* ack_str = NULL ;

#ifdef USE_WEBAPP
    HttpStream *s=(HttpStream*)conn;
    rx_body_buf = httpGetBodyInput(s);
#else
    mg_stream_t *s=(mg_stream_t*)conn;
    struct mg_http_message *msg=s->ev_data;
    rx_body_buf = msg->body.buf;
#endif

    //转换json参数
    memset(&_over_chn_pwr_request,0,sizeof(_OverChnPwrRequest));
    if(json_to_chn_pwr_status_monitor(rx_body_buf,&_over_chn_pwr_request)!=0)
    {
        http_reply(conn, 400, NULL);
        return ;        
    }

   

    #if(1)
    //查询
    if(strcmp(_over_chn_pwr_request.type,"listQuery")==0||strcmp(_over_chn_pwr_request.type,"resetChannel")==0)
    {
        //log_i("channel status request:listQuery");

        //log_d(rx_body_buf);
        if (strcmp(_over_chn_pwr_request.type,"resetChannel")==0)
        {
            //__globalDeviceManage._ReloadChm_flag=true;
            //ResetChmData();
            //__globalDeviceManage._ReloadChm_flag=false;
        }

        GlobalPowerInfo _powerInfo;
        GlobalPowerManger* _globalPowerMangerTemp = NULL ;
        int product_chn_id = 0 ;
        //查询json参数
        /*
        * todo:
        */

        __globalDeviceManage.view_page = 2 ; //通道信息

        cur_dev_addr = _over_chn_pwr_request.product_id;
        if(cur_dev_addr>0) {
            ack_str = ctrl_sts_ack_to_json();
            http_reply(conn, 200, ack_str);
            cJSON_free((void *)ack_str);
            return;
        }

        if(_over_chn_pwr_request.productChId==NULL)
        {
            //log_d("param no chn id.");
        }
        else
        {
            // product_chn_id = strtol(_over_chn_pwr_request.productChId,NULL,10);
            product_chn_id = _over_chn_pwr_request.productChId;
            log_d("product_chn_id:%d",product_chn_id);
        }
        _OverChnPwrAckInfo _over_chn_pwr_back_info;
        INIT_LIST_HEAD(&_over_chn_pwr_back_info.list);
        #if(1)
       //未指定通道 检索所有通道
        if(product_chn_id==0)
        {
            dev_search_latest_power_All_info(&__globalDeviceManage,&_over_chn_pwr_back_info);
            /*
            list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
            {
                //log_d("start serach ch%d.",_globalPowerMangerTemp->product_ch_id);
                _OverChnPwrAckInfo* _overChnPwrBackInfoTemp = (_OverChnPwrAckInfo*)malloc(sizeof(_OverChnPwrAckInfo));
                if(_overChnPwrBackInfoTemp==NULL)
                {
                    log_e("_overChnPwrBackInfoTemp malloc err.");
                }
                //查询数据库总电源信息
                if(dev_search_latest_power_info(__globalDeviceManage.db,__globalDeviceManage._global_device_info->product_id,_globalPowerMangerTemp->product_ch_id,&_powerInfo)!=0)
                {
                    log_e("serach total pwr err.");
                }
                else
                {   
                    //填数据
                    _overChnPwrBackInfoTemp->product_name = __globalDeviceManage._global_device_info->product_name;
                    _overChnPwrBackInfoTemp->product_number = __globalDeviceManage._global_device_info->product_number; 
                    _overChnPwrBackInfoTemp->product_id = __globalDeviceManage._global_device_info->product_id;  
                    _overChnPwrBackInfoTemp->productChName = _globalPowerMangerTemp->product_ch_name;
                    _overChnPwrBackInfoTemp->productChId = _globalPowerMangerTemp->product_ch_id;
                    _overChnPwrBackInfoTemp->status = _powerInfo._power_info.status;
                    _overChnPwrBackInfoTemp->voltage = _powerInfo._power_info.voltage;
                    _overChnPwrBackInfoTemp->current = _powerInfo._power_info.current;
                    _overChnPwrBackInfoTemp->power = _powerInfo._power_info.power ;
                    _overChnPwrBackInfoTemp->freq = _powerInfo._power_info.freq ;
                    _overChnPwrBackInfoTemp->consumption = _powerInfo._power_info.consumption ;
                    _overChnPwrBackInfoTemp->factor = _powerInfo._power_info.factor ;
                
                    list_add_tail(&_overChnPwrBackInfoTemp->list,&_over_chn_pwr_back_info.list);
                    //log_d("serach ch%d pwr ok.",_globalPowerMangerTemp->product_ch_id);
                }
            }*/
        }
        else //指定通道
        {

            //log_d("222222222222222222");
            list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
            {
                if(product_chn_id==_globalPowerMangerTemp->product_ch_id)
                {
                    break;
                }
            }
            //更新数据
            
            //log_d("serach ch%d pwr ok.",product_chn_id);
            _OverChnPwrAckInfo* _overChnPwrBackInfoTemp = (_OverChnPwrAckInfo*)malloc(sizeof(_OverChnPwrAckInfo));
            if(_overChnPwrBackInfoTemp==NULL)
            {
                log_e("_overChnPwrBackInfoTemp malloc err.");
            }
            //查询数据库总电源信息
            if(dev_search_latest_power_info(__globalDeviceManage.db,
            __globalDeviceManage._global_device_info->product_id,
            product_chn_id,
            &_powerInfo)!=0)
            {
                log_e("serach total pwr err.");
            }
            {
                //填数据
                _overChnPwrBackInfoTemp->product_name = __globalDeviceManage._global_device_info->product_name;
                _overChnPwrBackInfoTemp->product_number = __globalDeviceManage._global_device_info->product_number; 
                _overChnPwrBackInfoTemp->product_id = __globalDeviceManage._global_device_info->product_id;  
                _overChnPwrBackInfoTemp->productChName = _globalPowerMangerTemp->product_ch_name;
                _overChnPwrBackInfoTemp->productChId = _globalPowerMangerTemp->product_ch_id;
                _overChnPwrBackInfoTemp->status = _powerInfo._power_info.status; 
                _overChnPwrBackInfoTemp->voltage = _powerInfo._power_info.voltage;
                _overChnPwrBackInfoTemp->current = _powerInfo._power_info.current;
                _overChnPwrBackInfoTemp->power = _powerInfo._power_info.power ;
                _overChnPwrBackInfoTemp->freq = _powerInfo._power_info.freq ;
                _overChnPwrBackInfoTemp->consumption = _powerInfo._power_info.consumption ;
                _overChnPwrBackInfoTemp->factor = _powerInfo._power_info.factor ;
                list_add_tail(&_overChnPwrBackInfoTemp->list,&_over_chn_pwr_back_info.list);                
            }
        }
        //参数转换json
        ack_str = over_chn_pwr_monitor_to_json(&_over_chn_pwr_back_info);
        //释放资源
        _OverChnPwrAckInfo* node;
        _OverChnPwrAckInfo*  next;
        list_for_each_entry_safe(node, next, &_over_chn_pwr_back_info.list, list)
        {
            list_del(&node->list);
            free(node);
        } 
        #endif



    }
    else if(strcmp(_over_chn_pwr_request.type,"open")==0)//通道开
    {
        int ret=0;
        int product_chn_id = 0 ;
        char buff[256];
        log_i("channel status request:open");
        /*
        * todo:添加控制
        */
       
       
        log_d("channel id:%d",_over_chn_pwr_request.productChId);


        // product_chn_id = strtol(_over_chn_pwr_request.productChId,NULL,10);
        // log_d("productChId:%d",product_chn_id);
        
        product_chn_id = _over_chn_pwr_request.productChId;
        GlobalPowerManger* _globalPowerMangerTemp = NULL ;
        list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
        {
            //log_d("channel:%d", _globalPowerMangerTemp->product_ch_id);
            if(_globalPowerMangerTemp==NULL)
                break;
            if(product_chn_id==_globalPowerMangerTemp->product_ch_id)
            {
                log_d("switch ctrl:%d",_globalPowerMangerTemp->product_ch_id);
                ret=g_switch_set_all_chn_ctrl(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp,
                _globalPowerMangerTemp->product_saddr,
                _globalPowerMangerTemp->product_ch_addr, 
                1,false);
                if (ret < 0)
                {
                    ret = g_switch_set_all_chn_ctrl(&__globalDeviceManage._globalRelaySampManger, _globalPowerMangerTemp,
                                                    _globalPowerMangerTemp->product_saddr,
                                                    _globalPowerMangerTemp->product_ch_addr,
                                                    1,false);
                }
                sprintf(buff,"$开启$|$通道$|%d",_globalPowerMangerTemp->product_ch_id);
                dev_insert_alarm_ctrl(__globalDeviceManage.db,_globalPowerMangerTemp->product_id,3,buff);
                break;
            }
        }
        ack_str = ctrl_sts_ack_to_json();
    }
    else if(strcmp(_over_chn_pwr_request.type,"close")==0)//通道关
    {
        log_i("channel status request:close");
        /*
        * todo:添加控制
        */
        char buff[256];
        int product_chn_id = 0 ;
        // product_chn_id = strtol(_over_chn_pwr_request.productChId,NULL,10);
        // log_d("productChId:%d",product_chn_id);
        product_chn_id = _over_chn_pwr_request.productChId;
        GlobalPowerManger* _globalPowerMangerTemp = NULL ;
        list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
        {
            if(_globalPowerMangerTemp==NULL)
                break;
            if(product_chn_id==_globalPowerMangerTemp->product_ch_id)
            {
                //log_d("switch ctrl:%d",_globalPowerMangerTemp->product_ch_id);
                ret=g_switch_set_all_chn_ctrl(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp,
                _globalPowerMangerTemp->product_saddr,
                _globalPowerMangerTemp->product_ch_addr ,//多版端口余8 
                0,false);
                if (ret < 0)
                {
                    ret = g_switch_set_all_chn_ctrl(&__globalDeviceManage._globalRelaySampManger, _globalPowerMangerTemp,
                                                    _globalPowerMangerTemp->product_saddr,
                                                    _globalPowerMangerTemp->product_ch_addr, // 多版端口余8
                                                    0,false);
                    /* code */
                }

                sprintf(buff,"$关闭$|$通道$|%d",_globalPowerMangerTemp->product_ch_id);
                dev_insert_alarm_ctrl(__globalDeviceManage.db,_globalPowerMangerTemp->product_id,3,buff);
                break;
            }
        }
        ack_str = ctrl_sts_ack_to_json();
    }
    else if(strcmp(_over_chn_pwr_request.type,"save")==0)//负载
    {
        log_i("channel status request:save");
        log_d(rx_body_buf);
        GlobalPowerManger *_globalPowerMangerTemp = NULL;
        list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
        {
            if (_over_chn_pwr_request.productChId == _globalPowerMangerTemp->product_ch_id)
            {
                break;
            }
        }

        if (_globalPowerMangerTemp != NULL)
        {
            if (strlen(_over_chn_pwr_request.productChName)<32)
            {
                strcpy(_globalPowerMangerTemp->product_ch_name, _over_chn_pwr_request.productChName);
                if (dev_update_power_manage_genera_info(__globalDeviceManage.db, __globalDeviceManage._global_device_info->product_id, _globalPowerMangerTemp->product_ch_id, _globalPowerMangerTemp) != 0)
                {
                    log_e("update pwr general data err.");
                }
            }else{
                log_e("ChName too long.");
            }
        }

        ack_str = ctrl_sts_ack_to_json();
    }
    else if(strcmp(_over_chn_pwr_request.type,"listHisQuery")==0) //历史记录查询
    {
        #if 0
        int ret = 0 ;
        int size = 0 ;
        int h_pwrchn = 0 ;
        int page_num = 0 ;
        int page_size = 0 ;
        GlobalPowerInfo _globalPowerInfo;
        INIT_LIST_HEAD(&_globalPowerInfo.list);
        h_pwrchn = strtol(_over_chn_pwr_request.productChId,NULL,10);
        page_num = atoi(_over_chn_pwr_request.pageNum);
        page_size = atoi(_over_chn_pwr_request.pageSize);
        //查询数据
        ret = dev_search_power_info(__globalDeviceManage.db,
                                __globalDeviceManage._global_device_info->product_id,
                                h_pwrchn,
                                _over_chn_pwr_request.start_time,
                                _over_chn_pwr_request.end_time,
                                page_num,
                                page_size,
                                &size,
                                &_globalPowerInfo);
        if(ret!=0)
        {
            log_e("dev all status history get error.\n");
        }
        //应答
        ack_str = over_channel_power_history_to_json(&_globalPowerInfo,
                                                    &__globalDeviceManage._global_device_info, 
                                                    _over_chn_pwr_request.productChName,
                                                    h_pwrchn);

        //释放资源
        GlobalPowerInfo*  node;
        GlobalPowerInfo*  next;
        list_for_each_entry_safe(node, next, &_globalPowerInfo.list, list)
        {
            list_del(&node->list);
            free(node);
        } 
        #endif                                        
    }
    else if(strcmp(_over_chn_pwr_request.type,"listDyTotalQuery")==0)
    {
#if DBUG_INFO
        log_i("over all request: listDyTotalQuery\n");
#endif

        int product_chn_id = 0 ;
        product_chn_id = _over_chn_pwr_request.productChId;
        log_d("productChId:%d",product_chn_id);
        log_i("channel status request:listDyTotalQuery");
        log_d("productChId:%d",_over_chn_pwr_request.productChId);
        log_d("start_time:%s",_over_chn_pwr_request.start_time);
        log_d("end_time:%s",_over_chn_pwr_request.end_time);
        log_d("lType:%s",_over_chn_pwr_request.lType);
        log_d("type:%s",_over_chn_pwr_request.type);
        log_d("user_token:%s",_over_chn_pwr_request.user_token);
        //ack_str = ctrl_sts_ack_to_json();
        #if(1)
        //申请电压统计信息参数
        GlobalPowerInfo __globalPowerInfo;
        //清0
        memset(&__globalPowerInfo,0,sizeof(GlobalPowerInfo));
        //查询数据库总电源信息 传给所申请的参数结构体
        if(dev_search_time_power_info(__globalDeviceManage.db,__globalDeviceManage._global_device_info->product_id,product_chn_id,TOTAL_VOLTAGE_TYPE,&__globalPowerInfo,_over_chn_pwr_request.start_time,_over_chn_pwr_request.end_time)!=0)
        {
            log_e("serach total voltage err.");
        }
        //传值给总管理结构体
        #define TOTAL_COUNT 60
        for(int i=0;i< TOTAL_COUNT;i++)
        {
            strcpy(_over_all_pwr_back_info._total_voltage.xAxis[i],__globalPowerInfo._total_voltage.xAxis[i]);
            _over_all_pwr_back_info._total_voltage.ydata[i] = __globalPowerInfo._total_voltage.ydata[i];
        }
        //返回电压统计
        ack_str = over_all_total_info_to_json(&_over_all_pwr_back_info,TOTAL_VOLTAGE_TYPE);
        #endif
    }
    //电流统计
    else if(strcmp(_over_chn_pwr_request.type,"listDlTotalQuery")==0)
    {
#if DBUG_INFO
        log_i("over all request: listDlTotalQuery\n");
#endif

        int product_chn_id = 0 ;
        log_i("channel status request:open");
        product_chn_id = _over_chn_pwr_request.productChId;
        log_d("productChId:%d",product_chn_id);

        //申请电流统计信息参数
        GlobalPowerInfo __globalPowerInfo;
        //清0
        memset(&__globalPowerInfo,0,sizeof(GlobalPowerInfo));
        //查询数据库总电源信息 传给所申请的参数结构体
        if(dev_search_time_power_info(__globalDeviceManage.db,__globalDeviceManage._global_device_info->product_id,product_chn_id,TOTAL_CURRENT_TYPE,&__globalPowerInfo,_over_chn_pwr_request.start_time,_over_chn_pwr_request.end_time)!=0)
        {
            log_e("serach total current err.");
        }
        //传值给总管理结构体
        for(int i=0;i< TOTAL_COUNT;i++)
        {
            strcpy(_over_all_pwr_back_info._total_current.xAxis[i],__globalPowerInfo._total_current.xAxis[i]);
            _over_all_pwr_back_info._total_current.ydata[i] = __globalPowerInfo._total_current.ydata[i];
        }

        //返回电流统计
        ack_str = over_all_total_info_to_json(&_over_all_pwr_back_info,TOTAL_CURRENT_TYPE);
    }
    //功率统计
    else if(strcmp(_over_chn_pwr_request.type,"listGlTotalQuery")==0)
    {
#if DBUG_INFO
        log_i("over all request: listGlTotalQuery\n");
#endif

       int product_chn_id = 0 ;
        log_i("channel status request:open");
        product_chn_id = _over_chn_pwr_request.productChId;
        log_d("productChId:%d",product_chn_id);

        //申请功率统计信息参数
        GlobalPowerInfo __globalPowerInfo;
        //清0
        memset(&__globalPowerInfo,0,sizeof(GlobalPowerInfo));
        //查询数据库总电源信息 传给所申请的参数结构体
        if(dev_search_time_power_info(__globalDeviceManage.db,__globalDeviceManage._global_device_info->product_id,product_chn_id,TOTAL_POWER_TYPE,&__globalPowerInfo,_over_chn_pwr_request.start_time,_over_chn_pwr_request.end_time)!=0)
        {
            log_e("serach total power err.");
        }
        //传值给总管理结构体
        for(int i=0;i< TOTAL_COUNT;i++)
        {
            strcpy(_over_all_pwr_back_info._total_power.xAxis[i],__globalPowerInfo._total_power.xAxis[i]);
            _over_all_pwr_back_info._total_power.ydata[i] = __globalPowerInfo._total_power.ydata[i];
        }

        //返回功率统计
        ack_str = over_all_total_info_to_json(&_over_all_pwr_back_info,TOTAL_POWER_TYPE);
    }
    //耗电量统计
    else if(strcmp(_over_chn_pwr_request.type,"listHdlTotalQuery")==0)    
    {
        #if DBUG_INFO
                log_i("over all request: listHdlTotalQuery\n");
        #endif

        int product_chn_id = 0 ;
        log_i("channel status request:open");
        product_chn_id = _over_chn_pwr_request.productChId;
        log_d("productChId:%d",product_chn_id);

        //申请耗电量统计信息参数
        GlobalPowerInfo __globalPowerInfo;
        //清0
        memset(&__globalPowerInfo,0,sizeof(GlobalPowerInfo));
        //查询数据库总电源信息 传给所申请的参数结构体
        if(dev_search_time_power_info(__globalDeviceManage.db,__globalDeviceManage._global_device_info->product_id,product_chn_id,TOTAL_POWER_CONS_TYPE,&__globalPowerInfo,_over_chn_pwr_request.start_time,_over_chn_pwr_request.end_time)!=0)
        {
            log_e("serach total power consumption err.");
        }
        //传值给总管理结构体
        for(int i=0;i< TOTAL_COUNT;i++)
        {
            strcpy(_over_all_pwr_back_info._total_consumption.xAxis[i],__globalPowerInfo._total_consumption.xAxis[i]);
            _over_all_pwr_back_info._total_consumption.ydata[i] = __globalPowerInfo._total_consumption.ydata[i];
        }

        //返回耗电量统计
        ack_str = over_all_total_info_to_json(&_over_all_pwr_back_info,TOTAL_POWER_CONS_TYPE);        
    }
    else if(strcmp(_over_chn_pwr_request.type,"threeTypeSave")==0)
    {
        GlobalPowerManger *_globalPowerMangerTemp = NULL;
        list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
        {
            if (_over_chn_pwr_request.productChId == _globalPowerMangerTemp->product_ch_id)
            {
                break;
            }
        }
        if (__globalDeviceManage._global_device_info->product_pwr_type == SmartPDU_Tree_AC_One)
        {
            if (_over_chn_pwr_request.outputType == 1)
            {
                http_reply(conn, 201, ack_str);
                cJSON_free((void *)ack_str);
                return;
            }
        }
        if (_globalPowerMangerTemp != NULL)
        {            
            GlobalTreeACManager *_globalTACManager = NULL;
            list_for_each_entry(_globalTACManager, &_globalPowerMangerTemp->list_Tree_AC, list_Tree_AC)
            {
                if (_over_chn_pwr_request.outputType == 2)
                {
                    if (strcmp(g_product_t_ac_type_str[_globalTACManager->product_ph_type], _over_chn_pwr_request.productPhOrder) == 0)
                    {
                        _globalTACManager->product_ph_outputStatus = 1;
                    }
                    else
                    {
                        _globalTACManager->product_ph_outputStatus = 2;
                    }
                }
                else
                {
                    _globalTACManager->product_ph_outputStatus = 1;
                }
                _globalTACManager->product_ph_outputType=_over_chn_pwr_request.outputType;
                if (dev_update_t_ac_power_manage_info(__globalDeviceManage.db, _globalTACManager) != 0)
                {
                    log_e("update pwr general data err.");
                }
            }
        }
    }

    #endif
    
    http_reply(conn, 200, ack_str);
    cJSON_free((void*)ack_str);
}


/// @brief 传感器状态请求应答
/// @param stream 
static void sensorStatusMonitoring(void* conn)
{
    __globalDeviceManage.view_page=-1;
    int ret = -1 ;
    _OverSensorRequest _over_all_sensor_request;
    _OverSensorBackInfo _over_all_sensor_back_info;
    GlobalSensorManger _globalSensorMangerTemp ;
    GlobalSensorInfo _globalSensorInfo;
    char* rx_body_buf = NULL;
    char* ack_str = NULL ;

#ifdef USE_WEBAPP
    HttpStream *s=(HttpStream*)conn;
    rx_body_buf = httpGetBodyInput(s);
#else
    mg_stream_t *s=(mg_stream_t*)conn;
    struct mg_http_message *msg=s->ev_data;
    rx_body_buf = msg->body.buf;
#endif
    //转换json参数
    if(json_to_sensor_manage(rx_body_buf,&_over_all_sensor_request)!=0)
    {
        http_reply(conn, 400, NULL);
        return ;        
    } 
    //查询json参数
    if(strcmp(_over_all_sensor_request.type,"listQuery")==0)
    {
        log_d("start listQuery handle.");
        
        #if(1)
        //链表初始化
        INIT_LIST_HEAD(&_over_all_sensor_back_info.list);
        //获取传感器当前的最新值
        GlobalSensorManger* _globalSensorManagerTemp = NULL;
        list_for_each_entry(_globalSensorManagerTemp, &__globalDeviceManage._globalSensorManger.list, list)
        {
            _OverSensorBackInfo* _overSensorBackInfoTemp = (_OverSensorBackInfo*)malloc(sizeof(_OverSensorBackInfo));
            if(_overSensorBackInfoTemp==NULL)
                log_e("_OverSensorBackInfo malloc error.");
            memset(_overSensorBackInfoTemp,0,sizeof(_OverSensorBackInfo));
            //基本信息
            _overSensorBackInfoTemp->sensorId = _globalSensorManagerTemp->sensor_id;
            memcpy(&_overSensorBackInfoTemp->sensorName,&_globalSensorManagerTemp->sensor_name,sizeof(_overSensorBackInfoTemp->sensorName));
            //strcpy(_overSensorBackInfoTemp->sensorName,_globalSensorManagerTemp->sensor_name);
            _overSensorBackInfoTemp->sensorType = _globalSensorManagerTemp->sensor_type;
            memcpy(&_overSensorBackInfoTemp->comSlogan,&_globalSensorManagerTemp->sensor_port_name,sizeof(_overSensorBackInfoTemp->comSlogan));
            //strcpy(_overSensorBackInfoTemp->comSlogan,_globalSensorManagerTemp->sensor_port_name);

            //485独有
            if(_globalSensorManagerTemp->sensor_interface_type==1)
            {
                _overSensorBackInfoTemp->sensorAddr = _globalSensorManagerTemp->sensor_addr ;
                _overSensorBackInfoTemp->sensorBaud = _globalSensorManagerTemp->sensor_baud;
                strcpy(_overSensorBackInfoTemp->sensorvaluech,"RS485");
            }
            else
            {
                 strcpy(_overSensorBackInfoTemp->sensorvaluech,"IN");
            }
            _overSensorBackInfoTemp->connectionStatus = _globalSensorManagerTemp->sensor_status;
            _overSensorBackInfoTemp->nodeNumber = __globalDeviceManage._globalSensorManger.sensor_node_number;
            //拿数据
            memset(&_globalSensorInfo, 0, sizeof(_globalSensorInfo));
            switch(_globalSensorManagerTemp->sensor_type)
            {
                case 0://温湿度传感器 2个值
                {
                   
                    ret = dev_serach_latest_sensor_info(__globalDeviceManage.db,
                                                __globalDeviceManage._global_device_info->product_id,
                                                _overSensorBackInfoTemp->sensorId,
                                                &_globalSensorInfo);
                    if(ret!=0)
                        log_e("get temp sensor info error.");
                    _overSensorBackInfoTemp->temperatureValue = _globalSensorInfo.val1;
                    _overSensorBackInfoTemp->humidityValue = _globalSensorInfo.val2;
                     _overSensorBackInfoTemp->temperatureValue=__globalDeviceManage.g_modebus_read.temprature/1000;
                     _overSensorBackInfoTemp->humidityValue=__globalDeviceManage.g_modebus_read.humidity/1000;
                }break; 
                case 1://烟雾传感器 1个值
                {
                    ret = dev_serach_latest_sensor_info(__globalDeviceManage.db,
                                                __globalDeviceManage._global_device_info->product_id,
                                                _overSensorBackInfoTemp->sensorId,
                                                &_globalSensorInfo);
                    if(ret!=0)
                        log_e("get temp sensor info error.") ;   
                    _overSensorBackInfoTemp->alarmStatus = !_globalSensorInfo.val1; // 1/0 报警未报警
                }break; 
                case 2://水浸传感器 1个值  c
                {
                    ret = dev_serach_latest_sensor_info(__globalDeviceManage.db,
                                                __globalDeviceManage._global_device_info->product_id,
                                                _overSensorBackInfoTemp->sensorId,
                                                &_globalSensorInfo);
                    if(ret!=0)
                        log_e("get temp sensor info error.") ;   
                    _overSensorBackInfoTemp->waterImmersionState = !_globalSensorInfo.val1; // 1/0 报警未报警
                }break; 
                case 3://门禁传感器 
                {
                    ret = dev_serach_latest_sensor_info(__globalDeviceManage.db,
                                                __globalDeviceManage._global_device_info->product_id,
                                                _overSensorBackInfoTemp->sensorId,
                                                &_globalSensorInfo);
                    if(ret!=0)
                        log_e("get temp sensor info error.") ;   
                    _overSensorBackInfoTemp->accessControlStatus =  !_globalSensorInfo.val1; // 1/0 报警未报警
                }break; 
                case 4: //气体传感器 1个值
                {
                    ret = dev_serach_latest_sensor_info(__globalDeviceManage.db,
                                                __globalDeviceManage._global_device_info->product_id,
                                                _overSensorBackInfoTemp->sensorId,
                                                &_globalSensorInfo);
                    if(ret!=0)
                        log_e("get temp sensor info error.");    
                    _overSensorBackInfoTemp->gasConcentration =  _globalSensorInfo.val1; // 气体浓度
                }break;
                case 5://气压气流传感器 2个值
                {
                    ret = dev_serach_latest_sensor_info(__globalDeviceManage.db,
                                                __globalDeviceManage._global_device_info->product_id,
                                                _overSensorBackInfoTemp->sensorId,
                                                &_globalSensorInfo);
                    if(ret!=0)
                        log_e("get temp sensor info error.") ;   
                    _overSensorBackInfoTemp->airPressureValue =  _globalSensorInfo.val1; // 气压
                    _overSensorBackInfoTemp->airflowValue =  _globalSensorInfo.val2; // 气流
                };break; 
                case 6://空调遥控器 没有值
                {

                }break; 
            }
            // log_d("sensor_id: %d",_overSensorBackInfoTemp->sensorId);
            // log_d("sensor_name: %s",_overSensorBackInfoTemp->sensorName);
            // log_d("sensor_type: %d",_overSensorBackInfoTemp->sensorType);
            // log_d("sensor_port_name: %s",_overSensorBackInfoTemp->comSlogan);
            // log_d("sensor_addr: %d",_overSensorBackInfoTemp->sensorAddr);
            // log_d("sensor_baud: %d",_overSensorBackInfoTemp->sensorBaud);
            //入队
            list_add_tail(&_overSensorBackInfoTemp->list,&_over_all_sensor_back_info.list);
        }    
        //参数转换json
        
        ack_str = over_all_sensor_info_to_json(&_over_all_sensor_back_info);

        //释放资源
        _OverSensorBackInfo* node;
        _OverSensorBackInfo* next;
        //printf("dasdasdasdasdasdasdasd1\n");
        list_for_each_entry_safe(node, next, &_over_all_sensor_back_info.list, list)
        {
            //printf("dasdasdasdasdasdasdasd2\n");
            list_del(&node->list);
            free(node);
        } 
        #endif
    }
    //删除传感器
    else if(strcmp(_over_all_sensor_request.type,"delete")==0)
    {
        log_d("start delete handle.");
        int sensor_id_temp = 0 ;
        if(_over_all_sensor_request.sensorId!=NULL)
        {
            sensor_id_temp = strtol(_over_all_sensor_request.sensorId,NULL,10);
        }    
        else
        {
            sensor_id_temp = 0 ;
        }

        if(dev_delete_sensor_manage(__globalDeviceManage.db, 1,sensor_id_temp)!=0)
        {
            log_e("sensor delete failed.");
        }
        //维护列表也需要删除
        GlobalSensorManger* node;
        GlobalSensorManger* next;
        list_for_each_entry_safe(node, next, &__globalDeviceManage._globalSensorManger.list, list)
        {
            if(node->sensor_id == sensor_id_temp)
            {
                list_del(&node->list);
                free(node);
                break;
            }
        } 

        ack_str = ctrl_sts_ack_to_json();
    }
    //更新传感器
    else if(strcmp(_over_all_sensor_request.type,"update")==0)
    {
        log_d("start update handle.");
        int sensor_id_temp = 0 ;
        if(_over_all_sensor_request.sensorId!=NULL)
        {
            sensor_id_temp = _over_all_sensor_request.sensorId;
        }
        else
        {
            sensor_id_temp = 0;
        }
        GlobalSensorManger *node = NULL;
        GlobalSensorManger *next = NULL;
        list_for_each_entry_safe(node, next, &__globalDeviceManage._globalSensorManger.list, list)
        {
            if (node->sensor_id == sensor_id_temp)
            {
                break;
            }
        }
        if (node)
        {
#if (1)
            GlobalSensorManger *_globalSensorMangerTemp = node;
            // 填充数据
            _globalSensorMangerTemp->sensor_type = strtol(_over_all_sensor_request.sensorType, NULL, 10);
            if (_over_all_sensor_request.sensorName)
            {
                int nSize=strlen(_over_all_sensor_request.sensorName);
                if (nSize<=64)
                {
                    strcpy(_globalSensorMangerTemp->sensor_name, _over_all_sensor_request.sensorName);
                }             
                else{
                    //响应
                    //stream->errorMsg="Edit Name Too Long";
					http_reply(conn, 500, ack_str);
                    //释放资源
                    cJSON_free((void*)ack_str);
                    return ;
                }   
            }            
            if(_over_all_sensor_request.comSlogan)
            {
                strcpy(_globalSensorMangerTemp->sensor_port_name, _over_all_sensor_request.comSlogan);  
            }
            
            //_globalSensorMangerTemp->sensor_baud = strtol(_over_all_sensor_request.sensorBaud, NULL, 10);
            //_globalSensorMangerTemp->sensor_addr = strtol(_over_all_sensor_request.sensorAddr, NULL, 10);
            _globalSensorMangerTemp->sensor_status = 0;
            switch (_globalSensorMangerTemp->sensor_type)
            {
            case 0:
                _globalSensorMangerTemp->sensor_val_count = 2;
                break; // 温湿度传感器 2个值
            case 1:
                _globalSensorMangerTemp->sensor_val_count = 1;
                break; // 烟雾传感器 1个值
            case 2:
                _globalSensorMangerTemp->sensor_val_count = 1;
                break; // 水浸传感器 1个值
            case 3:
                _globalSensorMangerTemp->sensor_val_count = 0;
                break; // 门禁传感器 没有值
            case 4:
                _globalSensorMangerTemp->sensor_val_count = 1;
                break; // 气体传感器 1个值
            case 5:
                _globalSensorMangerTemp->sensor_val_count = 2;
                break; // 气压气流传感器 2个值
            case 6:
                _globalSensorMangerTemp->sensor_val_count = 0;
                break; // 空调遥控器 没有值
            }

            // 插入数据库
            if (dev_update_sensor_genera_manage(__globalDeviceManage.db,
                                                __globalDeviceManage._global_device_info->product_id,
                                                _globalSensorMangerTemp->sensor_id,
                                                _globalSensorMangerTemp) != 0)
            {
                log_e("dev update error.");
            }
#endif
        }

        ack_str = ctrl_sts_ack_to_json();
    }
    //添加传感器
    else if(strcmp(_over_all_sensor_request.type,"add")==0) //正常跑过
    {
        log_d("start add handle.");
        GlobalSensorManger* _globalSensorMangerTemp = (GlobalSensorManger*)malloc(sizeof(GlobalSensorManger));
        //清空数据
        memset(_globalSensorMangerTemp, 0, sizeof(GlobalSensorManger));
        //填充数据
        _globalSensorMangerTemp->product_id = __globalDeviceManage._global_device_info->product_id ;
        if(_over_all_sensor_request.sensorId!=NULL)
        {
            _globalSensorMangerTemp->sensor_id = strtol(_over_all_sensor_request.sensorId,NULL,10);
        }    
        else
        {
             _globalSensorMangerTemp->sensor_id = 0 ;
        }
        _globalSensorMangerTemp->sensor_type = strtol(_over_all_sensor_request.sensorType,NULL,10);
        strcpy( _globalSensorMangerTemp->sensor_name,_over_all_sensor_request.sensorName);
        strcpy(_globalSensorMangerTemp->sensor_port_name,_over_all_sensor_request.comSlogan);
        _globalSensorMangerTemp->sensor_baud = strtol(_over_all_sensor_request.sensorBaud,NULL,10);
        _globalSensorMangerTemp->sensor_addr = strtol(_over_all_sensor_request.sensorAddr,NULL,10);
        _globalSensorMangerTemp->sensor_status = 0;
        switch( _globalSensorMangerTemp->sensor_type)
        {
            case 0:_globalSensorMangerTemp->sensor_val_count = 2 ;break; //温湿度传感器 2个值
            case 1:_globalSensorMangerTemp->sensor_val_count = 1 ;break; //烟雾传感器 1个值
            case 2:_globalSensorMangerTemp->sensor_val_count = 1 ;break; //水浸传感器 1个值  
            case 3:_globalSensorMangerTemp->sensor_val_count = 0 ;break; //门禁传感器 没有值
            case 4:_globalSensorMangerTemp->sensor_val_count = 1 ;break; //气体传感器 1个值
            case 5:_globalSensorMangerTemp->sensor_val_count = 2 ;break; //气压气流传感器 2个值
            case 6:_globalSensorMangerTemp->sensor_val_count = 0 ;break; //空调遥控器 没有值
        }
        //插入数据库
        if(dev_insert_sensor_genera_manage(__globalDeviceManage.db,&_globalSensorMangerTemp)!=0)
        {
            log_e("dev insert error.");
        }
        //全局接口体中也需要添加相关参数
        list_add_tail(&_globalSensorMangerTemp->list,&__globalDeviceManage._globalSensorManger.list);


        ack_str = ctrl_sts_ack_to_json();
    }
    //烟雾报警复位
    else if(strcmp(_over_all_sensor_request.type,"reset")==0)
    {
        ack_str = ctrl_sts_ack_to_json();
    }
    //门禁释放
    else if(strcmp(_over_all_sensor_request.type,"release")==0)
    {
        ack_str = ctrl_sts_ack_to_json();
    }
    //打开空调开关
    else if(strcmp(_over_all_sensor_request.type,"open")==0)
    {
        ack_str = ctrl_sts_ack_to_json();
    }
    //关闭空调开关
    else if(strcmp(_over_all_sensor_request.type,"close")==0)
    {
        ack_str = ctrl_sts_ack_to_json();
    }
    #if(1)
    //历史信息
    else if(strcmp(_over_all_sensor_request.type,"listHisQuery")==0)
    {
        int rsize = 0 ;
        int g_sensor_id = 0 ;
        int g_sensor_type = 0 ;
        GlobalSensorInfo* _globalSensorInfoTemp;
        GlobalSensorManger* _globalSensorMangerSTemp;
        int page_num = 0;
        int page_size = 0;        
#if 0
        INIT_LIST_HEAD(&_globalSensorInfo.list);
        g_sensor_type = atoi(_over_all_sensor_request.sensorType);
        // log_d("page_num:%d",page_num);
        // log_d("page_size:%d",page_size);
        //查询数据
         ret = dev_search_sensor_info(__globalDeviceManage.db,
                             __globalDeviceManage._global_device_info->product_id,
                             g_sensor_id,
                             _over_all_sensor_request.startTime,
                             _over_all_sensor_request.endTime,
                             page_num,
                             page_size,
                             &rsize,
                             &_globalSensorInfo);
         if(ret!=0)
             log_e("get sensor history error.");
        
        //查找管理表找到关联信息
        list_for_each_entry(_globalSensorMangerSTemp, &__globalDeviceManage._globalSensorManger.list, list)
        {
            //ID相等 记录信息
            if(_globalSensorMangerSTemp->sensor_id== g_sensor_id)
            {
                break;
            }
        }        
        //组返回数据
        list_for_each_entry(_globalSensorInfoTemp, &_globalSensorInfo.list, list)
        {
#endif
            /*
            _OverSensorBackInfo* _overSensorBackInfoTemp = (_OverSensorBackInfo*)malloc(sizeof(_OverSensorBackInfo));
            if(_overSensorBackInfoTemp==NULL)
                log_e("_OverSensorBackInfo malloc error.");
            memset(_overSensorBackInfoTemp,0,sizeof(_OverSensorBackInfo));

            //基本信息
            _overSensorBackInfoTemp->sensorId = _over_all_sensor_request.sensorId;
            strcpy(_overSensorBackInfoTemp->sensorName,_globalSensorMangerSTemp->sensor_name);
            _overSensorBackInfoTemp->sensorType = _globalSensorMangerSTemp->sensor_type;
            strcpy(_overSensorBackInfoTemp->comSlogan,_globalSensorMangerSTemp->sensor_port_name);
            //485独有
            if(_globalSensorMangerSTemp->sensor_interface_type==1)
            {
                _overSensorBackInfoTemp->sensorAddr = _globalSensorMangerSTemp->sensor_addr ;
                _overSensorBackInfoTemp->sensorBaud = _globalSensorMangerSTemp->sensor_baud;
            }
            _overSensorBackInfoTemp->connectionStatus = _globalSensorMangerSTemp->sensor_status;
            _overSensorBackInfoTemp->nodeNumber = __globalDeviceManage._globalSensorManger.sensor_node_number;

            //判断sensor type 填充数据
            switch(_globalSensorMangerSTemp->sensor_type)
            {
                case 0://温湿度传感器 2个值
                {
                    _overSensorBackInfoTemp->temperatureValue = _globalSensorInfoTemp->val1;
                    _overSensorBackInfoTemp->humidityValue = _globalSensorInfoTemp->val2;
                }break;
                case 1://烟雾传感器 1个值
                {
                    _overSensorBackInfoTemp->alarmStatus =  (bool)_globalSensorInfo.val1; // 1/0 报警未报警
                }break;
                case 2://水浸传感器
                {
                    _overSensorBackInfoTemp->waterImmersionState =  (bool)_globalSensorInfo.val1; // 1/0 报警未报警
                }break;
                case 3://门禁传感器 没有值
                {
                    _overSensorBackInfoTemp->accessControlStatus =  (bool)_globalSensorInfo.val1; // 1/0 报警未报警
                }break;
                case 4://气体传感器 1个值
                {
                    _overSensorBackInfoTemp->gasConcentration =  _globalSensorInfoTemp->val1; // 气体浓度
                }break;
                case 5:
                {
                    _overSensorBackInfoTemp->airPressureValue =  _globalSensorInfoTemp->val1; // 气压
                    _overSensorBackInfoTemp->airflowValue =  _globalSensorInfoTemp->val2; // 气流
                }break;
                case 6://空调遥控器 没有值
                {

                }break; 
            }
            */
            //入队
//            list_add_tail(_overSensorBackInfoTemp,&_over_all_sensor_back_info.list);
        //}
        
        // //参数转换json
        // ack_str = over_all_sensor_info_to_json(&_over_all_sensor_back_info);   
        // //释放资源
        // _OverSensorBackInfo* node;
        // _OverSensorBackInfo* next;
        // list_for_each_entry_safe(node, next, &_over_all_sensor_back_info.list, list)
        // {
        //     list_del(&node->list);
        //     free(node);
        // }
        /*
        if(strcmp(_over_all_sensor_request.sensorType,"0")==0)
        {
            ack_str = over_sensor_history_info_to_json(&_over_all_sensor_back_info, SENSOR_TYPE_VALUE);
        }
        else if(strcmp(_over_all_sensor_request.sensorType,"4")==0)
        {
            ack_str = over_sensor_history_info_to_json(&_over_all_sensor_back_info, SENSOR_TYPE_VALUE);
        }
        else if(strcmp(_over_all_sensor_request.sensorType,"5")==0)
        {
            ack_str = over_sensor_history_info_to_json(&_over_all_sensor_back_info, SENSOR_TYPE_VALUE);
        }
        else if(strcmp(_over_all_sensor_request.sensorType,"1")==0)
        {
            ack_str = over_sensor_history_info_to_json(&_over_all_sensor_back_info, SENSOR_TYPE_LIST);
        }
        else if(strcmp(_over_all_sensor_request.sensorType,"2")==0)
        {
            ack_str = over_sensor_history_info_to_json(&_over_all_sensor_back_info, SENSOR_TYPE_LIST);
        }
        else if(strcmp(_over_all_sensor_request.sensorType,"3")==0)
        {
            ack_str = over_sensor_history_info_to_json(&_over_all_sensor_back_info, SENSOR_TYPE_LIST);
        }
        */
    } 
    #endif
    
    http_reply(conn, 200, ack_str);
    cJSON_free((void*)ack_str);
}

/// @brief 告警保护
/// @param stream 
static void alarmProtect(void *conn)
{
    __globalDeviceManage.view_page=-1;
    int ret = -1 ;
    _AlarmRequestInfo _alarm_request_info;
    _AlarmAckInfo _alarm_ack_info; //填充数据
    char* rx_body_buf = NULL;
    char* ack_str = NULL ;
    int nAlarmNumber=0;
    
#ifdef USE_WEBAPP
    HttpStream *s=(HttpStream*)conn;
    rx_body_buf = httpGetBodyInput(s);
    usleep(100000);
#else
    mg_stream_t *s=(mg_stream_t*)conn;
    struct mg_http_message *msg=s->ev_data;
    rx_body_buf = msg->body.buf;
#endif

    memset(&_alarm_request_info, 0, sizeof(_alarm_request_info));
    //转换json参数
    if(json_to_alarm_manage(rx_body_buf,&_alarm_request_info)!=0)
    {
        http_reply(conn, 400, NULL);
        return ;        
    } 
    //查询json参数
    if(strcmp(_alarm_request_info.type,"listAllQuery")==0) //电源告警信息查询
    {
        int i = 0 ;
        //初始化表
        INIT_LIST_HEAD(&_alarm_ack_info.list);
        //查询数据库
        ret = dev_serarch_all_alarm(__globalDeviceManage.db,
            __globalDeviceManage._global_device_info->product_id,
            -1,_alarm_request_info.pagenum,_alarm_request_info.pagesize,
            &_alarm_ack_info,&nAlarmNumber);
        if(ret!=0)
            log_e("get power alarm error.");
        //转换参数
        ack_str = alarm_info_to_json(&_alarm_ack_info,nAlarmNumber);

        //释放资源
        _AlarmAckInfo* node;
        _AlarmAckInfo* next;
        list_for_each_entry_safe(node, next, &_alarm_ack_info.list, list)
        {
            list_del(&node->list);
            free(node);
        } 

    }
    else if(strcmp(_alarm_request_info.type,"powerAlarmList")==0) //电源告警信息查询
    {
        //初始化表
        INIT_LIST_HEAD(&_alarm_ack_info.list);
        //查询数据库
        ret = dev_serarch_all_alarm(__globalDeviceManage.db,
            __globalDeviceManage._global_device_info->product_id,
            0,_alarm_request_info.pagenum,_alarm_request_info.pagesize,
            &_alarm_ack_info,&nAlarmNumber);
        if(ret!=0)
            log_e("get power alarm error.");
        //转换参数
        ack_str = alarm_info_to_json(&_alarm_ack_info,nAlarmNumber);

        //释放资源
        _AlarmAckInfo* node;
        _AlarmAckInfo* next;
        list_for_each_entry_safe(node, next, &_alarm_ack_info.list, list)
        {
            list_del(&node->list);
            free(node);
        } 
    }
    else if(strcmp(_alarm_request_info.type,"sensorAlarmList")==0) //传感器告警信息查询
    {
        //初始化表
        INIT_LIST_HEAD(&_alarm_ack_info.list);
        //查询数据库
        ret = dev_serarch_all_alarm(__globalDeviceManage.db,
            __globalDeviceManage._global_device_info->product_id,
            1,_alarm_request_info.pagenum,_alarm_request_info.pagesize,
            &_alarm_ack_info,&nAlarmNumber);
        if(ret!=0)
            log_e("get sensor alarm error.");
        //转换参数
        ack_str = alarm_info_to_json(&_alarm_ack_info,nAlarmNumber);

        //释放资源
        _AlarmAckInfo* node;
        _AlarmAckInfo* next;
        list_for_each_entry_safe(node, next, &_alarm_ack_info.list, list)
        {
            list_del(&node->list);
            free(node);
        } 
    }
    else if(strcmp(_alarm_request_info.type,"networAlarmkList")==0) //网络告警信息查询
    {
        //初始化表
        INIT_LIST_HEAD(&_alarm_ack_info.list);
        //查询数据库
        ret = dev_serarch_all_alarm(__globalDeviceManage.db,
            __globalDeviceManage._global_device_info->product_id,
            2,_alarm_request_info.pagenum,_alarm_request_info.pagesize,
            &_alarm_ack_info,&nAlarmNumber);
        if(ret!=0)
            log_e("get net alarm error.");
        //转换参数
        ack_str = alarm_info_to_json(&_alarm_ack_info,nAlarmNumber);

        //释放资源
        _AlarmAckInfo* node;
        _AlarmAckInfo* next;
        list_for_each_entry_safe(node, next, &_alarm_ack_info.list, list)
        {
            list_del(&node->list);
            free(node);
        } 

    }
    else if(strcmp(_alarm_request_info.type,"powerThresholdList")==0)//电源阈值查询
    {
        //查询每个通道阈值
        ack_str = alarm_power_threshold_to_json(&__globalDeviceManage._globalPowerManger);
    }
    else if(strcmp(_alarm_request_info.type,"save")==0)//电源阈值保存
    {
        if (!_alarm_request_info.user_token)
        {
            return;
        }
        
        //拿到参数保存
        GlobalPowerManger* _globalPowerMangerSaveTemp ;
        // int g_pwr_ch_id = atoi(_alarm_request_info._pwr_info.productChId);
        int g_pwr_ch_id = _alarm_request_info._pwr_info.productChId;
        if (g_pwr_ch_id ==0)
        {
           _globalPowerMangerSaveTemp=&__globalDeviceManage._globalPowerManger;
        }
        else
        {
            list_for_each_entry(_globalPowerMangerSaveTemp, &__globalDeviceManage._globalPowerManger.list, list)
            {
                // ID相等 记录信息
                if (_globalPowerMangerSaveTemp->product_ch_id == g_pwr_ch_id)
                {
                    break;
                }
            }
        }

        //更新参数
        if (_alarm_request_info._pwr_info.voltageUpperValue)
        {
            _globalPowerMangerSaveTemp->global_over_manager->product_vol_upper_threshold =atof(_alarm_request_info._pwr_info.voltageUpperValue);
        }     
        if (_globalPowerMangerSaveTemp->global_over_manager->product_vol_upper_threshold!=0){_globalPowerMangerSaveTemp->global_over_manager->product_vol_upper_enable = 1 ;
        }else{_globalPowerMangerSaveTemp->global_over_manager->product_vol_upper_enable = 0;} 

        if (_alarm_request_info._pwr_info.voltageDownValue)
        {
            _globalPowerMangerSaveTemp->global_over_manager->product_vol_lower_threshold =atof(_alarm_request_info._pwr_info.voltageDownValue);
        }     
        if (_globalPowerMangerSaveTemp->global_over_manager->product_vol_lower_threshold!=0){_globalPowerMangerSaveTemp->global_over_manager->product_vol_lower_enable  = 1 ;
        }else{_globalPowerMangerSaveTemp->global_over_manager->product_vol_lower_enable  = 0 ;} 

        if (_alarm_request_info._pwr_info.currentUpperValue)
        {
            _globalPowerMangerSaveTemp->global_over_manager->product_cur_upper_threshold = atof(_alarm_request_info._pwr_info.currentUpperValue);
        }     

        if (_globalPowerMangerSaveTemp->global_over_manager->product_cur_upper_threshold!=0){_globalPowerMangerSaveTemp->global_over_manager->product_cur_upper_enable = 1 ;
        }else{_globalPowerMangerSaveTemp->global_over_manager->product_cur_upper_enable = 0 ;} 

        if (_alarm_request_info._pwr_info.powerUpperValue)
        {
            _globalPowerMangerSaveTemp->global_over_manager->product_pwr_upper_threshold = atof(_alarm_request_info._pwr_info.powerUpperValue);
        }     
        if (_globalPowerMangerSaveTemp->global_over_manager->product_pwr_upper_threshold!=0){_globalPowerMangerSaveTemp->global_over_manager->product_pwr_upper_enable = 1 ;
        }else{_globalPowerMangerSaveTemp->global_over_manager->product_pwr_upper_enable = 0 ;} 

        if (_alarm_request_info._pwr_info.alarmContentUpperValue)
        {
            _globalPowerMangerSaveTemp->global_over_manager->product_pwrcon_upper_threshold = atof(_alarm_request_info._pwr_info.alarmContentUpperValue);
        }      
        if (_globalPowerMangerSaveTemp->global_over_manager->product_pwrcon_upper_threshold!=0){_globalPowerMangerSaveTemp->global_over_manager->product_pwrcon_upper_enable = 1 ;
        }else{_globalPowerMangerSaveTemp->global_over_manager->product_pwrcon_upper_enable = 0 ;} 
        //_globalPowerMangerSaveTemp->global_over_manager->product_pwrcon_upper_enable = 1 ;
            
        ret=g_switch_set_all_single_threshold(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerSaveTemp->product_ch_type
                                        ,_globalPowerMangerSaveTemp->product_saddr
                                        ,(_globalPowerMangerSaveTemp->product_ch_addr)
                                        ,_globalPowerMangerSaveTemp->global_over_manager);
        if (ret<0)
        {
            log_e("power threshold update error.ret:%d,%s",ret,modbus_strerror(errno));
            /* code */
        }
        
        //写入数据库
        ret = dev_update_power_manage_over_info(__globalDeviceManage.db,
        __globalDeviceManage._global_device_info->product_id,
        _globalPowerMangerSaveTemp->product_ch_id,
        _globalPowerMangerSaveTemp);
        if(ret!=0)
            log_e("power threshold update error.");
        //返回数据
        ack_str = ctrl_sts_ack_to_json();
    }
    
    else if(strcmp(_alarm_request_info.type,"sensorThresholdList")==0)//传感器阈值查询
    {
        ack_str = alarm_sensor_threshold_to_json(&__globalDeviceManage._globalSensorManger);
    }

    else if(strcmp(_alarm_request_info.type,"saveSensorThreshold")==0)//传感器阈值保存
    {
        GlobalSensorManger* _globalSensorMangerSaveTemp;
        int g_sensor_id = atoi(_alarm_request_info._sensor_info.sensorId);
        list_for_each_entry(_globalSensorMangerSaveTemp, &__globalDeviceManage._globalSensorManger.list, list)
        {
            //ID相等 记录信息
            if(_globalSensorMangerSaveTemp->sensor_id== g_sensor_id)
            {
                break;
            }
        }  
        _globalSensorMangerSaveTemp->over_manager->sensor_val1_upper_threshold = atof(_alarm_request_info._sensor_info.thresholdUpperValue);
        _globalSensorMangerSaveTemp->over_manager->sensor_val2_upper_threshold = atof(_alarm_request_info._sensor_info.thresholdDownValue);        
        //更新参数
        ret = dev_update_sensor_over_manage(__globalDeviceManage.db,
                                    __globalDeviceManage._global_device_info->product_id,
                                    g_sensor_id,
                                    _globalSensorMangerSaveTemp);
        if(ret!=0)
            log_e("power threshold update error.");
        //拿到参数保存
        ack_str = ctrl_sts_ack_to_json();
    }    

    http_reply(conn, 200, ack_str);
    cJSON_free((void*)ack_str);
}


/// @brief 查询日志
/// @param stream 
static void logInformation(void *conn)
{
    int ret = -1 ;
    char* rx_body_buf = NULL;
    char* ack_str = NULL ;
    int nAlarmNum = 0;
    _LogInformationRequestInfo __logInformationRequestInfo;
    _AlarmAckInfo _alarm_ack_info; //填充数据
    
#ifdef USE_WEBAPP
    HttpStream *s=(HttpStream*)conn;
    rx_body_buf = httpGetBodyInput(s);
#else
    mg_stream_t *s=(mg_stream_t*)conn;
    struct mg_http_message *msg=s->ev_data;
    rx_body_buf = msg->body.buf;
#endif
    
    memset(&__logInformationRequestInfo,0,sizeof(_LogInformationRequestInfo));
    if(json_to_loginformation_manage(rx_body_buf,&__logInformationRequestInfo)!=0)
    {
        http_reply(conn, 400, NULL);
        return ;        
    }
    //查询json参数
    if(strcmp(__logInformationRequestInfo.type,"listJgrzQuery")==0) //告警日志
    {
        //初始化表
        INIT_LIST_HEAD(&_alarm_ack_info.list);


        if(__logInformationRequestInfo.beginTime==NULL || __logInformationRequestInfo.endtime==NULL)
        {
            struct tm* t ;
            struct timeval tv;
            char start_time[32] = {0};
            char stop_time[32] = {0};

            gettimeofday(&tv, NULL);
            t = localtime(&tv.tv_sec);
            sprintf(stop_time,"%04d-%02d-%02d %02d:%02d:%02d",t->tm_year+1900,t->tm_mon+1,t->tm_mday,23,59,59);    
            log_d(stop_time);


            sprintf(start_time,"%04d-%02d-%02d %02d:%02d:%02d",t->tm_year+1900,t->tm_mon+1,t->tm_mday,0,0,0);  
            log_d(start_time);
            
            dev_search_alarm_info(__globalDeviceManage.db,
                            __globalDeviceManage._global_device_info->product_id,
                            0,     //注意注意 此处需要查询的参数是0 1 2
                            start_time,//启动时间
                            stop_time,  //结束时间
                            __logInformationRequestInfo.pagenum-1,  //页
                            __logInformationRequestInfo.pagesize, //条
                            &_alarm_ack_info,&nAlarmNum);      

            ack_str = alarm_type_info_to_json(&_alarm_ack_info,nAlarmNum);  

            //释放资源
            _AlarmAckInfo* node;
            _AlarmAckInfo* next;
            list_for_each_entry_safe(node, next, &_alarm_ack_info.list, list)
            {
                list_del(&node->list);
                free(node);
            }
        }
        else
        {
            dev_search_alarm_info(__globalDeviceManage.db,
                            __globalDeviceManage._global_device_info->product_id,
                            0,     //注意注意 此处需要查询的参数是0 1 2
                            __logInformationRequestInfo.beginTime,//启动时间
                            __logInformationRequestInfo.endtime,  //结束时间
                            __logInformationRequestInfo.pagenum-1,  //页
                            __logInformationRequestInfo.pagesize, //条
                            &_alarm_ack_info,&nAlarmNum);

            ack_str = alarm_type_info_to_json(&_alarm_ack_info,nAlarmNum);  

            //释放资源
            _AlarmAckInfo* node;
            _AlarmAckInfo* next;
            list_for_each_entry_safe(node, next, &_alarm_ack_info.list, list)
            {
                list_del(&node->list);
                free(node);
            }   
        }
        //转换参数
        //ack_str = alarm_type_info_to_json(&_alarm_ack_info);            
    }
    else if(strcmp(__logInformationRequestInfo.type,"exportJgrz")==0) //导出告警日志
    {

    }   
    else if(strcmp(__logInformationRequestInfo.type,"listCzrzQuery")==0) //操作日志
    {
        //初始化表
        INIT_LIST_HEAD(&_alarm_ack_info.list);

        //默认查当天日志
        if(__logInformationRequestInfo.beginTime==NULL || __logInformationRequestInfo.endtime==NULL)
        {
           struct tm* t ;
            struct timeval tv;
            char start_time[32] = {0};
            char stop_time[32] = {0};

            gettimeofday(&tv, NULL);
            t = localtime(&tv.tv_sec);
            sprintf(stop_time,"%04d-%02d-%02d %02d:%02d:%02d",t->tm_year+1900,t->tm_mon+1,t->tm_mday,23,59,59);    
            log_d(stop_time);

            sprintf(start_time,"%04d-%02d-%02d %02d:%02d:%02d",t->tm_year+1900,t->tm_mon+1,t->tm_mday,0,0,0);  
            log_d(start_time);

            dev_search_alarm_info(__globalDeviceManage.db,
                                  __globalDeviceManage._global_device_info->product_id,
                                  3, // alarm_type,        操作日志
                                  start_time,
                                  stop_time,
                                  __logInformationRequestInfo.pagenum - 1,
                                  __logInformationRequestInfo.pagesize,
                                  &_alarm_ack_info, &nAlarmNum);
        }
        else
        {
            dev_search_alarm_info(__globalDeviceManage.db,
                                __globalDeviceManage._global_device_info->product_id,
                                3,// alarm_type,        操作日志
                                __logInformationRequestInfo.beginTime,
                                __logInformationRequestInfo.endtime,
                                __logInformationRequestInfo.pagenum-1,
                                __logInformationRequestInfo.pagesize,
                                &_alarm_ack_info,&nAlarmNum);
        }
        //转换参数
        ack_str = alarm_ctrl_type_info_to_json(&_alarm_ack_info,nAlarmNum);   

        //释放资源
        _AlarmAckInfo* node;
        _AlarmAckInfo* next;
        list_for_each_entry_safe(node, next, &_alarm_ack_info.list, list)
        {
            list_del(&node->list);
            free(node);
        } 
    }  
    else if(strcmp(__logInformationRequestInfo.type,"exportCzrz")==0) //导出操作日志
    {

    }    
    else if(strcmp(__logInformationRequestInfo.type,"listYxrzQuery")==0) //运行日志
    {
        //初始化表
        INIT_LIST_HEAD(&_alarm_ack_info.list);

        dev_search_alarm_info(__globalDeviceManage.db,
                            __globalDeviceManage._global_device_info->product_id,
                            4,// alarm_type,        运行日志
                            __logInformationRequestInfo.beginTime,
                            __logInformationRequestInfo.endtime,
                            __logInformationRequestInfo.pagenum-1,
                            __logInformationRequestInfo.pagesize,
                            &_alarm_ack_info,&nAlarmNum);
        //转换参数
        ack_str = alarm_type_info_to_json(&_alarm_ack_info,nAlarmNum);    

        //释放资源
        _AlarmAckInfo* node;
        _AlarmAckInfo* next;
        list_for_each_entry_safe(node, next, &_alarm_ack_info.list, list)
        {
            list_del(&node->list);
            free(node);
        } 
    }    
    else if(strcmp(__logInformationRequestInfo.type,"exportYxrz")==0) //导出运行日志        导出方式->
    {

    }       
    
    http_reply(conn, 200, ack_str);
    cJSON_free((void*)ack_str);
}


/// @brief 通信网口设置
/// @param stream 
static void communicationManagement(void *conn)
{
    int r = -1 ;
    char* rx_body_buf = NULL;
    char* ack_str = NULL ;
    _CommunicationManageRequestInfo _communicationManageRequestInfo;
	_CommunicationManageRequestInfo reqInfo;
    GlobalDeviceInfo *devInfo=__globalDeviceManage._global_device_info;
    
#ifdef USE_WEBAPP
    usleep(100000);
    HttpStream *s=(HttpStream*)conn;
    rx_body_buf = httpGetBodyInput(s);
#else
    mg_stream_t *s=(mg_stream_t*)conn;
    struct mg_http_message *msg=s->ev_data;
    rx_body_buf = msg->body.buf;
#endif
    //转换json参数
    if(json_to_communication_manage(rx_body_buf,&reqInfo)!=0)
    {
        http_reply(conn, 400, NULL);
        return ;        
    }
    //查询网络参数
    if(strcmp(reqInfo.type,"listWkIPV4Query")==0 || strcmp(reqInfo.type,"listWkIPV6Query")==0)//缃戠粶鍙傛暟鏌ヨ
    {
        NetworkInfo_t* info = &devInfo->_network_info;
        int ipv=strstr(reqInfo.type, "listWkIPV4Query")?IP_V4:IP_V6;

        if(ipv==IP_V4) {
            sys_get_net(info, ipv);
            //print_net("get", info);

            ack_str = communication_net_ack_to_json(info);
        }
    }
    else if(strcmp(reqInfo.type,"WkIPV4Save")==0 || strcmp(reqInfo.type,"WkIPV6Save")==0 )  //淇濆瓨鏁版嵁
    {
        NetworkInfo_t* info = &devInfo->_network_info;
        _NET_CommunicationRequestInfo *info2=&reqInfo._net_info;
        int ipv=strstr(reqInfo.type, "WkIPV4Save")?IP_V4:IP_V6;
        
        
        info->mode = atoi(info2->mode);
        if(info->mode==1) { //static
            info->mode = info->mode;
            
            if(info2->ipaddr)   strcpy(info->ip_address, info2->ipaddr);
            if(info2->maskaddr) strcpy(info->mask, info2->maskaddr);
            if(info2->gateway)  strcpy(info->gateway, info2->gateway);     
            if(info2->dns1)     strcpy(info->dns1, info2->dns1); 
            if(info2->dns2)     strcpy(info->dns2, info2->dns2);
        }
        
        ////////////////////////////////////////////////////////////////////////////////
        if(info->mode==1 && ipv==IP_V4) {    //only proc static ipaddress
            r = sys_set_net(info, ipv);
            //print_net("set", info);
            if(r==0) {
                paras_save();
                ack_str = ctrl_sts_ack_to_json(); 
            }
        }
        //////////////////////////////////////////////////////////////////////////////    
                    
    }
    //查询设置RS485参数
    else if(strcmp(reqInfo.type,"listRsQuery")==0)//modbus鍙傛暟鏌ヨ
    {
        ModbusInfo_t* _modbusInfo_temp = &devInfo->_gmodbus_info;
        ack_str = communication_rs_ack_to_json(_modbusInfo_temp);
    }
    else if(strcmp(reqInfo.type,"RsSave")==0)//淇濆瓨modbus鏁版嵁
    {
        ModbusInfo_t* info = &devInfo->_gmodbus_info;
        info->product_modbus_type = atoi(reqInfo._rs_info.mode);
        info->product_modbus_baud = atoi(reqInfo._rs_info.baud);
        info->product_modbus_addr = atoi(reqInfo._rs_info.addr);
        
        ///////////////////////////////////////////////////////////////////////////////
        r = cascade_set_modbus(info);
        if(r==0) {
            paras_save();
            dev_update_device_modus_info(__globalDeviceManage.db,devInfo);
        }
        
        ack_str = ctrl_sts_ack_to_json();
    }
    //响应
    http_reply(conn, 200, ack_str);
    cJSON_free((void*)ack_str); 
}


/// @brief 服务管理
/// @param stream 
static void serviceManagement(HttpStream *stream)
{
    __globalDeviceManage.view_page=-1;
    int ret = -1 ;
    char* rx_body_buf = NULL;
    _ServiceManageRequestInfo _serviceManageRequestInfo;
    char* ack_str = NULL ;

#ifdef USE_WEBAPP
    HttpStream *s=(HttpStream*)conn;
    rx_body_buf = httpGetBodyInput(s);
#else
    mg_stream_t *s=(mg_stream_t*)conn;
    struct mg_http_message *msg=s->ev_data;
    rx_body_buf = msg->body.buf;
#endif

    //转换json参数
    if(json_to_service_manage(rx_body_buf,&_serviceManageRequestInfo)!=0)
    {
        http_reply(conn, NULL, 400);
        return ;        
    }
    //查询smtp信息
    else if(strcmp(_serviceManageRequestInfo.type,"listSmtpQuery")==0)
    {
        // SmtpSever* _smtp_sever_info = &__globalDeviceManage.user_server.smtp_set;
        // ack_str = communication_net_ack_to_json(_smtp_sever_info);
    }   
    else if(strcmp(_serviceManageRequestInfo.type,"SmtpSave")==0)
    {

    }   
    //查询snmp信息
    else if(strcmp(_serviceManageRequestInfo.type,"listSnmpQuery")==0)
    {
        // 查询SNMP信息
        if (0 == dev_get_snmp_info(__globalDeviceManage.db, &_globalSNMPManager))
        {
            ack_str = service_snmp_ack_to_json(&_globalSNMPManager);
        }
    }   
    else if(strcmp(_serviceManageRequestInfo.type,"SnmpSave")==0)
    {
        _globalSNMPManager.mode = atoi(_serviceManageRequestInfo._snmp_info.mode);
        if (strcmp(_serviceManageRequestInfo._snmp_info.version,"SNMP V1")==0)
        {
            _globalSNMPManager.version=0;
        }
        else if (strcmp(_serviceManageRequestInfo._snmp_info.version,"SNMP V2c")==0)
        {
            _globalSNMPManager.version=1;
        }
        else if (strcmp(_serviceManageRequestInfo._snmp_info.version,"SNMP V3")==0)
        {
            _globalSNMPManager.version=2;
        }
        else
        {
            _globalSNMPManager.version=-1;
        }
    
        _globalSNMPManager.public= malloc(32);
        strcpy(_globalSNMPManager.public, _serviceManageRequestInfo._snmp_info.public);
        _globalSNMPManager.trapmode = atoi(_serviceManageRequestInfo._snmp_info.trapmode);
        _globalSNMPManager.product_id = __globalDeviceManage._global_device_info->product_id;
        if (dev_update_snmp_info(__globalDeviceManage.db,_globalSNMPManager.product_id,&_globalSNMPManager) != 0)
        {
            log_e("update snmp info err.");
        }
    }   
    //查询snmp_trap信息
    else if(strcmp(_serviceManageRequestInfo.type,"listStQuery")==0)
    {

    }   
    else if(strcmp(_serviceManageRequestInfo.type,"StSave")==0)
    {

    }   
    //查询ntp信息
    else if(strcmp(_serviceManageRequestInfo.type,"listNtpQuery")==0)
    {
        // 查询NTP信息
        if (0 == dev_get_ntp_info(__globalDeviceManage.db,&_globalNTPManager))
        {
            ack_str = service_ntp_ack_to_json(&_globalNTPManager);
        }
    }   
    else if(strcmp(_serviceManageRequestInfo.type,"NtpSave")==0)
    {
        _globalNTPManager.mode = atoi(_serviceManageRequestInfo._ntp_info.mode);
       _globalNTPManager.ntpaddress= malloc(64);
        strcpy(_globalNTPManager.ntpaddress, _serviceManageRequestInfo._ntp_info.ntpaddress);
        _globalNTPManager.ntpName= malloc(64);
        strcpy(_globalNTPManager.ntpName, _serviceManageRequestInfo._ntp_info.ntpName);
        _globalNTPManager.port = atoi(_serviceManageRequestInfo._ntp_info.port);
        _globalNTPManager.product_id = __globalDeviceManage._global_device_info->product_id;
         _globalNTPManager.time= malloc(64);
        strcpy(_globalNTPManager.time, _serviceManageRequestInfo._ntp_info.time);
        const char* key = "GMT/UTC";
        char* p = strstr(_serviceManageRequestInfo._ntp_info.tzone, key);
        if (p == NULL)
        {
            log_e("time zone not contain GMT/UTC");
            return;
        }
        char tempstr[10];
        memcpy(tempstr, &p[strlen(key)], strlen(p) - strlen(key));
        int value = atoi(tempstr);
        if (value > 12 || value < -11)
        {
            char buf[128];
            memset(buf, 0, sizeof(buf));
            sprintf(buf, "product id = %d timezone err.", _globalNTPManager.product_id);
            log_e(buf);
            return;
        }      
        _globalNTPManager.tzone = value;
        value = atoi(_serviceManageRequestInfo._ntp_info.weekday);
        if (value > 12 || value < -11)
        {
            char buf[128];
            memset(buf, 0, sizeof(buf));
            sprintf(buf, "product id = %d weekday err.", _globalNTPManager.product_id);
            log_e(buf);
            return;
        }      
        _globalNTPManager.weekday = value;
        if (dev_update_ntp_info(__globalDeviceManage.db,_globalNTPManager.product_id,&_globalNTPManager) != 0)
        {
            log_e("update ntp info err.");
        }
        if (_globalNTPManager.mode == 0)
        {
            time_t t;
            memset(tempstr, 0, sizeof(tempstr));
            p = strstr(_globalNTPManager.time, "-");
            if (p == NULL)
            {
                log_e("find year of local time failed");
                return;
            }
            memset(tempstr, 0, sizeof(tempstr));
            memcpy(tempstr, _globalNTPManager.time, p - _globalNTPManager.time);
            struct tm tm_new;
            tm_new.tm_year = atoi(tempstr) - 1900;
            char* p1 = strstr(&p[1], "-");
            if (p1 == NULL)
            {
                log_e("find month of local time failed");
                return;
            }
            int nSize= p1 - p - 1;
            memset(tempstr, 0, sizeof(tempstr));
            memcpy(tempstr, &p[1],nSize);
            tm_new.tm_mon = atoi(tempstr) - 1;
            p = p1;
            p1 = strstr(&p[2], " ");//个位数第一位有可能是空格所以需要找空格后一个
            if (p1 == NULL)
            {
                log_e("find mday of local time failed");
                return;
            }
            memset(tempstr, 0, sizeof(tempstr));
            memcpy(tempstr, &p[1], p1 - p - 1);
            tm_new.tm_mday = atoi(tempstr);
            p = p1;
            p1 = strstr(&p[0], " ");
            if (p1 == NULL)
            {
                log_e("find split of date and time failed");
                return;
            }
            p = &p1[0];
            p1 = strstr(p, ":");
            if (p1 == NULL)
            {
                log_e("find hour of local time failed");
                return;
            }
            memset(tempstr, 0, sizeof(tempstr));
            memcpy(tempstr, &p[1], p1 - p);
            tm_new.tm_hour = atoi(tempstr);
            p = &p1[1];
            p1 = strstr(p, ":");
            if (p1 == NULL)
            {
                log_e("find minute of local time failed");
                return;
            }
            memset(tempstr, 0, sizeof(tempstr));
            memcpy(tempstr, &p[0], p1 - p);
            tm_new.tm_min = atoi(tempstr);
            p = &p1[1];
            if (p == NULL)
            {
                log_e("find second of local time failed");
                return;
            }
            memset(tempstr, 0, sizeof(tempstr));
            memcpy(tempstr, &p[0], 2);
            tm_new.tm_sec = atoi(tempstr);
            t = mktime(&tm_new);
            set_local_timeandzone(&tm_new, _globalNTPManager.tzone);
        }
        ack_str = ctrl_sts_ack_to_json();
        if (_serviceManageRequestInfo._ntp_info.mode) free(_serviceManageRequestInfo._ntp_info.mode);
        if (_serviceManageRequestInfo._ntp_info.port) free(_serviceManageRequestInfo._ntp_info.port);
        if (_serviceManageRequestInfo._ntp_info.tzone) free(_serviceManageRequestInfo._ntp_info.tzone);
        if (_serviceManageRequestInfo._ntp_info.weekday) free(_serviceManageRequestInfo._ntp_info.weekday);
    }
    // 定时设置
    else if (strcmp(_serviceManageRequestInfo.type, "listDsQuery") == 0)
    {
        int chn_id = atoi(_serviceManageRequestInfo._ds_info.productChId);
        // 查询通道信息
        GlobalPowerManger *_globalPowerMangerTemp = NULL;
        list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
        {
            if (_globalPowerMangerTemp->product_ch_id == chn_id)
                break;
        }
        // 返回定时信息
        ack_str = service_ds_ack_to_json(_serviceManageRequestInfo._ds_info.productChName,
                                         _serviceManageRequestInfo._ds_info.productChId,
                                         _globalPowerMangerTemp->_powerDsManage);
    }
    else if (strcmp(_serviceManageRequestInfo.type, "dsSave") == 0)
    {
        int chn_id = atoi(_serviceManageRequestInfo._ds_info.productChId);
        // 查询通道信息
        GlobalPowerManger *_globalPowerMangerTemp = NULL;
        list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
        {
            if (_globalPowerMangerTemp->product_ch_id == chn_id)
                break;
        }
        // 记录参数
        strcpy(_globalPowerMangerTemp->_powerDsManage->ds_date, _serviceManageRequestInfo._ds_info.channelDate);
        strcpy(_globalPowerMangerTemp->_powerDsManage->ds_time, _serviceManageRequestInfo._ds_info.channelTime);
        _serviceManageRequestInfo._ds_info.setStatus = atoi(_serviceManageRequestInfo._ds_info.setStatus);
        //
        ack_str = ctrl_sts_ack_to_json();
    }
    // 时序设置
    else if (strcmp(_serviceManageRequestInfo.type, "listSxQuery") == 0) // 查询
    {
        bool bflag = false;
        GlobalPowerManger *_globalPowerMangerTemp = NULL;
        list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
        {
            if (_globalPowerMangerTemp->product_id == atoi(_serviceManageRequestInfo._posix_info.productId))
            {
                bflag = true;
                break;
            }
        }
        if (bflag == false) return;
        
        ack_str = service_sx_ack_to_json(_globalPowerMangerTemp->product_id, &__globalDeviceManage._globalPowerManger);
        if (_serviceManageRequestInfo._posix_info.productId) free(_serviceManageRequestInfo._posix_info.productId);
    }   
    else if(strcmp(_serviceManageRequestInfo.type,"sXTimeSave")==0)//保存时间间隔
    {
        int chn_id = atoi(_serviceManageRequestInfo._posix_info.productChId);
        int id = atoi(_serviceManageRequestInfo._posix_info.productId);
        GlobalPowerManger *_globalPowerMangerTemp = NULL;
        list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
        {
            if (_globalPowerMangerTemp->product_id == id && _globalPowerMangerTemp->product_ch_id == chn_id)
            {
                int value = atoi(_serviceManageRequestInfo._posix_info.firingInterval);
                if (value > 65535)
                {
                    char buf[128];
                    memset(buf, 0, sizeof(buf));
                    sprintf(buf, "product id = %d, ch id = %d start delay err.", _globalPowerMangerTemp->product_id, _globalPowerMangerTemp->product_ch_id);
                    log_e(buf);
                    continue;
                }
                _globalPowerMangerTemp->product_ch_start_delay = value;
                value = atoi(_serviceManageRequestInfo._posix_info.closeInterval);
                if (value > 65535)
                {
                    char buf[128];
                    memset(buf, 0, sizeof(buf));
                    sprintf(buf, "product id = %d, ch id = %d stop delay err.", _globalPowerMangerTemp->product_id, _globalPowerMangerTemp->product_ch_id);
                    log_e(buf);
                    continue;
                }
                _globalPowerMangerTemp->product_ch_stop_delay = value;
                ret=g_switch_set_all_start_time_delay(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp->product_ch_type,_globalPowerMangerTemp->product_saddr,_globalPowerMangerTemp->product_ch_addr,_globalPowerMangerTemp->product_ch_start_delay);
                if (ret<0)
                {
                    usleep(50000);
                    g_switch_set_all_start_time_delay(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp->product_ch_type,_globalPowerMangerTemp->product_saddr,_globalPowerMangerTemp->product_ch_addr,_globalPowerMangerTemp->product_ch_start_delay);
                    /* code */
                }

                ret = g_switch_set_all_stop_time_delay(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp->product_ch_type,_globalPowerMangerTemp->product_saddr,_globalPowerMangerTemp->product_ch_addr,_globalPowerMangerTemp->product_ch_stop_delay);
                if (ret<0)
                {
                    usleep(50000);
                    g_switch_set_all_stop_time_delay(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp->product_ch_type,_globalPowerMangerTemp->product_saddr,_globalPowerMangerTemp->product_ch_addr,_globalPowerMangerTemp->product_ch_stop_delay);
                    /* code */
                }
                
                if (dev_update_power_manage_genera_info(__globalDeviceManage.db,_globalPowerMangerTemp->product_id,_globalPowerMangerTemp->product_ch_id,_globalPowerMangerTemp) != 0)
                {
                    log_e("update pwr general data err.");
                }
                break;
            }
        }
        ack_str = ctrl_sts_ack_to_json();
        if (_serviceManageRequestInfo._posix_info.productId) free(_serviceManageRequestInfo._posix_info.productId);
        if (_serviceManageRequestInfo._posix_info.closeInterval) free(_serviceManageRequestInfo._posix_info.closeInterval);
        if (_serviceManageRequestInfo._posix_info.firingInterval) free(_serviceManageRequestInfo._posix_info.firingInterval);
        if (_serviceManageRequestInfo._posix_info.productChId) free(_serviceManageRequestInfo._posix_info.productChId);
    }   

    // 分组设置
    else if (strcmp(_serviceManageRequestInfo.type, "fzSave") == 0) // 分组设置
    {
        int nMode = atoi(_serviceManageRequestInfo._group_info.mode);
        GlobalPowerManger* _globalPowerMangerTemp = NULL ;
        int chNum= 0;

        list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
        {
            chNum++;
        }

        //初始化分组
        GroupInfo group_list;
        INIT_LIST_HEAD(&group_list.list);
        if (0 == nMode)//相邻分组方式
        {
            int xlnum = atoi(_serviceManageRequestInfo._group_info.xlnumber);
      
            if (xlnum > 0)
            {
                int pGroupNum = chNum/xlnum;
                if (chNum % xlnum>0)
                {
                    pGroupNum++;
                }
                
                dev_delete__group_info(__globalDeviceManage.db,__globalDeviceManage._global_device_info->product_id);
                for (size_t i = 0; i < pGroupNum; i++)
                {
                    GroupInfo *new_group = (GroupInfo *)malloc(sizeof(GroupInfo));
                    // 清空数据
                   memset(new_group, 0, sizeof(GroupInfo));
                    if (!new_group)
                    {
                        break;
                    }
                    new_group->product_id = __globalDeviceManage._global_device_info->product_id;
                    new_group->GroupID = i + 1;
                    sprintf(new_group->GroupName, "Group%d", i + 1);

                    int j = 0;
                    GlobalPowerManger *_globalPowerMangerTemp1 = NULL;
                    list_for_each_entry(_globalPowerMangerTemp1, &__globalDeviceManage._globalPowerManger.list, list)
                    {
                        if (j >= i * xlnum && j < (i + 1) * xlnum)
                        {
                            char chTemp[64];
                            sprintf(chTemp, "%d,", _globalPowerMangerTemp1->product_ch_id);
                            strcat(new_group->GroupChList, chTemp);
                        }
                        j++;
                    }
                    list_add_tail(&new_group->list, &group_list.list);
                    dev_insert_group_info(__globalDeviceManage.db, new_group);
                }               
            }
        }
        else if (1 == nMode)//间隔分组方式
        {
             int jgnum = atoi(_serviceManageRequestInfo._group_info.jgnumber);
            int pGroupNum = jgnum+1;
            if (pGroupNum>chNum)
            {
                pGroupNum=chNum;
            }

            if (jgnum >= 0 && pGroupNum> 0 )
            {
                dev_delete__group_info(__globalDeviceManage.db,__globalDeviceManage._global_device_info->product_id);
                for (size_t i = 0; i < pGroupNum; i++)
                {
                    GroupInfo *new_group = (GroupInfo *)malloc(sizeof(GroupInfo));
                    // 清空数据
                   memset(new_group, 0, sizeof(GroupInfo));
                    if (!new_group)
                    {
                        break;
                    }
                    new_group->product_id = __globalDeviceManage._global_device_info->product_id;
                    new_group->GroupID = i + 1;
                    sprintf(new_group->GroupName, "Group%d", i + 1);

                    int j = i;
                    int m = 0;
                    GlobalPowerManger *_globalPowerMangerTemp1 = NULL;
                    list_for_each_entry(_globalPowerMangerTemp1, &__globalDeviceManage._globalPowerManger.list, list)
                    {
                        if (m==j)
                        {
                            char chTemp[64];
                            sprintf(chTemp, "%d,", _globalPowerMangerTemp1->product_ch_id);
                            strcat(new_group->GroupChList, chTemp);
                            j=j+jgnum+1;
                        }
                        m++;
                    }
                    list_add_tail(&new_group->list, &group_list.list);
                    dev_insert_group_info(__globalDeviceManage.db, new_group);
                }               
            }
        }
        ack_str = ctrl_sts_ack_to_json();
    }
    else if (strcmp(_serviceManageRequestInfo.type, "listFzQuery") == 0) // 分组查询
    {
        // 查询分组信息
        GroupInfo group_list;
        INIT_LIST_HEAD(&group_list.list);
        if (0 == dev_get_group_info(__globalDeviceManage.db, &group_list))
        {
            // 返回分组信息
            ack_str = service_group_ack_to_json(&group_list);
        }
    }
    else if (strcmp(_serviceManageRequestInfo.type, "fzOpen") == 0) // 分组开
    {
        unsigned short pAddrCtrl[50];
        memset(pAddrCtrl,0,sizeof(pAddrCtrl));
        int ngroup= atoi(_serviceManageRequestInfo._group_info.opergroupid);
        // 查询分组信息
        GroupInfo group_list;
        INIT_LIST_HEAD(&group_list.list);
        if (0 == dev_get_group_info(__globalDeviceManage.db, &group_list))
        {
            GroupInfo *_GroupInfoTemp = NULL;
            list_for_each_entry(_GroupInfoTemp, &group_list.list, list)
            {
                if (_GroupInfoTemp->GroupID == ngroup)
                {

                    if (__globalDeviceManage._global_device_info->product_pwr_type == 1)
                    { // 直流版本功能
                        char *pCHlist;
                        char *pCHListSave;
                        pCHlist=strtok_r(_GroupInfoTemp->GroupChList, ",",&pCHListSave);
                        while(pCHlist!=NULL)
                        {
                            GlobalPowerManger *_globalPowerMangerTemp = NULL;
                            list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
                            {
                                if (_globalPowerMangerTemp == NULL)
                                    break;
                                if (atoi(pCHlist) == _globalPowerMangerTemp->product_ch_id)
                                {
                                    log_d("switch ctrl:%d,%d", _globalPowerMangerTemp->product_saddr, _globalPowerMangerTemp->product_ch_addr);
                                    pAddrCtrl[_globalPowerMangerTemp->product_saddr] |= 1 << (_globalPowerMangerTemp->product_ch_addr - 1);
                                    break;
                                }
                            }
                            pCHlist=strtok_r(NULL, ",",&pCHListSave);
                        }                       
                        for (size_t i = 0; i < 50; i++)
                        {
                            if (pAddrCtrl[i] != 0)
                            {
                                ret = g_switch_set_dcpdu_chns_ctrl(&__globalDeviceManage._globalRelaySampManger,
                                                                   i,
                                                                   pAddrCtrl[i],
                                                                   1);
                                if (ret < 0)
                                {
                                    ret = g_switch_set_dcpdu_chns_ctrl(&__globalDeviceManage._globalRelaySampManger,
                                                                       i,
                                                                       pAddrCtrl[i], 1);
                                }
                            }
                        }
                    }
                    else
                    {
                        char *pCHlist;
                        char *pCHListSave;
                        pCHlist = strtok_r(_GroupInfoTemp->GroupChList, ",",&pCHListSave);
                        //其他版本功能
                        while (pCHlist!=NULL)
                        {
                            GlobalPowerManger *_globalPowerMangerTemp = NULL;

                            list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
                            {
                                if (_globalPowerMangerTemp == NULL)
                                    break;
                                if (atoi(pCHlist) == _globalPowerMangerTemp->product_ch_id)
                                {
                                    log_d("switch ctrl:%d,%d", _globalPowerMangerTemp->product_saddr, _globalPowerMangerTemp->product_ch_addr);
                                    ret= g_switch_set_all_chn_ctrl(&__globalDeviceManage._globalRelaySampManger,
                                                              _globalPowerMangerTemp,
                                                              _globalPowerMangerTemp->product_saddr,
                                                              _globalPowerMangerTemp->product_ch_addr, // 多版端口余8
                                                              1,true);
                                    if (ret < 0)
                                    {
                                        ret = g_switch_set_all_chn_ctrl(&__globalDeviceManage._globalRelaySampManger,
                                                                        _globalPowerMangerTemp,
                                                                        _globalPowerMangerTemp->product_saddr,
                                                                        _globalPowerMangerTemp->product_ch_addr, // 多版端口余8
                                                                        1,true);
                                    }

                                    break;
                                }
                            }
                            pCHlist = strtok_r(NULL, ",",&pCHListSave);
                        }
                    }
                }
            }
        }
        ack_str = ctrl_sts_ack_to_json();
    }
    else if (strcmp(_serviceManageRequestInfo.type, "fzClose") == 0) // 分组关
    {
        unsigned short pAddrCtrl[50];
        memset(pAddrCtrl, 0, sizeof(pAddrCtrl));
        int ngroup = atoi(_serviceManageRequestInfo._group_info.opergroupid);
        // 查询分组信息
        GroupInfo group_list;
        INIT_LIST_HEAD(&group_list.list);
        if (0 == dev_get_group_info(__globalDeviceManage.db, &group_list))
        {
            GroupInfo *_GroupInfoTemp = NULL;
            list_for_each_entry(_GroupInfoTemp, &group_list.list, list)
            {
                if (_GroupInfoTemp->GroupID == ngroup)
                {
                    /* code */

                    if (__globalDeviceManage._global_device_info->product_pwr_type == 1)
                    {
                        char *pCHlist;
                        char *pCHListSave;
                        pCHlist = strtok_r(_GroupInfoTemp->GroupChList, ",",&pCHListSave);
                        // 直流版本功能
                        while (pCHlist!=NULL)
                        {
                            GlobalPowerManger *_globalPowerMangerTemp = NULL;
                            list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
                            {
                                if (_globalPowerMangerTemp == NULL)
                                    break;
                                if (atoi(pCHlist) == _globalPowerMangerTemp->product_ch_id)
                                {
                                    log_d("switch ctrl:%d,%d", _globalPowerMangerTemp->product_saddr, _globalPowerMangerTemp->product_ch_addr);
                                    pAddrCtrl[_globalPowerMangerTemp->product_saddr] |= 1 << (_globalPowerMangerTemp->product_ch_addr-1);
                                    break;
                                }
                            }
                            pCHlist = strtok_r(NULL, ",",&pCHListSave);
                        }
                        for (size_t i = 0; i < 50; i++)
                        {
                            if (pAddrCtrl[i] != 0)
                            {
                                ret = g_switch_set_dcpdu_chns_ctrl(&__globalDeviceManage._globalRelaySampManger,
                                                             i,
                                                             pAddrCtrl[i],
                                                             0);
                                if (ret < 0)
                                {
                                    ret = g_switch_set_dcpdu_chns_ctrl(&__globalDeviceManage._globalRelaySampManger,
                                                                       i,
                                                                       pAddrCtrl[i],
                                                                       0);
                                    /* code */
                                }
                            }
                        }
                    }
                    else
                    {
                        char *pCHlist;
                        char *pCHListSave;
                        pCHlist=strtok_r(_GroupInfoTemp->GroupChList, ",",&pCHListSave);
                        while (pCHlist!=NULL)
                        {
                            GlobalPowerManger *_globalPowerMangerTemp = NULL;
                            list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
                            {
                                if (_globalPowerMangerTemp == NULL)
                                    break;
                                if (atoi(pCHlist) == _globalPowerMangerTemp->product_ch_id)
                                {
                                    log_d("switch ctrl:%d,%d", _globalPowerMangerTemp->product_saddr, _globalPowerMangerTemp->product_ch_addr);
                                    ret = g_switch_set_all_chn_ctrl(&__globalDeviceManage._globalRelaySampManger,
                                                                    _globalPowerMangerTemp,
                                                                    _globalPowerMangerTemp->product_saddr,
                                                                    _globalPowerMangerTemp->product_ch_addr, // 多版端口余8
                                                                    0,true);
                                    if (ret < 0)
                                    {
                                        ret = g_switch_set_all_chn_ctrl(&__globalDeviceManage._globalRelaySampManger,
                                                                        _globalPowerMangerTemp,
                                                                        _globalPowerMangerTemp->product_saddr,
                                                                        _globalPowerMangerTemp->product_ch_addr, // 多版端口余8
                                                                        0,true);
                                    }

                                    break;
                                }
                            }
                            pCHlist = strtok_r(NULL, ",",&pCHListSave);                            
                        }
                    }
                }
            }
        }
        ack_str = ctrl_sts_ack_to_json();
    }
    
    http_reply(conn, 200, ack_str);
    cJSON_free((void*)ack_str);
}

/// @brief 系统管理
/// @param stream 
static void systemManagent(void *conn)
{
    __globalDeviceManage.view_page=-1;
    int ret = -1 ;
    char* rx_body_buf = NULL;
    _UserRoleManageInfo _UserRoleManageRequestInfo;
    char* ack_str = NULL ;

#ifdef USE_WEBAPP
    HttpStream *s=(HttpStream*)conn;
    rx_body_buf = httpGetBodyInput(s);
#else
    mg_stream_t *s=(mg_stream_t*)conn;
    struct mg_http_message *msg=s->ev_data;
    rx_body_buf = msg->body.buf;
#endif

    //转换json参数
    if(json_to_user_manage(rx_body_buf,&_UserRoleManageRequestInfo)!=0)
    {
        http_reply(conn, 400, NULL);
        return ;        
    }
    //获取角色信息
    else if(strcmp(_UserRoleManageRequestInfo.type,"getUser")==0)
    {
        // 查询用户信息
        UserInfo User_list;
        INIT_LIST_HEAD(&User_list.list);
        // 查询角色信息
        RoleInfo Role_list;
        INIT_LIST_HEAD(&Role_list.list);
        ack_str = ctrl_sts_ack_to_json();

        if (0 == dev_get_user_info(__globalDeviceManage.db, &User_list) && 0 == dev_get_role_info(__globalDeviceManage.db, &Role_list) 
            /*&& strcmp(_UserRoleManageRequestInfo.userName,"")!=0*/)
        {
            char *nName=getUserNamebyToken(_UserRoleManageRequestInfo.user_token);
            if (nName!=NULL)
            {
                ack_str = service_userRole_ack_to_json(nName,&User_list, &Role_list);
            }
        }
        
    } 
    //查询用户列表 
    else if(strcmp(_UserRoleManageRequestInfo.type,"listUserQuery")==0)
    {
        // 查询用户信息
        UserInfo User_list;
        INIT_LIST_HEAD(&User_list.list);
        // 查询角色信息
        RoleInfo Role_list;
        INIT_LIST_HEAD(&Role_list.list);
        ack_str = ctrl_sts_ack_to_json();

        if (0 == dev_get_user_info(__globalDeviceManage.db, &User_list) && 0 == dev_get_role_info(__globalDeviceManage.db, &Role_list) 
            /*&& strcmp(_UserRoleManageRequestInfo.userName,"")!=0*/)
        {
            char *nName = getUserNamebyToken(_UserRoleManageRequestInfo.user_token);
            if (nName != NULL)
            {
                ack_str = service_userQuery_ack_to_json(nName, &User_list, &Role_list);
            }
        }
    }   
    //删除用户
    else if(strcmp(_UserRoleManageRequestInfo.type,"deleteUser")==0)
    {
        //char *pUserlist;
        //char *pUserListSave;
       // pUserlist = strtok_r(_UserRoleManageRequestInfo.userIds, ",", &pUserListSave);

        //while (pUserlist != NULL)
        //{
            dev_delete_user_info(__globalDeviceManage.db,_UserRoleManageRequestInfo.userIds);
          //  pUserlist = strtok_r(NULL, ",", &pUserListSave);
       // }
    }   
    //添加用户
    else if(strcmp(_UserRoleManageRequestInfo.type,"addUser")==0)
    {
        UserInfo *new_user = (UserInfo *)malloc(sizeof(UserInfo));
        memset(new_user,0,sizeof(UserInfo));

        new_user->product_id =  __globalDeviceManage._global_device_info->product_id;

        int nMaxUserNum=1;
        UserInfo User_list;
        INIT_LIST_HEAD(&User_list.list);
       // 查询角色信息
        RoleInfo Role_list;
        INIT_LIST_HEAD(&Role_list.list);

        if (0 == dev_get_user_info(__globalDeviceManage.db, &User_list) && 0 == dev_get_role_info(__globalDeviceManage.db, &Role_list))
        {

            UserInfo *_UserInfoTemp = NULL;
            list_for_each_entry(_UserInfoTemp, &User_list.list, list)
            {
                if (_UserInfoTemp == NULL)
                    break;

                if (_UserInfoTemp->userID >= nMaxUserNum)
                {
                    nMaxUserNum=_UserInfoTemp->userID;
                }
            }

            new_user->userID = nMaxUserNum+1;

            new_user->userName = malloc(256);
            strcpy(new_user->userName, _UserRoleManageRequestInfo.userName);
            new_user->userPW = malloc(256);
            strcpy(new_user->userPW, _UserRoleManageRequestInfo.password);
            new_user->nickName = malloc(256);
            strcpy(new_user->nickName, _UserRoleManageRequestInfo.nickName);
            new_user->roleID = _UserRoleManageRequestInfo.roleId;//GetRoleIDByName(_UserRoleManageRequestInfo.roleName,&Role_list);

            new_user->createTime = malloc(64);
            struct tm *t;
            struct timeval tv;
            gettimeofday(&tv, NULL);
            t = localtime(&tv.tv_sec);
            sprintf(new_user->createTime, "%04d-%02d-%02d %02d:%02d:%02d", t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, 23, 59, 59);

            dev_insert_user_info(__globalDeviceManage.db, new_user);
        }

        ack_str=ctrl_sts_ack_to_json();
    }   
    //更新用户信息
    else if(strcmp(_UserRoleManageRequestInfo.type,"updateUser")==0)
    {
        UserInfo *new_user = (UserInfo *)malloc(sizeof(UserInfo));
        memset(new_user,0,sizeof(UserInfo));

        new_user->product_id =  __globalDeviceManage._global_device_info->product_id;
        new_user->userID = _UserRoleManageRequestInfo.userId;
        new_user->userName = malloc(256);
        strcpy(new_user->userName , _UserRoleManageRequestInfo.userName);
        new_user->userPW = malloc(256);
        strcpy(new_user->userPW , _UserRoleManageRequestInfo.password);
        new_user->nickName = malloc(256);
        strcpy(new_user->nickName , _UserRoleManageRequestInfo.nickName);
        new_user->roleID = _UserRoleManageRequestInfo.roleId;
        new_user->createTime = malloc(64);
        strcpy(new_user->createTime , _UserRoleManageRequestInfo.createTime);

        dev_update_user_info(__globalDeviceManage.db, new_user);

        ack_str=ctrl_sts_ack_to_json();
    }    

    http_reply(conn, 200, ack_str);
    cJSON_free((void*)ack_str);
}

/// @brief 设备重启
/// @param stream 
static void equipmentMintenance(void *conn)
{
    int ret = -1 ;
    char* rx_body_buf = NULL;
    char* ack_str = NULL ;
     _OverBackStsInfo _over_back_sts_info;       //设备总体状态信息
    _Equipment_Mintenance _Over_equipment_mintenance;

#ifdef USE_WEBAPP
    HttpStream *s=(HttpStream*)conn;
    rx_body_buf = httpGetBodyInput(s); 
    usleep(500000);
#else
    mg_stream_t *s=(mg_stream_t*)conn;
    struct mg_http_message *msg=s->ev_data;
    rx_body_buf = msg->body.buf;
#endif

    //转换json参数
    if(json_to_over_equipment_mintenance(rx_body_buf,&_Over_equipment_mintenance)!=0)
    {
        http_reply(conn, 400, NULL);
        return ;
    }
    //查询设备列表
    if(strcmp(_Over_equipment_mintenance.type,"listSbRestartQuery")==0)
    {
        // 查询设备总体参数
       if (dev_get_device_info(__globalDeviceManage.db,__globalDeviceManage._global_device_info) != 0)
        {
            log_e("get device info error.\n");
            http_reply(conn, 400, NULL);
            return;
        }

        _over_back_sts_info.product_name = __globalDeviceManage._global_device_info->product_name;
        _over_back_sts_info.product_number = __globalDeviceManage._global_device_info->product_number;
        _over_back_sts_info.product_id = __globalDeviceManage._global_device_info->product_id;
        _over_back_sts_info.product_Code = malloc(8);
        strcpy(_over_back_sts_info.product_Code, "-");
       // _over_back_sts_info.product_type = malloc(32);
        //strcpy(_over_back_sts_info.product_type, "GC Series");
        _over_back_sts_info.product_type=g_product_type_str[__globalDeviceManage._global_device_info->product_type];
        _over_back_sts_info.productVersion = __globalDeviceManage._global_device_info->product_version;
 
        _over_back_sts_info.product_sysTime = malloc(32);
        struct tm *t;
        struct timeval tv;
        gettimeofday(&tv, NULL);
        t = localtime(&tv.tv_sec);
        sprintf(_over_back_sts_info.product_sysTime, "%04d-%02d-%02d %02d:%02d:%02d", t->tm_year + 1900, t->tm_mon + 1,
                t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec);

        long diff =0;
        struct timespec ts;
        if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0)
        {
          diff = ts.tv_sec;
        }
        sprintf(_over_back_sts_info.product_runTime, "%02ld:%02ld:%02ld", diff / 3600, (diff % 3600) / 60, diff % 60);
        _over_back_sts_info.productAddr = getLocalIpAddress("eth0");

        _over_back_sts_info.product_mac = get_mac_address("eth0");

        _over_back_sts_info.product_RS485Addr = __globalDeviceManage._global_device_info->_gmodbus_info.product_modbus_addr;

        //_over_back_sts_info.product_status = __globalDeviceManage._global_device_info ->product_status;
        _over_back_sts_info.product_status = malloc(16);
        strcpy(_over_back_sts_info.product_status, "online");

        _over_back_sts_info.product_type_id=__globalDeviceManage._global_device_info->product_pwr_type;


         ack_str = over_product_list_info_to_json(&__globalDeviceManage, &_over_back_sts_info);
    }
    else if(strcmp(_Over_equipment_mintenance.type,"listShfwQuery")==0)
    {

    }
    else if(strcmp(_Over_equipment_mintenance.type,"sBRestart")==0) {  //restart
        if(strcmp(_Over_equipment_mintenance.product_name,__globalDeviceManage._global_device_info->product_name)) {
            sys_reboot();
        }
        else {
            //send to other device
        }
    }
    else if(strcmp(_Over_equipment_mintenance.type,"restoreFactorySettings")==0) {  //restore to factory
        if(strcmp(_Over_equipment_mintenance.product_name,__globalDeviceManage._global_device_info->product_name)) {
            sys_set_factory();
        }
        else {
            //send to other device
        }
    }
    
    http_reply(conn, 200, ack_str);
    cJSON_free((void*)ack_str);
}


typedef struct {
  size_t expected;  // POST data length, bytes
  size_t received;  // Already received bytes
  void *fp;         // Opened uploaded file
}upload_stat_t;
static void equipmentMintenanceUpload(void *conn)
{
    int ret = -1 ;
    char* ack_str = "OK" ;
    int len,tlen=0;

#ifdef USE_WEBAPP
    HttpStream *s=(HttpStream*)conn;
    http_reply(conn, 200, NULL);
#else
    mg_stream_t *s=(mg_stream_t*)conn;
    upload_stat_t *us = (upload_stat_t *) s->c->data;
    struct mg_fs *fs = &mg_fs_posix;
    
    if (s->ev == MG_EV_HTTP_HDRS) {
        struct mg_http_message *hm = (struct mg_http_message *) s->ev_data;
        char path[MG_PATH_MAX];
        mg_snprintf(path, sizeof(path), "%s/%.*s", "/root/dl", hm->uri.len - 8,
                    hm->uri.buf + 8);
        us->expected = hm->body.len;  // Store number of bytes we expect
         mg_iobuf_del(&s->c->recv, 0, hm->head.len);
        mg_iobuf_del(&s->c->recv, 0, hm->head.len);  // Delete HTTP headers
        s->c->pfn = NULL;  // Silence HTTP protocol handler, we'll use MG_EV_READ
        if (mg_path_is_sane(mg_str(path))) {
          fs->rm(path);                        // Delete file if it exists
          us->fp = fs->op(path, MG_FS_WRITE);  // Open file for writing
        }
    }

    // Catch uploaded file data for both MG_EV_READ and MG_EV_HTTP_HDRS
    if (us->expected > 0 && s->c->recv.len > 0) {
        us->received += s->c->recv.len;
        if (us->fp) fs->wr(us->fp, s->c->recv.buf, s->c->recv.len);  // Write to file
        s->c->recv.len = 0;  // Delete received data
        if (us->received >= us->expected) {
            // Uploaded everything. Send response back
            MG_INFO(("Uploaded %lu bytes", us->received));
            mg_http_reply(s->c, 200, NULL, "%lu ok\n", us->received);
            if (us->fp) fs->cl(us->fp);  // Close file
            memset(us, 0, sizeof(*us));  // Cleanup upload state
            s->c->is_draining = 1;          // Close connection when response gets sent
        }
    }  
#endif
}

static int webSetCallback(void)
{
	httpAddCallback("/login", loginFunc);//登录
#if 1
    httpAddCallback("/logout", loginOutFunc);//登出
    httpAddCallback("/getInfo", getUserInfo);//获取用户信息
	httpAddCallback("/pdu/changeLanguages", changeLanguages);//切换语言
    httpAddCallback("/pdu/systemConfiguration", systemConfiguration);//登录
    httpAddCallback("/getRouters", getUserRouters);//获取菜单接口
    httpAddCallback("/pdu/overallStatusMonitoring", overallStatusMonitoring);//设备电源监控信息
    httpAddCallback("/pdu/channelStatusMonitoring", channelStatusMonitoring);//设备通道电源监控信息
    httpAddCallback("/pdu/sensorStatusMonitoring", sensorStatusMonitoring);//传感器总体请求信息
    httpAddCallback("/pdu/alarmProtect", alarmProtect);//告警历史信息 
    httpAddCallback("/pdu/logInformation", logInformation);//日志
    httpAddCallback("/pdu/communicationManagement", communicationManagement);//通信设置
    httpAddCallback("/pdu/serviceManagement", serviceManagement);//服务管理
    httpAddCallback("/pdu/system", systemManagent);//用户管理
    httpAddCallback("/pdu/equipmentMintenance", equipmentMintenance);//设备重启 
    httpAddCallback("/pdu/equipmentMintenanceUpload", equipmentMintenanceUpload); //固件升级
#endif
	
    return 0;
}





/// @brief appinit初始化
/// @param  
/// @return 
int appweb_init(void)
{
    sys_start_thread(THREAD_ID_UPDATE, update_thread, &__globalDeviceManage);
    sys_start_thread(THREAD_ID_WEB, web_thread, &__globalDeviceManage);
    
    return 0;
}