app.py_2

# coding=utf-8
#!/usr/bin/evn python
import flask
from flask import request,redirect,url_for,jsonify
#from werkzeug import secure_filename
import json,os,re,time,io,datetime
import requests
import ConfigParser
import sys

from werkzeug.utils import secure_filename

from log_module import logger

from code_convert import convert_code,wenan_code_huawei_code_CSYS,wenan_code_huawei_code_CLPP,wenan_code_huawei_code_CLLX\
    ,wenan_code_huawei_code_CDLX,wenan_code_huawei_code_event,wenan_code_huawei_code_HPYS,wenan_code_huawei_code_HPZL\
    ,wenan_code_huawei_code_WFDM,wenan_code_huawei_code_SJLX

from date_format import strtime_format_msec,strtime_format_nomsec

from tid_model import tid_maker,tid_end_dt

import videoconvert as videoutil
from upload_video_ftp import ftpconnect,uploadfile

from Queue import Queue
#import retry_model
from retry_model import retry_send


##调试写文件
def debug_writeFile(data,file_name):
    #print 'wirte %s data--------------' %(data['event_type'])
    with open(file_name, mode='w') as fp:
        fp.write(json.dumps(data))


##配置文件
config = ConfigParser.RawConfigParser(allow_no_value=True)
config.read(r'/opt/thrid_data.conf')
#config.read(r'thrid_data.conf')

hostIP = config.get('hostIP', 'hostIP')
service_port = config.get('hostIP', 'port')
illegal_url = config.get('illegal', 'url')
event_url = config.get('event', 'url')
t_flow_url = config.get('t_flow', 'url')
vehicle_url = config.get('vehicle', 'url')
ftpServerIP = config.get('ftp', 'ftpServerIP')
ftpUserName = config.get('ftp', 'ftpUserName')
ftpPassWord = config.get('ftp', 'ftpPassWord')


###替换字典key方法

def replace_Dictkey(source_dict,key_dict):
    #print 'replace_dictkey old_key is %r------------------' %key_dict
    for old_key in key_dict:
        #print('old_key is :%s' %old_key)
        if source_dict.has_key(old_key):
            source_dict[key_dict[old_key]] = source_dict.pop(old_key)
        else:
            print('source_dict not key:%s' %old_key)

#删除字段中字段
def del_dictKey(sour_dict,dict_keyList):
    for dict_key in dict_keyList:
        if sour_dict.has_key(dict_key):
            del sour_dict[dict_key]
        else:
            print 'sour_dict no key :%s' %dict_key

