前往小程序,Get更优阅读体验!
立即前往
首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >高质量编码-轨迹管理平台(后台代码)

高质量编码-轨迹管理平台(后台代码)

原创
作者头像
MiaoGIS
修改2020-12-02 17:51:34
7720
修改2020-12-02 17:51:34
举报
文章被收录于专栏:Python in AI-IOT

轨迹管理平台实现了轨迹服务的管理,定位设备的管理,以位置轨迹的监控。后台是由Python实现的,Web服务由tornado框架开发,平台端实现对服务和设备的管理,设备终端也是通过调用api来实现定位信息的上传的。

代码截图说明如下:

初始化数据库和Redis。这里minTimeout表示同一设备要求距离上次上传特定时间间隔后才允许下一次上传,避免请求迸发,起到限流的作用。maxTimeout表示距离现在多久没有收到上传数据时判断为设备离线。

初始化Redis。从数据库中读取数据用来初始化Redis。hash_locators表示设备ID列表。updateForbidden_locator_X表示为每一个设备限制上传间隔。keepOnline_locator_X表示初始化所有设备为在线。recentCoordinate_locator_X表示设置每一个设备的最新定位数据(对于每一个设备从数据库历史定位表中查找最近的定位数据)。

平台API路由映射如下:

对于用户,轨迹服务,定位设备的管理,后台都提供了增删改查接口,比如对于轨迹服务(fleed表示车队的意思)

对于设备终端的新增和删除都要同时在Redis中更新其信息。

定位数据上传时会自带时间戳,这里方便演示在收到数据时以系统时间为时间戳。收到数据时更新Redis中最新定位数据。

轨迹管理平台主要有实时位置和轨迹查询的功能。

实时位置接口根据服务ID从Redis中获取其所有定位设备的最新数据。

查询某时间范围内有轨迹数据的设备,显示在历史轨迹设备列表中。

轨迹查询接口根据设备ID,时间范围从数据库中获取其历史轨迹数据。在历史轨迹设备列表勾选某设备时从后台查询。

代码如下:

代码语言:python
代码运行次数:0
复制
import tornado.web
import tornado.ioloop
import tornado.httpserver
from tornado.options import define,options
import redis
from gpsMonitor_Model import *
import redis
from datetime import datetime,timedelta
import os
import sqlite3
import json
from collections import namedtuple
define('port',default=8090,help='run on the given port',type=int)

Locator=namedtuple('Locator',['id','name','stops'])
LocatorCoordinate=namedtuple('LocatorCoordinate',['coordinate_x','coordinate_y','coordinate_time'])
class Application(tornado.web.Application):
    def __init__(self):
        handlers=[
            (r'/',IndexHandler),
            (r'/index',IndexHandler),
            (r'/user',userHandler),
                
            (r'/fleed',fleedHandler),
            (r'/locator',locatorHandler),
            (r'/coordinate',coordinateHandler),
            (r'/fleed/fleedsByUser',fleedsByUserHandler),
            (r'/locator/locatorsByFleed',locatorsByFleedHandler),
            (r'/coordinate/coordinatesByLocator',coordinatesByLocatorHandler),
            (r'/coordinate/coordinatesByLocatorAndTime',coordinatesByLocatorAndTimeHandler),
            (r'/coordinate/coordinatesByTime',coordinatesByTimeHandler),
            (r'/coordinate/coordinatesByTime2GroupByLocator',coordinatesByTime2GroupByLocatorHandler),
            (r'/locator/locatorsWithCoordinateByFleed',locatorsWithCoordinateByFleedHandler)
             ]
         
        settings=dict(
            template_path=os.path.join(os.path.curdir,'templates'),
            static_path=os.path.join(os.path.curdir,'static'),
            cookie_secret='miaojiyao',
            debug=True
            )
        tornado.web.Application.__init__(self,handlers,**settings)
class IndexHandler(tornado.web.RequestHandler):
        
    def get(self):
        
        self.render('trackMap.html')