vehicle_event_oldKey = ['lane','illegal','version','vehicle','device','model','ID','speed','location','pics','RefinedFeature','driver']#,'start_dt','end_dt'
#交通卡口和违法数据重构
def make_vehicle(event_data_dict):
        #debug_writeFile(event_data_dict, 'make_vehicle_Data_to_json.txt')
    #try:
        #采集方式
        #del event_data_dict['CJFX']
        event_data_dict['GCSJ'] = event_data_dict.pop('TJSD')
        # #设备编号
        # event_data_dict['SBBH'] = event_data_dict['device'].pop('code')
        # #方向类型
        # event_data_dict['FXLX'] = event_data_dict['location']['direction'].pop('code')
        #车道号
        #event_data_dict['CDH'] = event_data_dict['lane'].pop('number')
        #抓拍方向
        event_data_dict['ZPFX'] = event_data_dict.pop('model')
        if event_data_dict['ZPFX'] == '0':
            event_data_dict['ZPFX'] = '2'


        if event_data_dict['illegal']['state'] == 0:
            print '***---过车数据---****'
            #转换成过车卡口数据
            # 车身body类
            # 车辆型号---子品牌？---当前结构里没有子品牌
            if event_data_dict['vehicle'].has_key('body'):
                if event_data_dict['vehicle']['body'].has_key('sublogo'):
                    event_data_dict['CLXH'] = event_data_dict['vehicle']['body']['sublogo']['name']

                event_data_dict['CLPP'] = event_data_dict['vehicle']['body']['logo']['code']
                # # 年款
                # event_data_dict['CLNK1'] = 'unknown'
                # 车身颜色
                event_data_dict['CSYS'] = event_data_dict['vehicle']['body']['color']['code']

                # 车辆类型
                event_data_dict['CLLX'] = event_data_dict['vehicle']['body']['type'].pop('code')
                # 二次识别-号牌类plate
                # plate_keys = {'text': 'HPHM1', 'type_code': 'HPZL1', 'color_code': 'HPYS1'}
                # replace_Dictkey(event_data_dict['vehicle']['plate'], plate_keys)



            event_data_dict['HPHM'] = event_data_dict['vehicle']['plate'].pop('text')
            if event_data_dict['HPHM'] == u'无牌':
                event_data_dict['HPHM'] = '-'
            event_data_dict['HPZL'] = event_data_dict['vehicle']['plate'].pop('type_code')
            if event_data_dict['HPZL'] in ['31', '32', '00']:
                event_data_dict['HPZL'] = convert_code(event_data_dict['HPZL'], wenan_code_huawei_code_HPZL)

            #event_data_dict['HPZL1'] = convert_code(event_data_dict['HPZL1'], wenan_code_huawei_code_HPZL)
            event_data_dict['HPYS'] = event_data_dict['vehicle']['plate'].pop('color_code')
            #event_data_dict['HPYS1'] = convert_code(event_data_dict['HPYS1'],wenan_code_huawei_code_HPYS)
            if event_data_dict['ZPSL'] > 1:
                event_data_dict['ZP1'] = event_data_dict['pics'][0].pop('pic_base64')
                event_data_dict['ZP2'] = event_data_dict['pics'][1].pop('pic_base64')
            else:
                event_data_dict['ZP1'] = event_data_dict['pics'][0].pop('pic_base64')
                #必须字段没有赋值ZP1
                event_data_dict['ZP2'] = event_data_dict['ZP1']

            del event_data_dict['ZPSL']
            del event_data_dict['start_dt']
            del event_data_dict['end_dt']

            ##转换号牌code
            print('test---------HPYS', event_data_dict['HPYS'])
            event_data_dict['HPYS'] = convert_code(event_data_dict['HPYS'],wenan_code_huawei_code_HPYS)
            print('test---------HPYS---end', event_data_dict['HPYS'])
            #debug_writeFile(event_data_dict,'makevehile.log')
        else:
            #转成违法数据
            print 'illegal state is :%s' %(event_data_dict['illegal']['state']),'***---违法数据---***'

            ####*****将相应的违法转换成事件----逆行、拥堵、缓行、变道,非机动车逆行
            #illegal_eventCode = ['06','01','40','26','61','21','19']
            illegal_eventCode = ['shijianweidinyi']
            if event_data_dict['illegal'].has_key('code'):
                #添加违法视频名（短时录像）字段
                if event_data_dict.has_key('video'):
                    if event_data_dict['video'].has_key('unid'):
                        if(event_data_dict['video']['unid']) > 0:
                            event_data_dict['WFSPWJM'] = event_data_dict['video'].pop('unid')

                if event_data_dict['illegal']['code'] in illegal_eventCode:
                    print '违法转事件***********************：%s',event_data_dict['illegal']['code']
                    #make_event_data(event_data_dict)---有重复处理字段报错-暂时不调用该函数
                    #debug_writeFile(event_data_dict,'illegal_eventCode.txt')
                    # 车道类型
                    event_data_dict['CDLX'] = event_data_dict['lane'].pop('code')
                    # if event_data.has_key('CDLX'):
                    #     event_data['CDLX'] = convert_code(event_data['CDLX'], wenan_code_huawei_code_CDLX)
                    # 二次识别-号牌类plate
                    # plate_keys = {'text': 'HPHM', 'type_code': 'HPZL'}
                    # replace_Dictkey(event_data_dict['vehicle']['plate'], plate_keys)
                    # debug_writeFile(event_data_dict,'debug.log')
                    #
                    # if event_data_dict['HPZL'] in ['51', '52', '00']:
                    #     event_data_dict['HPZL'] = convert_code(event_data_dict['HPZL'], wenan_code_huawei_code_HPZL)
                    #event_data_dict['HPZL'] = convert_code(event_data_dict['HPZL'], wenan_code_huawei_code_HPZL)
                    # 发生地点
                    event_data_dict['FSDD'] = event_data_dict['location'].pop('name')
                    if event_data_dict['FSDD'] == "":
                        print('FSDD','no adress....')
                        event_data_dict['FSDD'] = 'no adress'
                    # 开始结束时间
                    event_data_keys = {'start_dt': 'FSSJ', 'end_dt': 'JSSJ'}
                    replace_Dictkey(event_data_dict, event_data_keys)
                    # 事件
                    event_data_dict['SJLX'] = event_data_dict['illegal'].pop('code')
                    # 图片
                    event_data_dict['ZP1'] = event_data_dict['pics'][0].pop('pic_base64')
                    event_data_dict['ZPLJ1'] = 'no url'
                    # 视频字段
                    event_data_dict['KSSP'] = 'no video'

                    illegal_event_delkey = ['GCSJ',"KKBH","ZPFX","ZPSL","CJFX"]
                    del_dictKey(event_data_dict,illegal_event_delkey)

                    ##转换事件code
                    event_data_dict['SJLX'] = convert_code(event_data_dict['SJLX'],wenan_code_huawei_code_event)

                else:
                    if event_data_dict['vehicle'].has_key('body'):
                        print('违法转换.....')
                        #####交通违法
                        #debug_writeFile(event_data_dict,'weifa.txt')
                        # 车道类型
                        event_data_dict['CDLX'] = event_data_dict['lane'].pop('code')
                        #event_data_dict['CDLX'] = convert_code(event_data_dict['CDLX'], wenan_code_huawei_code_CDLX)
                        # # 二次识别-号牌类plate
                        # plate_keys = {'text': 'HPHM', 'type_code': 'HPZL'}
                        # replace_Dictkey(event_data_dict['vehicle']['plate'], plate_keys)
                        event_data_dict['HPHM'] = event_data_dict['vehicle']['plate'].pop('text')
                        if event_data_dict['HPHM'] == u'无牌':
                            event_data_dict['HPHM'] = '-'
                        event_data_dict['HPZL'] = event_data_dict['vehicle']['plate'].pop('type_code')

                        if event_data_dict['HPZL'] in ['51','52','00']:
                            event_data_dict['HPZL'] = convert_code(event_data_dict['HPZL'], wenan_code_huawei_code_HPZL)
                        # 车辆类型
                        event_data_dict['CLLX'] = event_data_dict['vehicle']['body']['type'].pop('code')
                        # #违法地行政区划分
                        # event_data_dict['XZQH'] = '430801'
                        # #违法地点
                        # event_data_dict['WFDD'] = event_data_dict['location'].pop('name')
                        # if event_data_dict['WFDD'] == "":
                        #     event_data_dict['WFDD'] ='null adress'
                        event_data_keys = {'start_dt':'WFKSSJ','end_dt':'WFJSSJ'}
                        replace_Dictkey(event_data_dict, event_data_keys)
                        #违法代码
                        event_data_dict['WFDM'] = event_data_dict['illegal'].pop('code')
                        if event_data_dict['WFDM'] in [wenan_code[0] for wenan_code in wenan_code_huawei_code_WFDM]:
                            event_data_dict['WFDM'] = convert_code(event_data_dict['WFDM'], wenan_code_huawei_code_WFDM)
                        #区间距离--无
                        event_data_dict['QJJL'] = '0001'
                        #区间用时
                        event_data_dict['QJYS'] = "1"
                        # #设备经度
                        # event_data_dict['SBJD'] ='114.041816'
                        # #设备纬度
                        # event_data_dict['SBWD'] = '27.634384'
                        #图片
                        names = locals()
                        print '照片数量：%d' %(event_data_dict['ZPSL'])
                        for i in range(event_data_dict['ZPSL']):
                            names['ZP%d' % (i + 1)] = i
                            # print('pic***',event_data_dict['pics'][i].pop('pic_base64'))
                            event_data_dict.setdefault('ZP%d' %(i + 1),event_data_dict['pics'][i].pop('pic_base64'))
                        illegal_delkey = ["FXLX","KKBH","ZPFX","GCSJ"]
                        del_dictKey(event_data_dict,illegal_delkey)


        del_dictKey(event_data_dict, vehicle_event_oldKey)
        #debug_writeFile(event_data_dict, 'Vehicle_makeDatajson.txt')
        return True
    #except Exception as e:
        print e,'---***except***--- in vehicle'
        return False



#交通流量数据重构
Tflow_dictNewKey = {'queue_length':'PJPDCD',
                    'distance':'PJCSJJ',
                    'velocity':'PJSD',
                    'sample_num':'TXCLS',
                    'sample_dura':'TJZQS',
                    'road':'CDH',
                    'space_occupy':'CDKJZYL',
                    'road_type':'CDLX',
                    'dist_time':'PJCTSJ'
                    #'direction':'FXLX'
                    }

def make_tflow(event_data_dict):
    try:
        # global event_data
        # event_data = {}
        #
        # print type(event_data_dict)
        # print type(event_data)
        # 方向类型
        event_data_dict['FXLX'] = event_data_dict['direction'].pop('code')
        del event_data_dict['direction']
        #只需要机动车流量
        if event_data_dict.has_key('big_vehicle'):
            #处理机动车--大车数据
            for bigV_data in event_data_dict['big_vehicle']:
                #print data,'data----------',data['queue_length'],type(data)
                #替换字典的key值
                #data['PJPDCD'] = data.pop('queue_length')
                replace_Dictkey(bigV_data,Tflow_dictNewKey)
                del bigV_data['velocity_unit']
                del bigV_data['occupy']
                # if 'space_occupy' in bigV_data:
                #     del bigV_data['space_occupy']
        #处理机动车--小车数据
        if event_data_dict.has_key('small_vehicle'):
            for smallV_data in event_data_dict['small_vehicle']:
                replace_Dictkey(smallV_data, Tflow_dictNewKey)
                del smallV_data['velocity_unit']
                del smallV_data['occupy']
                # if 'space_occupy' in smallV_data:
                #     del smallV_data['space_occupy']
        #处理公交车
        if event_data_dict.has_key('bus'):
            for bus_data in event_data_dict['bus']:
                replace_Dictkey(bus_data, Tflow_dictNewKey)
                del bus_data['velocity_unit']
                del bus_data['occupy']


        if event_data_dict.has_key('xcycle'):
            del event_data_dict['event_data_dict']['xcycle']
        if event_data_dict.has_key('pedestrian'):
            del event_data_dict['event_data_dict']['pedestrian']
        # if event_data_dict.has_key('bus'):
        #     del event_data_dict['bus']

        del event_data_dict['device']

        if event_data_dict.has_key('location'):
            del event_data_dict['location']

        event_data_dict['TJSD'] = strtime_format_nomsec(event_data_dict['TJSD'])
        #event_data_dict['CDH'] = int(event_data_dict['CDH'])
        #debug_writeFile(event_data_dict, 'Tflow_makeData_event.txt')
        ##流量数据按车道号发出去
        bigC = event_data_dict.pop('big_vehicle')
        smallC = event_data_dict.pop('small_vehicle')
        busC = event_data_dict.pop('bus')


        #global event_data
        tflow_data_list = []
        #合并大小车车流量、平均速度
        for (b_data,s_data,bus_data) in zip(bigC,smallC,busC):
            #event_data_dict = dict(event_data_dict, **s_data)
            event_data_dict['PJSD'] = (s_data.pop('PJSD')*s_data['TXCLS'] + b_data.pop('PJSD')*b_data['TXCLS'] + bus_data.pop('PJSD')*bus_data['TXCLS'])/3.0
            event_data_dict['TXCLS'] = s_data.pop('TXCLS') + b_data.pop('TXCLS') + bus_data.pop('TXCLS')

            #######这的问题导致数据结构不对------
            new_event_data = dict(event_data_dict, **s_data)
            tflow_data_list.append(new_event_data)
        # del event_data_dict['big_vehicle']
        # del event_data_dict['small_vehicle']
        # debug_writeFile(event_data_dict,'Tflow_makeData.txt')
        debug_writeFile(tflow_data_list, 'Tflow_makeData_list.txt')
        return [True,tflow_data_list]
    except Exception as e:
        print e ,'---***except***---except***--- in Tflow'
        return [False,[]]


def make_pflow(event_data_dict):
    try:
        if event_data_dict.has_key('aux_dev_info'):
            del event_data_dict['aux_dev_info']
        event_data_dict  = event_data_dict['event_data_dict']
        if event_data_dict.has_key('xcycle'):
            xcycle = event_data_dict['xcycle']
            for region in xcycle:
                if region.has_key('regionid'):
                    del region['regionid']
                if region.has_key('regionname'):
                    del region['regionname']
                if region.has_key('sample_num_in'):
                    region['in_num'] = region['sample_num_in']
                    del region['sample_num_in']
                if region.has_key('sample_num_out'):
                    region['out_num'] = region['sample_num_out']
                    del region['sample_num_out']
        if event_data_dict.has_key('pedestrian'):
            pedestrian = event_data_dict['pedestrian']
            for region in pedestrian:
                if region.has_key('regionid'):
                    del region['regionid']
                if region.has_key('regionname'):
                    del region['regionname']
                if region.has_key('sample_num_in'):
                    region['in_num'] = region['sample_num_in']
                    del region['sample_num_in']
                if region.has_key('sample_num_out'):
                    region['out_num'] = region['sample_num_out']
                    del region['sample_num_out']
        # with open('PflowData.txt', 'w') as fp:
        #     #print 'pFlow......'
        #     fp.write(json.dumps(event_data_dict, indent=4))
        return True
    except Exception as e:
        print e,'---***except***---in Pflow'
        return False