class userHandler(tornado.web.RequestHandler):
     
    def post(self):
        user_id=self.get_argument('itemId')
        user_name=self.get_argument('user_name')
        user=User.get(user_id)
        user.user_name=user_name
        self.write('post:')
         
        self.write(repr(user))
        
        
    def get(self):
        user_id=self.get_argument('itemId')
        user=User.get(user_id)
        self.write('get:')
        self.write(repr(user))
    def put(self):
        user_name=self.get_argument('user_name')
        user=User(user_name=user_name)
        self.write('put:')
        self.write(repr(user))
    
    def delete(self):
        user_id=self.get_argument('itemId')
        user=User.get(user_id)
        User.delete(user_id)
        self.write('delete:')
        self.write(repr(user))
class fleedHandler(tornado.web.RequestHandler):
    def post(self):
        user=User.get(34)
        fleed_id=self.get_argument('itemId')
        fleed_name=self.get_argument('fleed_name')
        fleed=Fleed.get(fleed_id)
        fleed.fleed_name=fleed_name
        fleed.fleed_user=user 
        self.write('post:')
        self.write(repr(fleed))    
    def get(self):
        fleed_id=self.get_argument('itemId')
        fleed=Fleed.get(fleed_id)
        self.write('get:')
        self.write(repr(fleed))
    def put(self):
        user=User.get(33)
        fleed_name=self.get_argument('fleed_name')
        fleed=Fleed(fleed_name=fleed_name,fleed_user=user)
        self.write('put:')
        self.write(repr(fleed))
    def delete(self):
        fleed_id=self.get_argument('itemId')
        fleed=Fleed.get(fleed_id)
        Fleed.delete(fleed_id)
        self.write('delete:')
        self.write(repr(fleed))
class fleedsByUserHandler(tornado.web.RequestHandler):
    
    def get(self):
        user_id=self.get_argument('fleed_user')
        user=User.get(user_id)
        fleeds=Fleed.select(Fleed.q.fleed_userID==user.id)
        fleeds=map(lambda x: { 'fleed_name':x.fleed_name, 'fleed_id':x.id, 'fleed_userID':x.fleed_userID},fleeds)
        #self.write('getFleedsByUser:')
        self.write({'result':fleeds})
class locatorHandler(tornado.web.RequestHandler):
     
    def post(self):
        fleed=Fleed.get(self.get_argument('locator_fleed'))
        locator_id=self.get_argument('itemId')
        locator_name=self.get_argument('locator_name')
        locator=Locator.get(locator_id)
        locator.locator_name=locator_name
        locator.locator_fleed=fleed
        self.write('post:')
        self.write(repr(locator))
        
    def get(self):
        locator_id=self.get_argument('itemId')
        locator=Locator.get(locator_id)
        self.write('get:')
        
        self.write(repr(locator))
    def put(self):
        fleed=Fleed.get(self.get_argument('locator_fleed'))
        locator_name=self.get_argument('locator_name')
        locator=Locator(locator_name=locator_name,locator_fleed=fleed)

        myRedis.hset('hash_locators',str(locator.id),str(locator.id))
        myRedis.setex('updateForbidden_locator_'+str(locator.id),str(locator.id),minTimeout)
        myRedis.setex('keepOnline_locator_'+str(locator.id),str(locator.id),maxTimeout)
        
        
        locatorCoordinates= Coordinate.select(Coordinate.q.coordinate_locatorID==locator.id,orderBy=Coordinate.q.coordinate_time)
        if locatorCoordinates.count()>0:
            
            myRedis.set('recentCoordinate_locator_'+str(locator.id),
                        '|'.join([str(locatorCoordinates[-1].coordinate_x),
                                  str(locatorCoordinates[-1].coordinate_y),
                                  datetime.strftime(locatorCoordinates[-1].coordinate_time,'%Y-%m-%d %H:%M:%S')]))
        else:
            myRedis.set('recentCoordinate_locator_'+str(locator.id),
                        '|'.join([str(defaultCoordinate_x),
                                  str(defaultCoordinate_y),
                                  datetime.strftime(defaultCoordinate_time,'%Y-%m-%d %H:%M:%S')]))

        
        self.write('put:')
        self.write(repr(locator))
    def delete(self):
        locator_id=self.get_argument('itemId')
        locator=Locator.get(locator_id)
        Locator.delete(locator_id)
       
        myRedis.hdel('hash_locators',str(locator.id))

        
        myRedis.delete('updateForbidden_locator_'+str(locator.id))
        myRedis.delete('keepOnline_locator_'+str(locator.id))
        
	
        myRedis.delete('recentCoordinate_locator_'+str(locator.id))

        
        self.write('delete:')
        self.write(repr(locator))