event_data_oldKey = ["lane","pics","device","TJSD","plate_text","laneNO","direction","direction_name","locate_id","laneType","device_id","device_name","locate_name"]
def make_event_data(event_data_dict):
    try:
        # 设备编号
        #debug_writeFile(event_data_dict,'make_event_data.txt')

        #event_data_dict['SBBH'] = event_data_dict['device'].pop('code')
        if len(event_data_dict['SBBH']) < 18:
            print('SBBH','lenth less 18')
            event_data_dict['SBBH'] = "123456789987654321"
        # 方向类型
        #event_data_dict['FXLX'] = event_data_dict['location']['direction'].pop('code')
        # 车道号
        # event_data_dict['CDH'] = event_data_dict['lane'].pop('number')
        # if event_data_dict['CDH'] == 0:
        #     event_data_dict['CDH'] = 1
        # 车道类型
        event_data_dict['CDLX'] = event_data_dict['lane'].pop('code')

        # # 发生地点
        # event_data_dict['FSDD'] = event_data_dict['location'].pop('name')
        # if event_data_dict['FSDD'] == "":
        #     print('FSDD', 'no adress....')
        #     event_data_dict['FSDD'] = 'no adress'
        # 开始结束时间
        event_data_keys = {'start_dt': 'FSSJ', 'end_dt': 'JSSJ'}
        replace_Dictkey(event_data_dict, event_data_keys)

        event_data_dict['FSSJ'] = strtime_format_nomsec(event_data_dict['FSSJ'])
        event_data_dict['JSSJ'] = strtime_format_nomsec(event_data_dict['JSSJ'])
        # event_data['FSSJ'] = strtime_format_nomsec(event_data['FSSJ'])
        # event_data['JSSJ'] = strtime_format_nomsec(event_data['JSSJ'])
        # # 事件类型
        # event_data_dict['SJLX'] = event_data_dict['illegal'].pop('code')
        # 图片
        event_data_dict['ZP1'] = event_data_dict['pics'][0].pop('pic_base64')
        #视频字段
        del_dictKey(event_data_dict, event_data_oldKey)
        #debug_writeFile(event_data_dict, 'make_event_data_end.txt')
        #time.sleep(10)
        return True
    except Exception as e:
        print e, '---***except***---in event_data'
        return False


ped_xcy_event_oldKey = ['lane','illegal','pedestrian','driver','device','location','pics']
#行人事件数据重构
def make_pedestrian(event_data_dict):
    try:
        make_event_data(event_data_dict)
        del_dictKey(event_data_dict,ped_xcy_event_oldKey)
        # names = locals()
        # for i in range(1, event_data_dict['ZPSL'] + 1):
        #     # 先定义，后引用避免错误
        #     names['ZP%d' % i] = ''
        #     event_data_dict[names['ZP%d' % i]] = event_data_dict['pics'][i - 1].pop('pic_base64')

        #debug_writeFile(event_data_dict, 'Ped_makeDatajson.txt')
        print('***---行人事件-Ped---***')
        return True
    except Exception as e:
        print e,'---***except***---in Pedestrian'
        return False


#周界事件数据重构
def make_behavior(event_data_dict):
    try:
        event_type = event_data_dict['event_type']
        new_event_type = event_type
        if '26' == event_type:
            new_event_type = '1'
        if '25' == event_type:
            new_event_type = '2'
        if '23' == event_type or '24' == event_type:
            new_event_type = '3'
        event_data_dict['event_type'] = new_event_type
        return True
    except Exception as e:
        print e,'---***except***--- in Behavior'
        return False

#非机动车-骑自行车
def make_xcycle(event_data_dict):
    try:
        make_event_data(event_data_dict)
        del_dictKey(event_data_dict, ped_xcy_event_oldKey)

        #debug_writeFile(event_data_dict, 'Xcy_makeDatajson.txt')
        print('***---非机动车事件-Xcy---***')
        return True
    except Exception as e:
        print e,'---***except***--- in Xcycle'
        return False


bigDist_delkeyList = ['aux_dev_info',"dev_unid",'event_refid','source_type',"subtask_id",
                    "task_id","task_type","vchan_refid","vdev_unid","thread_id","event_cate",'event_type'] #"event_cate"

app = flask.Flask(__name__)

# @app.before_first_request
# def first_request():



result_200 = {'code':200,'message':'success'}
result_400 = {'code':400,'message':'queue is full'}
result_401 = {'code':400,'message':'queue is empty'}

#do_url = 'http://' + '127.0.0.1' + ':' + service_port + '/do'

do_url = 'http://' + hostIP + ':' + service_port + '/do'

from requests import exceptions
def consumer_run(queue_type,queue_length):
    print('in consumer_run-----*******queue_length is %d' %queue_length)
    if queue_length > 0:
        print(do_url)
        #consumer_r = {}
        try:
            consumer_r = requests.post(do_url,data=json.dumps(queue_type),timeout=2)
        except  exceptions.ReadTimeout as e:
            print('consumer ------firs way failed,will until successful transmission')
        # if json.loads(consumer_r.content)['code'] == 200:
        #     print('consumer ------ sucess')
        # else:
        #     print('consumer ------ faild')
    else:
        print('in consumer_run-----******* %s is empty,not consumer' %queue_type)

def add_data_to_queue(queue,queue_maxsize,data):
    print('in add_data_to_queue -----queue size is :%r' % queue.qsize())
    if queue.qsize() >= queue_maxsize:
        print('in add_data_to_queue is full-----queue size is :%r' %queue.qsize())
        #print(json.dumps(result_400))
        return json.dumps(result_400)
    elif queue.qsize() < queue_maxsize:
        queue.put(data,block=False)
        print('in add_data_to_queue..... success')
        return json.dumps(result_200)



# 接收数据
@app.route('/api/v1/recv/events', methods=["POST"])
def recv_data():
    #headers = {'Content-Type':'application/json'}
    #global data_queue
    data = request.get_data()
    debug_writeFile(data,'yuan.txt')
    data = json.loads(data)

    if data['event_type'] == 'vehicle':
        if data['event_data']['illegal']['state'] == 0:
            print('----------recv vehicle data -----------')
            return_code = add_data_to_queue(trans_queue,new_data_queue_maxsize,data)
            consumer_run('trans_queue', trans_queue.qsize())
            return return_code
        if data['event_data']['illegal']['state'] == 1:
            print('--------recv illegal data ---------')
            return_code = add_data_to_queue(illegal_queue, new_data_queue_maxsize, data)
            consumer_run('illegal_queue',illegal_queue.qsize())
            return return_code
    elif data['event_type'] == 'tflow':
        print('-----------recv tflow data--------------')
        # try:
        #     print('in try-----')
        #     return add_data_to_queue(t_flow_queue,new_data_queue_maxsize,data)
        # except Exception as e:
        #     print(e,'----')
        # finally:
        #     print('in finally')
        #     consumer_run('t_flow_queue', t_flow_queue.qsize())
        return_code = add_data_to_queue(t_flow_queue, new_data_queue_maxsize, data)
        consumer_run('t_flow_queue', t_flow_queue.qsize())
        return return_code
    elif data['event_cate'] == 'behavior':
        print('---------recv behavior data---------')
        # if data['event_type'] == 'lajiduiji':
        #     print('***jishui***')
        #     debug_writeFile(data,'lajiduiji.txt')
        # if data['event_type'] == 'lajiyichu':
        #     print('***jishui***')
        #     debug_writeFile(data,'lajiyichu.txt')
        return_code = add_data_to_queue(event_queue,new_data_queue_maxsize,data)
        consumer_run('event_queue',event_queue.qsize())
        return return_code
    else:
        print('无效数据.......直接返回')
        #debug_writeFile(data,'wuxiao.txt')
        return json.dumps(result_200)



    # print('in recv data_queue is ------++++++:%r' %data_queue.qsize())
    # if data_queue.qsize() >= data_queue_maxsize:
    #     print('in recv elif data_queue is full-----data_queue is :%r' % data_queue.qsize())
    #     print(json.dumps(result_400))
    #     return json.dumps(result_400)
    # elif data_queue.qsize() < data_queue_maxsize:
    #     data_queue.put(data,block=False)
    #
    #     data_consumer = consumer()
    #     data_consumer.run(data_queue.qsize())
    #     return json.dumps(result_200)