class locatorsByFleedHandler(tornado.web.RequestHandler):
    
    def get(self):
        fleed_id=self.get_argument('locator_fleed')
        fleed=Fleed.get(fleed_id)
        locators=Locator.select(Locator.q.locator_fleedID==fleed.id)
        locators=map(lambda x: { 'locator_id':x.id, 'locator_name':x.locator_name, 'locator_fleedID':x.locator_fleedID},locators)
        #self.write('getLocatorsByFleed:')
        self.write({'result':locators})

class coordinatesByTime2GroupByLocatorHandler(tornado.web.RequestHandler):
    def get(self):
        fleed_id=self.get_argument('fleed_id')
        startTime=self.get_argument('startTime')
        endTime=self.get_argument('endTime')
        startTime=datetime.strptime(startTime,'%Y-%m-%d %H:%M:%S')
        endTime=datetime.strptime(endTime,'%Y-%m-%d %H:%M:%S')
        con=sqlite3.connect('../../GPS_DB.db')
        cursor=con.cursor()
        
        locatorsByCoordinate=cursor.execute('select * from coordinate where coordinate_time>(?) \
                                            and coordinate_time<(?) group by coordinate_locator_id',(startTime,endTime))
   
        locatorsByFleed=Locator.select(Locator.q.locator_fleed==int(fleed_id))
        
        locator_ids=map(lambda x:x[4],locatorsByCoordinate)
        locators=filter(lambda x:locator_ids.count(x.id)>0,locatorsByFleed)
        locators=map(lambda x: { 'locator_id':x.id, 'locator_name':x.locator_name, 'locator_fleedID':x.locator_fleedID},locators)
        cursor.close()
        con.close()
       
        #locators=map(lambda x: { 'locator_id':x['name'], 'locator_name':x['name'], 'locator_fleedID':fleed_id},lines[0:25])
        self.write({'result':locators})
        
     
    
class locatorsWithCoordinateByFleedHandler(tornado.web.RequestHandler):
    
    def get(self):
        fleed_id=self.get_argument('locator_fleed')
        fleed=Fleed.get(fleed_id)
        locators=Locator.select(Locator.q.locator_fleedID==fleed.id)
        locators=map(lambda x: { 'locator_id':x.id, 'locator_name':x.locator_name, 'locator_fleedID':x.locator_fleedID},locators)
        
        #locators=map(lambda x: { 'locator_id':x['name'], 'locator_name':x['name'], 'locator_fleedID':fleed_id},lines)
        for locator in locators:
            
            locator['locator_status']='on' if myRedis.get('keepOnline_locator_'+str(locator.get('locator_id'))) else 'off'

            locator['locator_coordinate_x'],locator['locator_coordinate_y'],locator['locator_coordinate_time']=\
            myRedis.get('recentCoordinate_locator_'+str(locator.get('locator_id'))).split('|')
        #hashLocators=myRedis.hgetall('hash_locators')
        #filter(lambda x:hashLocators.get(str(x.get('locator_id',-90))) ,locators)
        #self.write('getLocatorsByFleed:')
        self.write({'result':locators})