#处理数据
@app.route('/do', methods=["POST"])
def process_data():
    json_2_dict = {}
    #tflow_send_code = {'code':200}
    global tflow_send_code
    global trans_send_code
    global illegal_send_code
    global event_send_code

    global illegal_queue
    print('in do ---------tflow_send_code is :%r**************************' %tflow_send_code)
    queue_type = json.loads(request.get_data())
    #print('data type is :%s type is %s' %(queue_type,type(queue_type)))
    #global data_queue
    if queue_type == 'trans_queue':
        print('in do----------trans_queue queue size is :%r' % trans_queue.qsize())
        if trans_queue.qsize() > 0 and trans_send_code['Code'] == 0:
            json_2_dict = trans_queue.get(block=False)
            #trans_send_code = {'code': 400}
            print('in do -------- Data retrieved from the queue successfully')
        else:
            print('trans is being sent.....dont continue to do')
    elif queue_type == "t_flow_queue":
        print('in do----------t_flow_queue queue size is :%r' % t_flow_queue.qsize())
        if t_flow_queue.qsize() > 0 and tflow_send_code['Code'] == 0:
            json_2_dict = t_flow_queue.get(block=False)
            # tflow_send_code = {'code':400}
            print('in do -------- Data retrieved from the queue successfully')
        else:
            print('tflow is being sent.....dont continue to do')
    elif queue_type == 'illegal_queue':
        print('in do----------illegal_queue queue size is :%r' % illegal_queue.qsize())
        if illegal_queue.qsize() > 0 and  illegal_send_code['Code'] == 0:
            json_2_dict = illegal_queue.get(block=False)
            # illegal_send_code = {'code': 400}
            print('in do -------- Data retrieved from the queue successfully')
        else:
            print('illegal data is being sent.....dont continue to do')
    elif queue_type == 'event_queue':
        print('-------')
        print('in do----------event_queue queue size is :%r' % event_queue.qsize())
        if event_queue.qsize() > 0 and event_send_code['Code'] == 0:
            json_2_dict = event_queue.get(block=False)
            # event_send_code = {'code': 400}
            print('in do -------- Data retrieved from the queue successfully')
        else:
            print('event data is being sent.....dont continue to do')

    if json_2_dict != {}:

        #print(type(data),data)
        #debug_writeFile(json_2_dict,'1111.txt')
        #json_2_dict = json.loads(data)

        if json_2_dict.has_key('video'):
            if json_2_dict['video'] != None:
                if json_2_dict['video'][0].has_key('unid'):
                    if (json_2_dict['video'][0]['unid']) > 0:
                        WFSPID = json_2_dict['video'][0].pop('unid')
                        WFSPID = WFSPID[:-3] + '-' + WFSPID[-3:]
                        json_2_dict['WFSPWJM'] = WFSPID + '.' + json_2_dict['video'][0].pop('format')

        if json_2_dict['event_cate'] == 'behavior':
            print('behavior-----')
            # event_code = 24
            SJLX = json_2_dict.pop('event_type')
            json_2_dict['SJLX'] = SJLX

        # debug_writeFile(json_2_dict, 'recv_sourceData_to_json.txt')
        if json_2_dict.has_key('event_data'):
            # event_data = json_2_dict['event_data']
            event_data = json_2_dict.pop('event_data')
            # debug_writeFile(event_data,'event_data_source.txt')
            if json_2_dict.has_key('WFSPWJM'):
                event_data['WFSPWJM'] = json_2_dict['WFSPWJM']

        # 统计起始时间
        if json_2_dict.has_key('event_dt'):
            event_data['TJSD'] = json_2_dict.pop('event_dt')
        # 设备编号
        if event_data.has_key('device'):
            event_data['SBBH'] = event_data['device'].pop('code')
            if len(event_data['SBBH']) < 18:
                print('SBBH', 'lenth less 18')
                event_data['SBBH'] = "123456789987654321"

        # 车道号
        if event_data.has_key('lane'):
            if event_data['lane'].has_key('number'):
                event_data['CDH'] = event_data['lane'].pop('number')
            # else:
            #     print('CDH-------is null---to 8')
            #     event_data['CDH'] = 8
            if event_data['CDH'] == 0:
                event_data['CDH'] = 1
            # event_data['CDH'] = event_data['lane'].pop('number')
        # 方向类型---交通流量方向类型封装的不一样，特别处理
        if event_data.has_key('location'):
            # event_data_dict['FXLX'] = event_data_dict.pop('direction')
            if event_data['location'].has_key('direction'):
                event_data['FXLX'] = event_data['location']['direction'].pop('code')
            del event_data['location']
            # else:
            #     event_data['FXLX'] = event_data['direction'].pop('code')
            #     del event_data['direction']
            #     #del event_data['location']

        is_send = False
        # print '************', '数据类型：',json_2_dict['event_type'], '***********'

        # 交通过车-违法-事件
        if json_2_dict.has_key('event_type'):
            if json_2_dict['event_type'] == 'vehicle':
                event_data['ZPSL'] = len(json_2_dict['pics'])
                event_data['pics'] = json_2_dict.pop('pics')

                # 卡口编号
                # event_data['KKBH'] = '1234567890'

                is_send = make_vehicle(event_data)
                # 将event_data字段合并到上一级
                # json_2_dict = dict(json_2_dict,**json_2_dict.pop(event_data))

                # 转换车辆品牌的code
                if event_data.has_key('CLPP'):
                    print('test---------',event_data['CLPP'])
                    event_data['CLPP'] = convert_code(event_data['CLPP'], wenan_code_huawei_code_CLPP)
                # 转换车身颜色-----已转换国标，不需要转换
                # if event_data.has_key('CSYS1'):
                #     event_data['CSYS1'] = convert_code(event_data['CSYS1'], wenan_code_huawei_code_CSYS)

                # 车辆类型转换code----国标
                if event_data.has_key('CLLX'):
                    event_data['CLLX'] = convert_code(event_data['CLLX'], wenan_code_huawei_code_CLLX)

                if event_data.has_key('CDLX'):
                    if isinstance(event_data['CDLX'], basestring):
                        event_data['CDLX'] = convert_code(event_data['CDLX'], wenan_code_huawei_code_CDLX)
                    else:
                        print("event_data['CDLX'] is not string type")
                        event_data['CDLX'] = convert_code(str(event_data['CDLX']), wenan_code_huawei_code_CDLX)

                if is_send:
                    if event_data.has_key('GCSJ'):
                        event_data['GCSJ'] = strtime_format_msec(event_data['GCSJ'])

                        # uuid
                        event_data['GCXH'] = tid_end_dt(event_data['GCSJ'])
                        # 采集方式---无
                        event_data['CJFX'] = '11'
                        print(event_data['HPHM'],'------------9999')
                        event_data = [event_data]
                        #print '交通过车数据........'
                        # print(json.dumps(event_data, ensure_ascii=False))
                        debug_writeFile(event_data,'guoche.log')

                        # if trans_queue.qsize() >= new_data_queue_maxsize:
                        #     print('trans_queue is full-----trans_queue is :%r' % trans_queue.qsize())
                        #     return 'trans_queue full'
                        # elif trans_queue.qsize() < new_data_queue_maxsize:
                        #     trans_queue.put(event_data, block=False)
                        #     print('trans_queue add elements')
                        #     return 'trans_queue add elements'

                        # 交通过车
                        if vehicle_url != "":
                            # try:
                            #     r = requests.post(url=vehicle_url, headers=headers, data=json.dumps(event_data))
                            #     print "send trans restult---------:", r.status_code
                            #     status_code = r.status_code
                            # except Exception as e:
                            #     status_code = 'unreachable'
                            #     print "send trans restult---------:unreachable"
                            trans_send_code = {'Code': 400}
                            print('发送交通过车.......')
                            trans_send_code = retry_send([vehicle_url,json.dumps(event_data,ensure_ascii=False),log_vehicle])
                            print('---------------------trans_send_code is :%r' % trans_send_code)
                            #log_vehicle.debug("send trans restult---------:%s" % status_code)
                    elif event_data.has_key('WFDM'):
                        # 采集方式---无
                        event_data['CJFX'] = '8'
                        # 交通违法
                        print '交通违法数据......'

                        WFKSSJ = event_data['WFKSSJ']
                        WFJSSJ = event_data['WFJSSJ']
                        CDH = event_data['CDH']
                        HPHM = event_data['HPHM']
                        SBBH = event_data['SBBH']
                        WFDM = event_data['WFDM']

                        event_data['WFKSSJ'] = strtime_format_nomsec(event_data['WFKSSJ'])
                        event_data['WFJSSJ'] = strtime_format_nomsec(event_data['WFJSSJ'])
                        event_data = [event_data]
                        # finally_send_data_list.append(event_data)
                        # print(json.dumps(event_data,ensure_ascii=False))
                        debug_writeFile(event_data, 'weifa.log')
                        if illegal_url != "":
                            illegal_send_code = {'Code': 400}
                            print('发送交通违法')
                            illegal_send_code = retry_send([illegal_url, json.dumps(event_data,ensure_ascii=False), log_illegal])
                            print('---------------------illegal_send_code is :%r' % illegal_send_code)

                        # if illegal_url != "":
                        #     # try:
                        #     #     r = requests.post(url=illegal_url, headers=headers, data=json.dumps(event_data))
                        #     #     print "send illegal restult---------:", r.status_code
                        #     #     status_code = r.status_code
                        #     # except Exception as e:
                        #     #     status_code = 'unreachable'
                        #     #     print "send illegal restult---------:unreachable"
                        #     retry_send([illegal_url,json.dumps(event_data),log_illegal])
                        #     # log_illegal.debug(
                        #     #     "WFKSSJ:%s------HPHM:%s******SBBH:%s------WFDM:%s------CDH:%d------status_code%r" % (
                        #     #     WFKSSJ, HPHM, SBBH, WFDM, CDH, status_code))

            elif json_2_dict['event_type'] == 'tflow':
                print('交通流量.....')
                # 将流量数据按车道复制多份
                # debug_writeFile(event_data,'make_befor.txt')
                t_flow_return = make_tflow(event_data)
                is_send = t_flow_return[0]
                tflow_data_list = t_flow_return[1]

                ##接口发送tflow数据
                if is_send:
                    # debug_writeFile(tflow_data_list, 'make_end.txt')
                    # event_data['TJSD'] = strtime_format_nomsec(event_data['TJSD'])
                    # debug_writeFile(tflow_data_list,'aaaabbb.txt')
                    for tflow in tflow_data_list:
                        if isinstance(tflow['CDLX'], basestring):
                            tflow['CDLX'] = convert_code(tflow['CDLX'], wenan_code_huawei_code_CDLX)
                        else:
                            print('road is not stringtype...')
                            tflow['CDLX'] = convert_code(str(tflow['CDLX']), wenan_code_huawei_code_CDLX)
                        tflow['CDH'] = int(tflow['CDH'])
                        tflow['PJPDCD'] = int(tflow['PJPDCD'])
                        tflow['PJSD'] = round(tflow['PJSD'], 1)
                        tflow['CDKJZYL'] = round(tflow['CDKJZYL'], 1)
                        tflow['PJCSJJ'] = round(tflow['PJCSJJ'], 1)
                        tflow["PJCTSJ"] = round(tflow["PJCTSJ"], 1)
                    debug_writeFile(tflow_data_list, 'tflow_data_list.txt')
                    # if t_flow_queue.qsize() >= new_data_queue_maxsize:
                    #     print('t_flow_queue is full-----t_flow_queue is :%r' % t_flow_queue.qsize())
                    #     return 't_flow_queue full'
                    # elif t_flow_queue.qsize() < new_data_queue_maxsize:
                    #     t_flow_queue.put(tflow_data_list, block=False)
                    #     print('t_flow_queue add elements')
                    #     return 't_flow_queue add elements'
                    if t_flow_url != "":

                        # try:
                        #     r = requests.post(url=t_flow_url, headers=headers,
                        #                       data=json.dumps(tflow_data_list, ensure_ascii=False))
                        #     print "send tflow restult---------:", r.status_code
                        #     status_code = r.status_code
                        # except Exception as e:
                        #     status_code = 'unreachable'
                        #     print "send t_flow restult---------:unreachable"
                        tflow_send_code = {'Code': 400}
                        print('发送交通流量')
                        tflow_send_code = retry_send([t_flow_url,json.dumps(tflow_data_list,ensure_ascii=False),log_flow])
                        print('---------------------tflow_send_code is :%r' %tflow_send_code)

                        #log_flow.debug("send tflow restult---------:%s" % status_code)
                # 重置空流量列表
                # tflow_data_list[:] = []
                # 将流量数据按车道复制多份
                # i = 1
                # for tflow_data in tflow_data_list:
                #     if tflow_data.has_key('location'):
                #         del tflow_data['location']
                #     event_data = tflow_data
                #     #转换成列表，一次发送多条
                #     #finally_send_data_list.append(tflow_data)
                #     # debug_writeFile(event_data,'tflow-event_data%d.txt' %i)
                #
                #
                #     ##接口发送tflow数据
                #     if is_send:
                #         debug_writeFile(event_data,'tflow_%d.log' %i)
                #         if t_flow_url != "":
                #             try:
                #                 r = requests.post(url=t_flow_url,headers=headers,data=json.dumps(event_data,ensure_ascii=False))
                #                 print "send tflow restult---------:",r.status_code
                #                 status_code = r.status_code
                #             except Exception as e:
                #                 status_code = 'unreachable'
                #                 print "send t_flow restult---------:unreachable"
                #     i = i + 1
            # 处理事件
        if json_2_dict.has_key('SJLX'):
            print('交通事件........')
            event_data['pics'] = json_2_dict.pop('pics')
            event_data['SJLX'] = json_2_dict['SJLX']
            # 转化事件类型为第三方code
            event_data['SJLX'] = convert_code(event_data['SJLX'], wenan_code_huawei_code_SJLX)
            debug_writeFile(event_data, 'event-data2.txt')
            if event_data.has_key('KSSPWJM'):
                event_data['KSSPWJM'] = event_data.pop('WFSPWJM')
            else:
                print('存在事件为开启短时录像....第三方数据中将没有短时录像字段，需要开启')
            if event_data.has_key("direction_id"):
                #event_data['FXLX'] = event_data.pop("direction_id")
                event_data['FXLX'] = event_data['direction'].pop('code')
                del event_data['direction']
            is_send = make_event_data(event_data)
            event_data = [event_data]
            debug_writeFile(event_data, 'event-data.txt')


            if is_send:
                if event_url != "":
                    # try:
                    #     r = requests.post(url=event_url, headers=headers, data=json.dumps(event_data))
                    #     print "send event restult---------:", r.status_code
                    #     status_code = r.status_code
                    # except Exception as e:
                    #     status_code = 'unreachable'
                    #     print "send event restult---------:unreachable"
                    event_send_code = {'Code': 400}
                    print('发送交通事件')
                    event_send_code = retry_send([event_url, json.dumps(event_data,ensure_ascii=False),log_event])
                    print('---------------------event_send_code is :%r' % event_send_code)
                    #log_event.debug("send event restult---------:%s" % status_code)

        print('is_send is---- :%s' % is_send)
        #time.sleep(100)
        # if is_send == True:
        #     print('is_send -------------------Ture')
        #     requests.post('http://192.168.88.189:20090/api/v1/tx1_box/test', json.dumps(json_2_dict))
        # print json_2_dict['event_data_dict']['driver']['face'][0]['state']
        print type(event_data), 'finally data type.......'
        return json.dumps({'message':'end','code':200})
    else:
        print('in do else-----data_queue:%r' %data_queue.qsize())
        return json.dumps({'message':'end','code':400})
    #headers = {'Content-Type':'application/json'}




# @app.route('/api/v1/recv/mac', methods=["GET"])
# def get_mac():
#     mac = request.remote_addr


##接收短时录像并上传
@app.route('/api/v1/web/videos/upload', methods=["POST"])
def uploadVideosByRefid():
    video = request.files['file']
    refid =request.form.get('refid')
    format = request.form.get('format')
    SBBH = request.form.get('location_id')
    # print ('refid=%s' % refid)
    # print ('format=%s' % format)
    # print ('video.name=%s' % video.filename)

    #filepath = os.path.join ( "static", "video", video.filename )  # 视频的路径:SBBH/FXLX/年月日
    video_path = video_dir + '/' + video.filename
    try:
        video.save(video_path)
        #print('save video path : %s' %video_path)
        #outVideosPathList = videoU.sav_videobyfile (video)
        # outVideosPath = outVideosPathList[0]
        # md5_code = outVideosPathList[1]
        # ftp上传
        # ftp = ftpconnect('192.168.9.62','ftpuser','yl')
        # ftp = ftpconnect('43.123.24.151', 'hw', '123456')
        ftp = ftpconnect(ftpServerIP, ftpUserName, ftpPassWord)
        if ftp:
            # ftp.mkd('sbbh')
            # ftp.cwd('sbbh')
            # ftp.mkd('ymd')
            # ftp.cwd('ymd')
            # print(ftp.pwd(),'0000000')
            # remote_storege_path = ftp.pwd() + '/' + 'test/test/testdir' ##ftp只能一次创建一个层目录
            ##SBBH/日期
            if len(SBBH) <= 0:
                SBBH = 'SBBH--weipeizhi'
            dt = datetime.datetime.now().strftime('%Y%m%d')

            # ftp.cwd('/home/uftp/testdir')

            # file_handle = open('testVideo.file',"rb")
            # ftp.storbinary("STOR %s" %(refid + format),file_handle,1024)
            # ftp.storlines('STOR %s' %video.filename,video)###文本文件方式视频文件ftp传输后播放有问题
            # ftp.close()
            refid = refid[:-3] + '-' + refid[-3:]

            upload_flag = uploadfile(ftp, video_path, SBBH, dt, refid, format)
            if upload_flag:
                result = {}
                #result.setdefault('refid', refid)
                result.setdefault('unid', video_path)
                result.setdefault('message','200 ')
                return json.dumps(result)
            else:
                result = {}
                # result.setdefault('refid', refid)
                result.setdefault('unid', video_path)
                result.setdefault('message', '400 ')
                return json.dumps(result)
        else:
            result = {}
            #result.setdefault('refid', refid)
            result.setdefault('unid', video_path)
            result.setdefault('message', '400 ')
            return json.dumps(result)
    except Exception as e:
        log_ftp.debug('upload videofile failed ------%s--%s--error:%s' %(refid,video.filename,e))
        result = {}
        #result.setdefault('refid', refid)
        result.setdefault('unid', video_path)
        result.setdefault('message', '400 ')
        return json.dumps(result)