class coordinateHandler(tornado.web.RequestHandler):
     
    def post(self):
        locator_id=self.get_argument('coordinate_locator')
        locator=Locator.get(locator_id)
        coordinate_id=self.get_argument('itemId') 
        coordinate_x=self.get_argument('coordinate_x')
        coordinate_y=self.get_argument('coordinate_y')
        coordinate_x=float(coordinate_x.encode('utf-8'))
        
        
        coordinate_y=float(coordinate_y.encode('utf-8'))
        coordinate_time=datetime.strptime('2010-10-09 10:00:20','%Y-%m-%d %H:%M:%S')
        
        coordinate=Coordinate.get(coordinate_id)
        coordinate.coordinate_x=coordinate_x
        coordinate.coordinate_y=coordinate_y
        coordinate.coordinate_time=coordinate_time
        coordinate.coordinate_locator=locator
        self.write('post:')
        self.write(repr(coordinate))
        
    def get(self):
        coordinate_id=self.get_argument('itemId')
        coordinate=Coordinate.get(coordinate_id)
        self.write('get:')
        self.write(repr(coordinate))
    def put(self):
        locator_id=self.get_argument('coordinate_locator')
        locator=Locator.get(locator_id)
        coordinate_x=self.get_argument('coordinate_x')
        coordinate_x=float(coordinate_x.encode('utf-8'))
        
        coordinate_y=self.get_argument('coordinate_y')
        coordinate_y=float(coordinate_y.encode('utf-8'))
        #coordinate_time=self.get_argument('coordinate_time')
        #coordinate_time=datetime.strptime(coordinate_time,'%Y-%m-%d %H:%M:%S')
        coordinate_time=datetime.now()
        if not myRedis.get('updateForbidden_locator_'+str(locator.id)):
            
            coordinate=Coordinate(coordinate_x=coordinate_x,coordinate_y=coordinate_y,coordinate_time=coordinate_time,coordinate_locator=locator)
            self.write('put:')
            
            myRedis.setex('updateForbidden_locator_'+str(locator.id),str(locator.id),minTimeout)
            myRedis.setex('keepOnline_locator_'+str(locator.id),str(locator.id),maxTimeout)
            myRedis.set('recentCoordinate_locator_'+str(locator.id),
                        '|'.join([str(coordinate_x),
                                  str(coordinate_y),
                                  datetime.strftime(coordinate_time,'%Y-%m-%d %H:%M:%S')]))
            self.write(repr(coordinate))
        else:
            self.write('not allow submit too often!')
    def delete(self):
        coordinate_id=self.get_argument('itemId')
        coordinate=Coordinate.get(coordinate_id)
        Coordinate.delete(coordinate_id)
        self.write('delete:')
        self.write(repr(coordinate))
        
class coordinatesByLocatorHandler(tornado.web.RequestHandler):
    
    def get(self):
        locator_id=self.get_argument('coordinate_locator')
        locator=Locator.get(locator_id)
        coordinates=Coordinate.select(Coordinate.q.coordinate_locatorID==locator.id)
        coordinates=map(lambda x: { 'coordinate_x':x.coordinate_x, 'coordinate_y':x.coordinate_y, 'coordinate_time':datetime.strftime(x.coordinate_time,'%Y-%m-%d %H:%M:%S'),'coordinate_locatorID':x.coordinate_locatorID},coordinates)
        #self.write('getCoordinatesByLocator:')
        self.write({'result':coordinates})
class coordinatesByTimeHandler(tornado.web.RequestHandler):
    
    def get(self):
        coordinate_time_start=self.get_argument('coordinate_time_start',datetime.strftime(datetime.now()-timedelta(1),'%Y-%m-%d %H:%M:%S'))
        coordinate_time_end=self.get_argument('coordinate_time_end',datetime.strftime(datetime.strptime(coordinate_time_start,'%Y-%m-%d %H:%M:%S')+timedelta(1),'%Y-%m-%d %H:%M:%S'))
        coordinate_time_start=datetime.strptime(coordinate_time_start,'%Y-%m-%d %H:%M:%S')
        coordinate_time_end=datetime.strptime(coordinate_time_end,'%Y-%m-%d %H:%M:%S')
         
        coordinates=Coordinate.select((Coordinate.q.coordinate_time>coordinate_time_start) & (Coordinate.q.coordinate_time<coordinate_time_end))
        coordinates=map(lambda x: { 'coordinate_x':x.coordinate_x, 'coordinate_y':x.coordinate_y, 'coordinate_time':datetime.strftime(x.coordinate_time,'%Y-%m-%d %H:%M:%S'),'coordinate_locatorID':x.coordinate_locatorID},coordinates)
        #self.write('getcoordinatesByTime:')
        self.write({'result':coordinates})