@app.route('/recv_data', methods=["POST"])
def recv_data_log():
    print('recv_data---')
    log_recv_data.debug(json.loads(request.get_data()))
    return 'recv'


if __name__ == '__main__':
    tflow_send_code = {'Code':0}
    trans_send_code = {'Code':0}
    illegal_send_code = {'Code':0}
    event_send_code = {'Code':0}
    headers = {'Content-Type': 'application/json'}
    #event_data = {}
    #tflow_data_list = []
    log_vehicle = logger('data_info_vehicle.log')
    log_illegal = logger('data_info_illegal.log')
    log_event = logger('data_info_event.log')
    log_flow = logger('data_info_flow.log')
    log_recv_data = logger('recv_data.log')
    log_ftp = logger('data_info_ftp.log')
    video_dir = r'D:\ftp_video_test'
    #videoU = videoutil.VideoUtil(r'/data/www/uploadvideo')
    #video_dir = r'/data/www/uploadvideo'
    if os.path.exists(video_dir) == False:
        os.makedirs(video_dir)
    #print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(1514784806820))
    print time.strftime ( '%Y-%m-%d %H:%M:%S', time.localtime ( time.time () ) )
    timeStamp = 1514784806820
    #timeStamp = 1544498480153
    print (int ( round ( time.time() * 1000 ) ))  # 毫秒级时间戳
    #dateArray = datetime.datetime.utcfromtimestamp ( timeStamp )
    #print dateArray
    otherStyleTime = time.strftime ( "%Y-%m-%d %H:%M:%S", time.localtime(timeStamp/1000))
    print otherStyleTime

    data_queue_maxsize = 2
    data_queue = Queue(maxsize=data_queue_maxsize)

    new_data_queue_maxsize = 2
    trans_queue = Queue(maxsize=new_data_queue_maxsize)
    illegal_queue = Queue(maxsize=new_data_queue_maxsize)
    event_queue = Queue(maxsize=new_data_queue_maxsize)
    t_flow_queue = Queue(maxsize=new_data_queue_maxsize)

    app.run (
        host= hostIP,
        #host = '127.0.0.1',
        port = service_port,
        debug=False,threaded=True,use_reloader=False)