class coordinatesByLocatorAndTimeHandler(tornado.web.RequestHandler):
    
    def get(self):
        locator_id=self.get_argument('coordinate_locator')
        locator=Locator.get(locator_id)
        coordinate_time_start=self.get_argument('coordinate_time_start',datetime.strftime(datetime.now()-timedelta(1),'%Y-%m-%d %H:%M:%S'))
        coordinate_time_end=self.get_argument('coordinate_time_end',datetime.strftime(datetime.strptime(coordinate_time_start,'%Y-%m-%d %H:%M:%S')+timedelta(1),'%Y-%m-%d %H:%M:%S'))
        coordinate_time_start=datetime.strptime(coordinate_time_start,'%Y-%m-%d %H:%M:%S')
        coordinate_time_end=datetime.strptime(coordinate_time_end,'%Y-%m-%d %H:%M:%S')
        coordinates=Coordinate.select((Coordinate.q.coordinate_locatorID==locator.id) & (Coordinate.q.coordinate_time>coordinate_time_start) & (Coordinate.q.coordinate_time<coordinate_time_end))
        coordinates=map(lambda x: { 'coordinate_x':x.coordinate_x, 'coordinate_y':x.coordinate_y, 'coordinate_time':datetime.strftime(x.coordinate_time,'%Y-%m-%d %H:%M:%S'),'coordinate_locatorID':x.coordinate_locatorID},coordinates)

        #myLines=filter(lambda x:str(x['name'])==str(locator_id),lines)
 
        #if len(myLines)==0:
            #self.write({'result':[]}) 
        #myLine=myLines[0]
         
        #coordinates=map(lambda x: { 'coordinate_x':x['lat'], 'coordinate_y':x['lng'],
        #                            'coordinate_time':datetime.strftime(x['time'],'%Y-%m-%d %H:%M:%S'),
        #                            'coordinate_locatorID':locator_id},myLine['stops'])
        
        #self.write('getcoordinatesByLocatorAndTime:')
        self.write({'result':coordinates})
def initRedis():
    locators=Locator.select()
    #locators=map(lambda x: Locator(x['name'],x['name'],x['stops']),lines)
    for locator in locators:
        
        myRedis.hset('hash_locators',str(locator.id),str(locator.id))
        myRedis.setex('updateForbidden_locator_'+str(locator.id),str(locator.id),minTimeout)
        myRedis.setex('keepOnline_locator_'+str(locator.id),str(locator.id),maxTimeout)
        
        locatorCoordinates= Coordinate.select(Coordinate.q.coordinate_locatorID==locator.id,
                                              orderBy=Coordinate.q.coordinate_time)
        #locatorCoordinates=map(lambda x:LocatorCoordinate(x['lat'],x['lng'],x['time']),locator.stops)
        if locatorCoordinates.count()>0:
        #if len(locatorCoordinates)>0:
            myRedis.set('recentCoordinate_locator_'+str(locator.id),
                        '|'.join([str(locatorCoordinates[0].coordinate_x),
                                  str(locatorCoordinates[0].coordinate_y),
                                  datetime.strftime(locatorCoordinates[0].coordinate_time,'%Y-%m-%d %H:%M:%S')]))
                                  
        else:
            myRedis.set('recentCoordinate_locator_'+str(locator.id),
                        '|'.join([str(defaultCoordinate_x),
                                  str(defaultCoordinate_y),
                                  datetime.strftime(defaultCoordinate_time,'%Y-%m-%d %H:%M:%S')]))
#测试数据
def initTest():
    f=open('./lines12.js','rb')
    global lines
    lines=json.load(f)[0:50]
    f.close()
    for line in lines:
        
        for i in range(len(line['stops'])):
            line['stops'][i]['time']=(defaultCoordinate_time-i*timedelta(0,defaultInterval))
            
		
if __name__=='__main__':
    print 'start server'
    myRedis=redis.Redis()
    minTimeout=60
    maxTimeout=60*5
    defaultInterval=300
    defaultCoordinate_x=34.730861
    defaultCoordinate_y=113.6101392
    defaultCoordinate_time=datetime.now()
    #initTest()
    initDatabase()
    initRedis()
    
    tornado.options.parse_command_line()
    http_server=tornado.httpserver.HTTPServer(Application())
    http_server.listen(options.port)
    tornado.ioloop.IOLoop.instance().start()
        
    

原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。

如有侵权,请联系 cloudcommunity@tencent.com 删除。

原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。

如有侵权,请联系 cloudcommunity@tencent.com 删除。

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
相关产品与服务
云数据库 Redis
腾讯云数据库 Redis(TencentDB for Redis)是腾讯云打造的兼容 Redis 协议的缓存和存储服务。丰富的数据结构能帮助您完成不同类型的业务场景开发。支持主从热备,提供自动容灾切换、数据备份、故障迁移、实例监控、在线扩容、数据回档等全套的数据库服务。
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档