1

.gitignore

@@ -0,0 +1,3 @@
+/.idea
+/static
+/Model/migrations

Ansjer/config.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3  
+# -*- coding: utf-8 -*-  
+"""
+@Copyright (C) ansjer cop Video Technology Co.,Ltd.All rights reserved.
+@AUTHOR: ASJRD018
+@NAME: Ansjer
+@software: PyCharm
+@DATE: 2018/7/2 14:06
+@Version: python3.6
+@MODIFY DECORD:ansjer dev
+@file: Conf.py
+@Contact: chanjunkai@163.com
+"""
+#主要静态变量配置文件
+import os
+import datetime
+from var_dump import var_dump
+
+# 根目录
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+# 发送邮件邮箱
+COMPANY_EMAIL = 'user_server@nsst.com'
+# token加密令牌,过期时间，刷新过期时间
+SECRET_KEY = 'c7ki2_gkg4#sjfm-u1%$s#&n#szf01f*v69rwv2qsf#-zmm@tl',
+EXPIRATION_DELTA = datetime.timedelta(days=7)
+REFRESH_EXPIRATION_DELTA = datetime.timedelta(days=7)
+STATIC_URL = '/static/'
+
+# 服务器类型
+SERVER_TYPE = 'local'
+# SERVER_TYPE = 'test'
+# SERVER_TYPE = 'formal'
+if SERVER_TYPE == 'local':
+    NGINX_RTMP_STAT = 'http://192.168.136.45:8077/stat'
+    SERVER_DOMAIN = 'http://192.168.136.45:8077'
+    DATABASE_DATA = 'Ansjer'
+    SERVER_HOST = '192.168.136.45'
+    RTMP_PUSH_URL = 'rtmp://192.168.136.45:1935/hls'
+
+elif SERVER_TYPE == 'test':
+    NGINX_RTMP_STAT = 'http://13.56.215.252:82/stat'
+    SERVER_DOMAIN = 'http://13.56.215.252:82'
+    DATABASE_DATA = 'AnsjerTest'
+    SERVER_HOST = 'localhost'
+    RTMP_PUSH_URL = 'http://13.56.215.252:8091/hls'
+elif SERVER_TYPE == 'formal':
+    NGINX_RTMP_STAT = 'http://13.56.215.252:81/stat'
+    SERVER_DOMAIN = 'http://13.56.215.252:81'
+    DATABASE_DATA = 'Ansjer81'
+    SERVER_HOST = 'localhost'
+    RTMP_PUSH_URL = 'http://13.56.215.252:8091/hls'
+#数据库
+DATABASES_DEFAULT={
+    'ENGINE': 'django.db.backends.mysql',
+    'NAME': DATABASE_DATA,
+    'USER': 'ansjer',
+    'PASSWORD': '1234',
+    'HOST': SERVER_HOST,
+    'PORT': '3306',
+    'OPTIONS': {'charset': 'utf8mb4', 'use_unicode': True},
+}
+
+AWS_ACCESS_ID = 'AKIAJKPU23EU5QWHFPKQ'
+AWS_ACCESS_SECRET = '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'
+AWS_ACCESS_REGION = 'us-east-1'
+AWS_BUCKET = 'ansjertest'
+

Ansjer/file/log type .txt

@@ -0,0 +1,184 @@
+typedef enum _log_type
+{
+	//系统控制(Control)
+	LOG_TYPE_SYSTEM_CTRL		= 0x00010000,
+	LOG_TYPE_BOOT,							//系统开机
+	LOG_TYPE_SHUTDOWN,						//系统关机
+	LOG_TYPE_REBOOT,						//系统重启
+	LOG_TYPE_FORMAT_SUCC,					//格式化磁盘成功
+	LOG_TYPE_FORMAT_FAIL,					//格式化磁盘失败
+	LOG_TYPE_UPGRADE_SUCC,					//升级成功
+	LOG_TYPE_UPGRADE_FAIL,					//升级失败
+	LOG_TYPE_CLEAR_ALARM,					//清除报警
+	LOG_TYPE_OPEN_ALARM,					//开启报警
+	LOG_TYPE_MANUAL_START,					//开启手动录像
+	LOG_TYPE_MANUAL_STOP,					//停止手动录像
+	LOG_TYPE_PTZ_ENTER,						//开始云台控制
+	LOG_TYPE_PTZ_CTRL,						//云台操作
+	LOG_TYPE_PTZ_EXIT,						//结束云台控制
+	LOG_TYPE_AUDIO_CH_CHANGE,				//改变现场音频通道
+	LOG_TYPE_VOLUME_ADJUST,					//调节音量
+	LOG_TYPE_MUTE_ENABLE,					//开启静音
+	LOG_TYPE_MUTE_DISENABLE,				//关闭静音
+	LOG_TYPE_DWELL_ENABLE,					//开启轮循
+	LOG_TYPE_DWELL_DISENABLE,				//关闭轮循
+	LOG_TYPE_LOG_IN,						//登录
+	LOG_TYPE_LOG_OFF,						//登出
+	LOG_TYPE_CHANGE_TIME,					//修改系统时间
+	LOG_TYPE_MANUAL_SNAP_SUCC,               //手动抓图成功
+	LOG_TYPE_MANUAL_SNAP_FAIL,               //手动抓图失败
+
+	//系统配置(Setup)
+	LOG_TYPE_CONFIG			= 0x00020000,
+	LOG_TYPE_CHGE_VIDEO_FORMAT,				//改变视频制式
+	LOG_TYPE_CHGE_VGA_RESOLUTION,			//改变显示器分辨率
+	LOG_TYPE_CHGE_LANGUAGE,					//调整语言
+	LOG_TYPE_CHGE_NET_USER_NUM,				//调整网络用户数目
+	LOG_TYPE_CHGE_TIME_ZONE,				//调整时区
+	LOG_TYPE_NTP_MANUAL,					//手动网络校时
+	LOG_TYPE_NTP_ON,						//开启自动网络校时
+	LOG_TYPE_NTP_OFF,						//关闭自动网络校时
+	LOG_TYPE_CHGE_NTP_SERVER,				//修改网络时间服务器地址
+	LOG_TYPE_CHGE_DST,						//调整夏令时设置
+	LOG_TYPE_PASSWD_ON,						//开启操作密码
+	LOG_TYPE_PASSWD_OFF,					//关闭操作密码
+
+	LOG_TYPE_CHGE_CAM_NAME,					//调整通道名称
+	LOG_TYPE_MODIFY_COLOR,					//调整图像色彩
+	LOG_TYPE_CHGE_HOST_MONITOR,				//调整主监视器画面设置
+	LOG_TYPE_CHGE_SPOT,						//调整辅助输出画面设置
+	LOG_TYPE_CHGE_OSD,						//调整字符叠加设置
+
+	LOG_TYPE_CHGE_LOCAL_ENCODE,				//调整录像流编码参数
+	LOG_TYPE_CHGE_REC_VIDEO_SWITCH,			//调整录像开关设置
+	LOG_TYPE_CHGE_REC_AUDIO_SWITCH,			//调整录制音频开关设置
+	LOG_TYPE_CHGE_REC_REDU_SWITCH,			//调整冗余录像开关设置
+	LOG_TYPE_CHGE_REC_PRE_TIME,				//调整景前录像时间
+	LOG_TYPE_CHGE_REC_POST_TIME,			//调整景后录像时间
+	LOG_TYPE_CHGE_REC_HOLD_TIME,			//调整录像数据过期时间
+
+	LOG_TYPE_CHGE_SCH_SCHEDULE,				//调整定时录像计划
+	LOG_TYPE_CHGE_SCH_MOTION,				//调整移动侦测录像计划
+	LOG_TYPE_CHGE_SCH_ALARM,				//调整报警录像计划
+
+	LOG_TYPE_CHGE_SENSOR_SWITCH,			//调整报警输入开关设置
+	LOG_TYPE_CHGE_SENSOR_TYPE,				//调整报警输入设备类型
+	LOG_TYPE_CHGE_SENSOR_TRIGGER,			//调整报警输入处理方式设置
+	LOG_TYPE_CHGE_SENSOR_SCH,				//调整报警输入侦测计划
+
+	LOG_TYPE_CHGE_MOTION_SWITCH,			//调整移动侦测开关设置
+	LOG_TYPE_CHGE_MOTION_SENS,				//调整移动侦测灵敏度
+	LOG_TYPE_CHGE_MOTION_AREA,				//调整移动侦测区域设置
+	LOG_TYPE_CHGE_MOTION_TRIGGER,			//调整移动侦测处理方式
+	LOG_TYPE_CHGE_MOTION_SCH,				//调整移动侦测计划
+
+	LOG_TYPE_CHGE_VL_TRIGGER,				//调整视频丢失处理方式设置
+
+	LOG_TYPE_CHGE_RELAY_SWITCH,				//调整报警输出开关设置
+	LOG_TYPE_CHGE_RELAY_SCH,				//调整报警输出计划
+
+	LOG_TYPE_BUZZER_ON,						//开启声音报警设备
+	LOG_TYPE_BUZZER_OFF,					//关闭声音报警设备
+	LOG_TYPE_CHGE_BUZZER_SCH,				//调整声音报警计划
+
+	LOG_TYPE_CHGE_HTTP_PORT,				//修改HTTP服务器端口
+	LOG_TYPE_CHGE_SER_PORT,					//修改网络服务器端口
+	LOG_TYPE_CHGE_IP,						//设置网络地址
+	LOG_TYPE_DHCP_SUCC,						//自动获取网络地址成功
+	LOG_TYPE_DHCP_FAIL,						//自动获取网络地址失败
+	LOG_TYPE_CHGE_PPPOE,					//设置PPPoE
+	LOG_TYPE_CHGE_DDNS,						//设置DDNS
+	LOG_TYPE_NET_STREAM_CFG,				//调整网络流编码设置
+
+	LOG_TYPE_CHGE_SERIAL,					//调整云台串口设置
+	LOG_TYPE_PRESET_MODIFY,					//调整预置点
+	LOG_TYPE_CRUISE_MODIFY,					//调整巡航线
+	LOG_TYPE_TRACK_MODIFY,					//调整轨迹
+
+	LOG_TYPE_USER_ADD,						//增加用户
+	LOG_TYPE_USER_MODIFY,					//调整用户权限
+	LOG_TYPE_USER_DELETE,					//删除用户
+	LOG_TYPE_CHANGE_PASSWD,					//修改用户密码
+
+	LOG_TYPE_LOAD_DEFAULT,					//恢复默认配置
+	LOG_TYPE_IMPORT_CONFIG,					//导入配置
+	LOG_TYPE_EXPORT_CONFIG,					//导出配置
+
+	LOG_TYPE_CHGE_IMAGE_MASK,				//图像遮挡
+	LOG_TYPE_RECYCLE_REC_ON,				//开启循环录像
+	LOG_TYPE_RECYCLE_REC_OFF,				//关闭循环录像
+	LOG_TYPE_CHGE_DISK_ALARM,				//调整磁盘报警空间
+
+	LOG_TYPE_CHGE_SEND_EMAIL,				//设置Email 发送人信息
+	LOG_TYPE_CHGE_RECV_EMAIL,				//设置Email 接收人信息
+	LOG_TYPE_CHGE_SNAP_SETTING,             //调整抓图配置
+
+	//yqf add 2017.12.22
+	LOG_TYPE_CHGE_SCH_PIR,					//调整人体红外感应录像计划
+	LOG_TYPE_CHGE_PIR_SWITCH,				//调整人体红外感应开关设置
+	LOG_TYPE_CHGE_PIR_TRIGGER,				//调整人体红外感应处理方式
+	LOG_TYPE_CHGE_PIR_SCH,					//调整人体红外感应计划
+
+	//录像回放(Playback)
+	LOG_TYPE_PLAYBACK		= 0x00040000,
+	LOG_TYPE_PLAYBACK_PLAY,					//播放
+	LOG_TYPE_PLAYBACK_PAUSE,				//暂停
+	LOG_TYPE_PLAYBACK_RESUME,				//恢复播放
+	LOG_TYPE_PLAYBACK_FF,					//快进
+	LOG_TYPE_PLAYBACK_REW,					//快退
+	LOG_TYPE_PLAYBACK_STOP,					//停止
+	LOG_TYPE_PLAYBACK_NEXT_SECTION,			//下一段
+	LOG_TYPE_PLAYBACK_PREV_SECTION,			//上一段
+
+	//数据备份(Backup)
+	LOG_TYPE_BACKUP			= 0x00080000,
+	LOG_TYPE_BACKUP_START,					//开始备份
+	LOG_TYPE_BACKUP_COMPLETE,				//备份完成
+	LOG_TYPE_BACKUP_CANCEL,					//放弃备份
+	LOG_TYPE_BACKUP_FAIL,					//备份失败
+
+	//录像检索(Search)
+	LOG_TYPE_SEARCH			= 0x00100000,
+	LOG_TYPE_SEARCH_TIME,					//按时间检索
+	LOG_TYPE_SEARCH_EVENT,					//按事件检索
+	LOG_TYPE_SEARCH_FILE_MAN,				//文件管理
+	LOG_TYPE_DELETE_FILE,					//删除文件
+	LOG_TYPE_LOCK_FILE,						//锁定文件
+	LOG_TYPE_UNLOCK_FILE,					//解锁文件
+	LOG_TYPE_DELETE_PICTURE,                //删除图片
+	LOG_TYPE_LOCK_PICTURE,                  //锁定图片
+	LOG_TYPE_UNLOCK_PICTURE,                //解锁图片
+
+
+	//查看信息(View information)
+	LOG_TYPE_VIEW_INFO		= 0x00200000,
+	LOG_TYPE_VIEW_SYSTEM,					//查看系统信息
+	LOG_TYPE_VIEW_EVENT,					//查看事件
+	LOG_TYPE_VIEW_LOG,						//查看日志
+	LOG_TYPE_VIEW_NETWORK,					//查看网络状态
+	LOG_TYPE_VIEW_ONLINE_USER,				//查看在线用户
+	LOG_TYPE_VIEW_EXPORT_LOG,				//导出日志
+	LOG_TYPE_VIEW_EXPORT_EVENT,				//导出事件
+
+	//异常信息(Error)
+	LOG_TYPE_ERROR_INFO		= 0x00400000,
+	LOG_TYPE_IP_CONFLICT,					//网络地址冲突
+	LOG_TYPE_NETWORK_ERR,					//网络异常
+	LOG_TYPE_DDNS_ERR,						//DDNS错误
+	LOG_TYPE_DISK_IO_ERR,					//磁盘读写错误
+	LOG_TYPE_UNKNOWN_OFF,					//异常断电
+	LOG_TYPE_UNKNOWN_ERR,					//未知错误
+	LOG_TYPE_ERR_9A9A9A9A,
+	LOG_TYPE_ERR_9A000001,
+	LOG_TYPE_ERR_9A000002,
+	LOG_TYE_DISK_WARNING,                  //磁盘衰减报警
+	LOG_TYE_DISK_DISCONNECT,                  //磁盘掉线报警
+	//LOG_TYE_DISK_NOTFIND,					//开机无硬盘
+
+    LOG_TYPE_EVENT            = 0x00800000,   //事件信息
+    LOG_TYPE_EVENT_MOTION     = 0x00800001,
+    LOG_TYPE_EVENT_SENSOR     = 0x00800002,
+    LOG_TYPE_EVENT_VIDEO_LOSS = 0x00800004,
+    LOG_TYPE_EVENT_COVER      = 0x00800008,
+    LOG_TYPE_EVENT_PIR		  = 0x00800010,   //yqf add 2017.12.26
+}LOG_TYPE;

Ansjer/file/requirements.txt

@@ -0,0 +1,19 @@
+Django > 2.0
+django-cors-headers
+django-imagekit
+django-guardian
+django-rest-framework
+simplejson
+djangorestframework-jwt
+South
+qcloudsms_py==0.1.1
+itsdangerous
+openpyxl
+xlrd
+mysqlclient
+boto3
+requests_aws4auth
+ffmpy
+xmltodict
+var_dump
+django-middleware-global-request

Ansjer/file/后台管理系统说明.txt

@@ -0,0 +1,69 @@
+一.修改记录
+创建时间： 2017/10/25 版本： 1.0
+
+二.项目说明
+	1.架构概述
+		1).现有模块 :  用户模块(包括用户设备共享模块)  设备信息模块 OTA模块 Token验证模块
+		2).整体说明 :                                  OTA模块
+		                                                 ↗ 
+														 
+			用户注册 -> 用户登录  -> Token验证模块 
+
+				 ↓		          ↓                     ↘
+			 用户模块       用户模块             设备信息模块
+		3).各个模块明细说明
+			1. 用户模块: 
+				用户信息处理模块：用户基本操作
+					用户注册：包括获取验证码，然后通过验证注册用户
+					用户登录：返回Token信息给后续验证用户安全性
+					用户信息完善：修改完善用户个人信息
+					用户修改密码：修改用户密码
+					用户重置密码：重置密码（使用邮箱进行重置）
+					显示用户信息：显示本用户当前信息
+					显示所有用户信息：只有管理员与超级管理员可以调用，显示所有的用户信息
+					用户启用、禁用：只有管理员与超级管理员可以调用，启用、禁用设备用户
+				
+				用户设备共享模块：共享用户设备
+					搜索用户：通过用户的信息搜索用户自身另外的账号
+					共享用户设备：主用户把设备共享给搜索到用户（可以共享一台设备，也可以全部等设备）
+					取消用户设备：主用户取消之前共享给其他账号的设备（可以取消共享一台设备，也可以全部等设备）
+					
+			2.Token验证模块：
+				token获取：在登录时调用获取Token
+				token验证：解密access token，验证有效期，如果有效可以继续访问接口，无效返回错误信息
+				token更新：解密refresh token，验证有效性，如果有效并且没有过期就更新access token，然后返回access token，或者返回错误信息
+				token错误信息：通过上面三个接口返回的错误码，解析出来token错误信息，并返回提示用户
+				
+			3.设备信息模块
+				添加设备信息：添加新设备信息
+				查询设备信息：查询本账户名下所有设备信息
+				修改设备信息：修改本账户名下的相应设备信息
+				删除设备信息：删除本账户名下相应设备信息
+				显示所有用户设备信息：只有管理员与超级管理员可以调用，显示所有的用户名下所有设备信息
+			
+			4.OTA模块
+				升级文件上传：上传升级文件（根据文件名称保存到相应的文件夹下）
+				添加版本信息：把上传的升级文件信息更新到数据库表里面
+				获取最新版本信息：通过输入要查询的设备信息，返回查询到该设备最新版本
+				获取最新版本url链接：通过输入要查询的设备信息，返回查询到该设备升级文件的下载链接
+				下载升级文件：通过获取的url下载升级文件
+
+			5.批量处理模块
+				设备信息批量导入：2种内容格式txt格式, 2种调用Excel文件导入方式
+				
+			6.权限模块
+				模型设计：用户、角色、权限，用户 → 多对多 ← 角色， 用户 → 多对多 ← 权限，角色 → 多对多 ← 权限
+			7.日志模块
+			    中间件middle入口进行统计入库，利用nginx自带module进行统计（更精确)
+			8.APP版本信息模块
+			    对应app版本更新，检测版本详细信息
+			9.语言包模块
+			    所有响应信息增加中英适配
+			10.
+
+
+django常用命令
+python3 mangage.py makemigrations
+python3 manage.py migrate --fake
+python3 manage.py sqlmigrate
+python3 manage.py runserver 0.0.0.0:8222

Ansjer/settings.py

@@ -0,0 +1,199 @@
+# 参数配置文件，测试和正式变动比较大的丢这了
+from Ansjer.config import *
+
+DEBUG = True
+# DEBUG = False
+ALLOWED_HOSTS = ['*']
+
+INSTALLED_APPS = [
+    'django.contrib.admin',
+    'django.contrib.auth',
+    'django.contrib.contenttypes',
+    'django.contrib.sessions',
+    'django.contrib.messages',
+    'django.contrib.staticfiles',
+    'corsheaders',
+    'imagekit',
+    'guardian',
+    'django_global_request',
+    'Model',
+]
+
+MIDDLEWARE = [
+    'corsheaders.middleware.CorsMiddleware',
+    'Service.middleware.StatisticsUrlMiddleware',
+    'django.middleware.security.SecurityMiddleware',
+    'django.contrib.sessions.middleware.SessionMiddleware',
+    'django.middleware.common.CommonMiddleware',
+    'django.middleware.csrf.CsrfViewMiddleware',
+    'corsheaders.middleware.CorsPostCsrfMiddleware',
+    'django.contrib.auth.middleware.AuthenticationMiddleware',
+    'django.contrib.messages.middleware.MessageMiddleware',
+    'django.middleware.clickjacking.XFrameOptionsMiddleware',
+    'django.middleware.security.SecurityMiddleware',
+    'django_global_request.middleware.GlobalRequestMiddleware',
+]
+
+AUTHENTICATION_BACKENDS = (
+    'django.contrib.auth.backends.ModelBackend', #django default backend
+    'guardian.backends.ObjectPermissionBackend',
+)
+
+ADDR_URL = []
+ANONYMOUS_USER_ID = -1  # 支持匿名用户
+# 上传路径根目录
+MEDIA_ROOT = os.path.join(BASE_DIR, 'static/Upgrate')
+# 在浏览器上访问该上传文件的url的前缀
+MEDIA_URL = '/static/Upgrate/'
+ROOT_URLCONF = 'Ansjer.urls'
+LOGIN_URL = '/account/login'
+AUTH_USER_MODEL = 'Model.Device_User' # 自定义Model
+APPEND_SLASH = False
+# 腾讯验证
+SDK_AppID = '1400052907'
+App_Key  = '7705976ca6e85fe7b86d6bc2d11f7783'
+TEMPLATES = [
+    {
+        'BACKEND': 'django.template.backends.django.DjangoTemplates',
+        'DIRS': [BASE_DIR + '/static/templates', ],
+        'APP_DIRS': True,
+        'OPTIONS': {
+            'context_processors': [
+                'django.template.context_processors.debug',
+                'django.template.context_processors.request',
+                'django.contrib.auth.context_processors.auth',
+                'django.contrib.messages.context_processors.messages',
+            ],
+        },
+    },
+]
+
+WSGI_APPLICATION = 'Ansjer.wsgi.application'
+
+DATABASES = {'default':DATABASES_DEFAULT}
+
+AUTH_PASSWORD_VALIDATORS = [
+    {
+        'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
+    },
+    {
+        'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
+    },
+    {
+        'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
+    },
+    {
+        'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
+    },
+]
+
+LANGUAGE_CODE = 'en-us'
+TIME_ZONE = 'Asia/Shanghai'
+# TIME_ZONE = 'UTC'
+USE_I18N = True
+USE_L10N = True
+USE_TZ = True
+'''
+
+STATIC_ROOT = os.path.join(BASE_DIR, 'static')
+STATICFILES_DIRS = (
+    os.path.join(BASE_DIR, 'common_static'),
+    '/var/www/static/',
+    'D:/www/static/',
+)
+'''
+#跨域增加忽略
+CORS_ALLOW_CREDENTIALS = True
+CORS_ORIGIN_ALLOW_ALL = True
+CORS_ORIGIN_WHITELIST = ('*')
+
+CORS_ALLOW_METHODS = (
+    'DELETE',
+    'GET',
+    'OPTIONS',
+    'PATCH',
+    'POST',
+    'PUT',
+    'VIEW',
+)
+
+CORS_ALLOW_HEADERS = (
+    'XMLHttpRequest',
+    'X_FILENAME',
+    'accept',
+    'accept-encoding',
+    'authorization',
+    'content-type',
+    'dnt',
+    'origin',
+    'user-agent',
+    'x-csrftoken',
+    'x-requested-with',
+    'Pragma',
+)
+
+#########################################
+'''
+增加错误信息推送到管理员邮箱
+'''
+# 管理员邮箱
+ADMINS = (
+    ('admin', 'chanjunkai@163.com'),
+    ('admin', '1379072853@qq.com'),
+)
+
+# 非空链接，却发生404错误，发送通知MANAGERS
+SEND_BROKEN_LINK_EMAILS = True
+MANAGERS = ADMINS
+
+# Email设置
+EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
+EMAIL_HOST = 'smtp.163.com'  # QQ邮箱SMTP服务器(邮箱需要开通SMTP服务)
+EMAIL_PORT = 25  # QQ邮箱SMTP服务端口
+EMAIL_HOST_USER = 'chanjunkai@163.com'  # 我的邮箱帐号
+EMAIL_HOST_PASSWORD = 'cjk1234'  # 授权码
+EMAIL_SUBJECT_PREFIX = 'website'  # 为邮件标题的前缀,默认是'[django]'
+EMAIL_USE_TLS = True  # 开启安全链接
+DEFAULT_FROM_EMAIL = SERVER_EMAIL = EMAIL_HOST_USER  # 设置发件人
+
+
+LOGGING = {
+    'version': 1,
+    'disable_existing_loggers': True,
+    'formatters': {
+        'error_format': {
+            # 'format': '{"asctime":"%(asctime)s","thread":"%(threadName)s:%(thread)d","errorline":"%(lineno)d","errorlevel":"%(levelname)s","errorcontent":"%(message)s"}'
+            'format': '%(asctime)s %(threadName)s %(thread)d %(lineno)d %(levelname)s %(message)s'
+        },
+    },
+    'filters': {
+    },
+    'handlers': {
+        'mail_admins': {
+            'level': 'ERROR',
+            'class': 'django.utils.log.AdminEmailHandler',
+            'include_html': True,
+        },
+        'default': {
+            'level':'ERROR',
+            'class':'logging.handlers.RotatingFileHandler',
+            'filename': BASE_DIR + '/static/log/error.log',
+            'maxBytes': 1024*1024*5, # 5 MB
+            'backupCount': 5,
+            'formatter':'error_format',
+        },
+        'console':{
+            'level': 'ERROR',
+            'class': 'logging.StreamHandler',
+            'formatter': 'error_format'
+        },
+    },
+    'loggers': {
+        'django': {
+            'handlers': ['default','console'],
+            # 'handlers': ['mail_admins','default','console'],
+            'level': 'ERROR',
+            'propagate': False
+        },
+    }
+}

Ansjer/test/666.py

@@ -0,0 +1,58 @@
+#！/usr/bin/env python
+import urllib.request
+import urllib.parse
+from sina.miniweibo import APIClient
+def weibo():
+    APP_KEY="2911889655"
+    APP_SECRET="a87782ecfc82aa969f2f99ee285777bd"
+    CALL_BACK="https://api.weibo.com/oauth2/default.html"
+    AUTH_URL="https://api.weibo.com/oauth2/default.html"
+    USER_ID="5124480538"
+    PASSWD="mini111"
+    client=APIClient(app_key=APP_KEY,app_secret=APP_SECRET,redirect_uri=CALL_BACK)
+    refer_url= client.get_authorize_url()
+    print("refer url:"+refer_url)
+    cookies=urllib.request.HTTPCookieProcessor()
+    opener = urllib.request.build_opener(cookies)
+    urllib.request.install_opener(opener)
+    postdata={
+        "client_id":APP_KEY,
+        "redirect_uri":CALL_BACK,
+        "userId":USER_ID,
+        "password":PASSWD,
+        "IsLoginSina":"0",
+        "action":"submit",
+        "response_type":"code",
+    }
+    headers={
+        "User-Agent":"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.90 Safari/537.36",
+        "Host":"api.weibo.com" ,
+        "Referer":refer_url
+    }
+    req=urllib.request.Request(
+        url=AUTH_URL,
+        data=urllib.parse.urlencode(postdata).encode("utf-8"),
+        headers=headers
+    )
+    try:
+        resp=urllib.request.urlopen(req)
+        print("callbackurl is %s" % resp.geturl())
+        pat = "code=(.*?)%"
+        print(resp.geturl())
+        code = input("input the retured code : ")
+        print("code is %s"% code)
+    except Exception as e:
+        print(e)
+    r=client.request_access_token(code)
+    access_token=r.access_token
+    expires_in=r.expires_in
+    print("access_token:",access_token)
+    print("expires_in:",expires_in)
+    client.set_access_token(access_token, expires_in)
+    return client,access_token
+client,access_token= weibo()
+#调用接口：（/转为__）客户对象，方法，接口名，接口目录，接口名（参数）
+rst=client.get.statuses__repost_timeline(id="FsMuBAG3n")
+print(rst)
+rst1=client.get.statuses__user_timeline(source="2911889655")
+print(rst1)

Ansjer/test/SyncdbTools.sh

@@ -0,0 +1,151 @@
+#!/bin/bash
+### BEGIN INIT INFO
+# Provides:          Liuzhiting
+# Required-Start:    $local_fs $remote_fs $network $syslog
+# Required-Stop:     $local_fs $remote_fs $network $syslog
+# Default-Start:     2 3 4 5
+# Default-Stop:      0 1 6
+# Short-Description: starts the mysql migrate
+# Description:       A database migration script for a back-end server system.
+### END INIT INFO
+
+function mysqlDump(){
+        echo 你输入的文件名称是：$3.txt
+	echo $1 $2 $3 $4 $3.txt $(date +%Y%m%d)
+	filePath="/mnt/sql/$(date +%Y%m%d)/"
+	if [ ! -x "$filePath" ];then
+		mkdir -p "$filePath"
+	fi
+
+        if [ "$2" == "all" ];then
+                echo 你选择的是全部备份，正在备份迁移请等待...
+		mysqldump -u root -pliuzhiting $1 > $filePath$3.txt
+		
+		filesize=$(stat -c "%s" $filePath$3.txt)
+		
+		if [ $filesize -gt 0 ];then
+			fullPath=$filePath$3.txt
+			echo "$fullPath $filesize 1024" | awk '{printf("备份文件全路径是:%s，文件大小:%0.5fkb\n", $1, $2/$3)}'
+			echo 备份迁移完成...
+			return 0
+		else
+			echo 未知原因，无法备份迁移...
+			return -1
+		fi
+
+
+        elif [ "$2" == "table" ];then
+                echo 你选择的备份的表格是：$4
+		mysqldump -u root -pliuzhiting $1 $4 > $filePath$3.txt
+		
+		filesize=$(stat -c "%s" $filePath$3.txt)
+		
+		if [ $filesize -gt 0 ];then
+			# echo 备份文件全路径:$filePath$3.txt，文件大小:$[$filesize/1024]kb
+			fullPath=$filePath$3.txt
+			echo "$filesize 1024 $fullPath" | awk '{printf("备份文件全路径是:%s，文件大小:%0.5fkb\n", $3, $1/$2)}'
+			echo 备份迁移完成...
+			return 0
+		else
+			echo 未知原因，无法备份迁移...
+			return -1
+		fi
+
+	else
+		echo $2
+                echo $3
+        fi
+
+        return -1
+}
+
+function manageDumpData () {
+	echo $1 $2 $3 $4
+	filePath="/mnt/sql/$(date +%Y%m%d)/"
+	if [ ! -x "$filePath" ];then
+		echo 正在创建$filePath文件夹
+		mkdir -p "$filePath"
+		echo 创建完成...
+	fi
+
+	echo $filePath$3.json
+
+	if [ ! -x "$1" ];then
+		echo 项目文件路径不存在，"$1"...
+		return -1
+	fi
+
+	cd "$1"
+	if [ "$2" == "all" ];then
+		echo 你选择的是备份项目数据库全部表格
+		if [ ! -f "$1manage.py" ];then
+			echo 项目路径下不存在"$1manage.py"
+			return -1
+		fi
+
+		python3 manage.py dumpdata > $filePath$3.json
+		
+		filesize=$(stat -c "%s" $filePath$3.json)
+
+		if [ $filesize -gt 0 ];then
+			fullPath=$filePath$3.json
+			echo "$fullPath $filesize 1024" | awk '{printf("备份文件全路径是:%1，文件大小:%0.5fkb\n", $1, $2/$3}'
+			echo 备份迁移完成...
+			return 0
+		else
+			echo 未知原因，无法备份迁移...
+			return -1
+		fi
+
+	elif [ "$2" == "app" ];then
+		echo 你选择备份Appname名称是:$4
+		python3 manage.py dumpdata $4 > $filePath$3.json
+		
+		filesize=$(stat -c "%s" $filePath$3.json)
+
+		if [ $filePath -gt 0 ];then
+			fullPath=$filePath$3.json
+			echo "$fullPath $filesize 1024" | awk '{printf("备份文件全路径是:%1，文件大小:%0.5fkb\n", $1, $2/$3}'
+			echo 备份迁移完成...
+			return 0
+		else
+			echo 未知原因，无法备份迁移...
+			return -1
+		fi
+	else
+		echo "YYYYY"
+
+		return 0
+	fi
+
+	return -1	
+
+}
+
+
+read -t 30 -p "请输入迁移方式(mysql自带方式[dump]或者Python方式[migrate],如果你选择的是mysql方式请再输入要备份的数据库名称[请按空格隔开,30秒完成输入]):" migrate dbname
+echo "$migrate" $dbname
+if [ ! $migrate ];then
+	migrate="dump"
+	dbname='Ansjer'
+fi
+
+if [ "$migrate" == "dump" ];then
+    echo 你选择的是MySQL备份方式，并且你要备份的数据库是:$dbname
+    read -t 30 -p "请先输入文件名称，然后选择备份所有数据[all] 或者备份其中一个表格[table]，如果选择的备份其中一个表格请再输入表格名称[每个输入用表格隔开]" filename database tablename
+    echo ddde, $database $filename $tablename
+    filename=${filename:-dump} #当变量a为null或为空字符串时则var=b var=${a:-b}
+    database=${database:-all}
+    mysqlDump $dbname $database $filename $tablename
+    echo $?
+elif [ "$migrate" == "migrate" ];then
+    echo 你选择的是Python方式备份迁移数据库...
+    projPath="/mnt/Sharing/Ansjer/"
+    read -t 30 -p "(请先输入要备份的文件名称，然后是选择要备份appname或者备份全部，如果全部清输入[all],或者输入[app]再输入appnname):" filename database appname
+    filename=${filename:-dump}
+    database=${database:-all}
+    manageDumpData $projPath $database $filename $appname
+    echo $?
+else
+    echo ay
+fi

Ansjer/test/util/mongodb.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python3  
+# -*- coding: utf-8 -*-  
+"""
+@Copyright (C) ansjer cop Video Technology Co.,Ltd.All rights reserved.
+@AUTHOR: ASJRD018
+@NAME: Ansjer
+@software: PyCharm
+@DATE: 2018/6/15 14:18
+@Version: python3.6
+@MODIFY DECORD:ansjer dev
+@file: mongodb.py
+@Contact: chanjunkai@163.com
+"""
+# !/usr/bin/python3
+import pymongo
+
+class mongodb(object):
+
+    def __init__(self):
+        myclient = pymongo.MongoClient('mongodb://localhost:27017/')
+        # myclient = pymongo.MongoClient('mongodb://192.168.136.45:27017/')
+        self.myclient = myclient
+        self.db = myclient['ansjertest']
+
+    def check_db_exist(self, database):
+        dblist = self.myclient.database_names()
+        if database in dblist:
+            return True
+        else:
+            return False
+
+    def insert_one(self, col, data):
+        column = self.db[col]
+        res = column.insert_one(data)
+        return res.inserted_id
+
+    def findAll(self, col,page,line,query):
+        collist = self.db.collection_names()
+        if col in collist:  # 判断 customers 集合是否存在
+            qs = self.db[col].find(query)
+            count = qs.count()
+            if page != 0 and line != 0:
+                qs = qs.sort("_id", -1).skip((page - 1) * 10).limit(line)
+            # print(count)
+            data = []
+            for q in qs:
+                data.append(q)
+            res_dict = {'data': data, 'count': count}
+            return res_dict
+        else:
+            print("集合不存在！")
+            return False
+
+if __name__ == '__main__':
+    mdb = mongodb()
+    col = "log_device_operation"
+    data = {"name": "111", "address": "Lowstreet 27"}
+    flag = mdb.insert_one(col=col, data=data)
+    # qs = mdb.findAll(col=col, page=1, line=100,query={'name':'Peter'})
+    # print(qs)

Ansjer/test/util/sql.py

@@ -0,0 +1,91 @@
+'''
+@author chenjunkai
+@time 20180612
+'''
+"""
+一般 Python 用于连接 MySQL 的工具：pymysql
+"""
+import pymysql.cursors
+
+connection = pymysql.connect(host='localhost',
+                             user='root',
+                             password='1234',
+                             db='test',
+                             charset='utf8mb4',
+                             cursorclass=pymysql.cursors.DictCursor)
+
+
+# 保存评论
+def insert_comments(music_id, comments, detail, connection0):
+    with connection0.cursor() as cursor:
+        sql = "INSERT INTO `comments` (`MUSIC_ID`, `COMMENTS`, `DETAILS`) VALUES (%s, %s, %s)"
+        cursor.execute(sql, (music_id, comments, detail))
+    connection0.commit()
+
+
+# 保存音乐
+def insert_music(music_id, music_name, album_id):
+    with connection.cursor() as cursor:
+        sql = "INSERT INTO `musics` (`MUSIC_ID`, `MUSIC_NAME`, `ALBUM_ID`) VALUES (%s, %s, %s)"
+        cursor.execute(sql, (music_id, music_name, album_id))
+    connection.commit()
+
+
+# 保存专辑
+def insert_album(album_id, artist_id):
+    with connection.cursor() as cursor:
+        sql = "INSERT INTO `albums` (`ALBUM_ID`, `ARTIST_ID`) VALUES (%s, %s)"
+        cursor.execute(sql, (album_id, artist_id))
+    connection.commit()
+
+
+# 保存歌手
+def insert_artist(artist_id, artist_name):
+    with connection.cursor() as cursor:
+        sql = "INSERT INTO `artists` (`ARTIST_ID`, `ARTIST_NAME`) VALUES (%s, %s)"
+        cursor.execute(sql, (artist_id, artist_name))
+    connection.commit()
+
+
+# 获取所有歌手的 ID
+def get_all_artist():
+    with connection.cursor() as cursor:
+        sql = "SELECT `ARTIST_ID` FROM `artists` ORDER BY ARTIST_ID"
+        cursor.execute(sql, ())
+        return cursor.fetchall()
+
+
+# 获取所有专辑的 ID
+def get_all_album():
+    with connection.cursor() as cursor:
+        sql = "SELECT `ALBUM_ID` FROM `albums` ORDER BY ALBUM_ID"
+        cursor.execute(sql, ())
+        return cursor.fetchall()
+
+
+# 获取所有音乐的 ID
+def get_all_music():
+    with connection.cursor() as cursor:
+        sql = "SELECT `MUSIC_ID` FROM `musics` ORDER BY MUSIC_ID"
+        cursor.execute(sql, ())
+        return cursor.fetchall()
+
+
+# 获取前一半音乐的 ID
+def get_before_music():
+    with connection.cursor() as cursor:
+        sql = "SELECT `MUSIC_ID` FROM `musics` ORDER BY MUSIC_ID LIMIT 0, 800000"
+        cursor.execute(sql, ())
+        return cursor.fetchall()
+
+
+# 获取后一半音乐的 ID
+def get_after_music():
+    with connection.cursor() as cursor:
+        sql = "SELECT `MUSIC_ID` FROM `musics` ORDER BY MUSIC_ID LIMIT 800000, 1197429"
+        cursor.execute(sql, ())
+        return cursor.fetchall()
+
+
+def dis_connect():
+    connection.close()

Ansjer/test/util/time.py

@@ -0,0 +1,13 @@
+
+import time, datetime
+print(datetime.datetime.now())
+def gettime():
+    for x in range(24):
+        a = datetime.datetime.now().strftime("%Y-%m-%d") + " %2d:00:00" % x
+        timeArray = time.strptime(a, "%Y-%m-%d %H:%M:%S")
+        timeStamp = int(time.mktime(timeArray))
+        print(timeStamp)
+if __name__ == "__main__":
+    gettime()
+
+

Ansjer/test/util/util_jk.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3  
+# -*- coding: utf-8 -*-  
+"""
+@Copyright (C) ansjer cop Video Technology Co.,Ltd.All rights reserved.
+@AUTHOR: ASJRD018
+@NAME: Ansjer
+@software: PyCharm
+@DATE: 2018/6/14 14:46
+@Version: python3.6
+@MODIFY DECORD:ansjer dev
+@file: util_jk.py
+@Contact: chanjunkai@163.com
+"""
+'''---------------------------------------------------'''
+# 简化for语句
+def getFor():
+    data = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
+    ss = [z for z in data if not data['a'] == 1]
+    print(ss)
+
+'''---------------------------------------------------'''
+# lamdba
+def getLamdba():
+    b = lambda a,y: a + 1+y
+    print(b(a=1,y=2))
+
+'''-----------判断系统版本------------------------'''
+def UsePlatform():
+    import platform
+    sysstr = platform.system()
+    if (sysstr == "Windows"):
+        print("Call Windows tasks")
+    elif (sysstr == "Linux"):
+        print("Call Linux tasks")
+    else:
+        print("Other System tasks")
+
+def access_redis_database(data={}):
+    return
+    POOL = redis.ConnectionPool(host='localhost', port=6379)
+    CONN = redis.Redis(connection_pool=POOL)
+    CONN.rpush('data_list', trans_dict_str(type=1, data=data))
+    data_list_len = CONN.llen('data_list')
+    print('--------------')
+    print(data_list_len)
+    print('!!!!!!!!!!!!!')
+    if data_list_len > 1000:
+        query_set_list = []
+        data_list = CONN.lrange('data_list', 0, data_list_len)
+        for i in range(data_list_len):
+            data_dict = trans_dict_str(type=2, data=data_list[i])
+            query_set_list.append(Access_Log(**data_dict))
+        # 批量插入
+        if len(query_set_list):
+            Access_Log.objects.bulk_create(query_set_list)
+            CONN.delete('data_list')
+    return

Ansjer/urls.py

@@ -0,0 +1,136 @@
+from django.contrib import admin
+from django.conf.urls import url
+# from django.views.generic.base import RedirectView
+from Controller import FeedBackInfo, EquipmentOTA, EquipmentInfo, EquipmentSensor, StreamMedia, AdminManage, AppInfo, \
+    AccessLog, Test, MealManage, DeviceMeal, HlsManage, DeviceManage, EquipmentStatus, SysManage,DeviceLog,LogAccess,EquipmentManager,LogManager,PermissionManager,OTAEquipment,BatchProcessingDatabase,shareUserPermission,UserManger, CheckUserData
+# from rest_framework_jwt.views import obtain_jwt_token, refresh_jwt_token, verify_jwt_token
+
+urlpatterns = [
+    url(r'^admin/', admin.site.urls),
+    # url(r'^favicon.ico$', RedirectView.as_view(url=r'favicon.ico', permanent=True)),
+    url(r'^favicon.ico$', UserManger.success, name=u'favicon.ico'),
+    url(r'^$', UserManger.LoginView.as_view(), name='login'),
+    url(r'^account/login$', UserManger.LoginView.as_view(), name='login_user'),
+    url(r'^account/logout$', UserManger.LogoutView.as_view(), name='logout_user'),
+    url(r'^account/authcode$', UserManger.getAuthCodeView.as_view(), name='auth_code'),
+    url(r'^account/register$', UserManger.registerView.as_view(), name='register_user'),
+    url(r'^account/changePwd$', UserManger.ChangePwdView.as_view(), name='change_password'),
+    url(r'^account/active/(?P<active_code>.*)$', CheckUserData.ActiveUserView.as_view(), name='user_active'),
+    # 配置激活账户链接
+    url(r'^account/forget$', UserManger.ForgetPwdView.as_view(), name='forget_password'),
+    url(r'^account/activate/(?P<token>\w+.[-_\w]*\w+.[-_\w]*\w+)$', CheckUserData.Active_User, name='active_user'),
+    url(r'^account/password/edit$', UserManger.ResetPwdView.as_view(), name='reset_password'),
+    url(r'^account/password/mobiletoResetPwd$', CheckUserData.MobiletoResetPwdView.as_view(),
+        name='Mobile_Reset_Password'),
+    url(r'^account/modifyPwd$', CheckUserData.ModifyPwdView.as_view(), name="modify_password"),
+    url(r'^account/showUserMore$', UserManger.showUserMoreView.as_view(), name='show_User_More'),
+    url(r'^account/perfectUserInfo$', UserManger.perfectUserInfoView.as_view(), name=u'Perfect_User_Info'),
+    url(r'^account/getAvatar/(?P<filePath>.*)$', UserManger.getAvatarView.as_view(), name=u'get_Avatar'),
+    url(r'^account/delUser$', UserManger.delUserInterface, name=u'del_User'),
+    url(r'^account/setUserValid$', UserManger.setUserValidView.as_view(), name=u'set_User_Valid'),
+    url(r'^account/showAllUser$', UserManger.showAllUserInterface, name=u'show_All_User'),
+    url(r'^account/help$', LogManager.HelpView.as_view(), name=u'help_info'),
+    url(r'^account/searchUser$', shareUserPermission.searchUserView.as_view(), name=u'search_User'),
+    url(r'^account/shareUserEquipment$', shareUserPermission.shareUserEquipmentView.as_view(),
+        name=u'share_User_Equipment'),
+    url(r'^account/unsharedUserEquipment$', shareUserPermission.unsharedUserEquipmentView.as_view(),
+        name=u'unshared_User_Equipment'),
+
+    url(r'^response/success$', UserManger.success, name=u'success_info'),
+    # http://13.56.215.252:82/equipment/queryUserEquipment?token=test
+    url(r'^equipment/queryUserEquipment$', EquipmentManager.queryUserEquipmentInterface, name='query_User_Equipment'),
+    url(r'^equipment/addNewUserEquipment$', EquipmentManager.addNewUserEquipmentInterface,
+        name='add_New_User_Equipment'),
+    url(r'^equipment/delUserEquipment$', EquipmentManager.delUserEquipmentInterface, name='del_User_Equipment'),
+    url(r'^equipment/modifyUserEquipment$', EquipmentManager.modifyUserEquipmentInterface,
+        name='modify_User_Equipment'),
+    url(r'^equipment/showAllUserEquipment$', EquipmentManager.showAllUserEquipmentInterface,
+        name='show_All_User_Equipment'),
+    url(r'^equipment/findEquipmentInfo$', EquipmentManager.findEquipmentInfoInterface, name='find_User_Equipment'),
+
+    url(r'^OTA/uploads$', OTAEquipment.getUploadFiletoDirView.as_view(), name=u'uploads_updata_file'),
+    url(r'^OTA/download$', OTAEquipment.downloadUpdataFileUrl, name='downloads_updata_file_backup'),
+    url(r'^OTA/downloads/(\w+)/(\w+[\w+]*.+[^_w]*.\w+)$', OTAEquipment.downloadUpdataFileUrlInterface,
+        name='downloads_updata_file'),
+    url(r'^OTA/getEquipmentVersion$', OTAEquipment.getEquipmentVersionInterface, name=u'get_equipment_version$'),
+    url(r'^OTA/getUpdataFileUrl$', OTAEquipment.getUpdataFileUrlInterface, name=u'get_updata_file_Url'),
+    url(r'^OTA/addNewEquipmentVersion$', OTAEquipment.addNewEquipmentVersionInterface, name=u'add_New_EquipmentVersion'),
+    url(r'^OTA/showAllEquipmentVersion$', OTAEquipment.showAllEquipmentVersionInterface, name=u'show_All_Equipment_Version'),
+
+    url(r'^toekn/refreshToken$', UserManger.refreshTokenView.as_view(), name=u'refresh_token'),
+
+    url(r'^import/batchAddEquipment$', BatchProcessingDatabase.batchAddEquipmentView.as_view(),
+        name=u'batch_Add_Equipment'),
+
+    url(r'^roles/addNewRole$', PermissionManager.addNewRoleView.as_view(), name=u'Add_New_Role'),
+    url(r'^roles/queryRole$', PermissionManager.queryRoleView.as_view(), name=u'Query_Role'),
+    url(r'^roles/delRole$', PermissionManager.delRoleView.as_view(), name=u'del_Role'),
+    url(r'^roles/modifyRole$', PermissionManager.modifyRoleView.as_view(), name=u'modify_Role'),
+    url(r'^perms/addNewPerms$', PermissionManager.addNewPermsView.as_view(), name=u'add_New_Perms'),
+    url(r'^perms/delPerms$', PermissionManager.delPermsView.as_view(), name=u'del_Perms'),
+    url(r'^perms/queryPerms$', PermissionManager.queryPermsView.as_view(), name=u'query_Perms'),
+    url(r'^perms/modifyPerms$', PermissionManager.modifyPermsView.as_view(), name=u'modify_Perms'),
+    url(r'^permsManager/queryRolePerms$', PermissionManager.queryRolePermsView.as_view(), name=u'query_Role_Perms'),
+
+    # url(r'^api-token-auth$', obtain_jwt_token),
+    # url(r'^api-token-refresh$', refresh_jwt_token),
+    # url(r'^api-token-verify$', verify_jwt_token),
+
+    url(r'^uploads/upgrade$', OTAEquipment.getUploadFiletoDirView.as_view(), name=u'upload_upgrade'),
+    url(r'^upgrade/download/(\w+.[^_w]*\w+.\w+)$', CheckUserData.download_file, name='download_upgrade'),
+    url(r'^downloads/upgrade/(\w+)/(\w+.[^_w]*\w+.\w+)$', OTAEquipment.downloadUpdataFileUrlInterface,
+        name='downloads_upgrade'),
+    url(r'^getOTAurl/getUpdataFileUrl$', OTAEquipment.getUpdataFileUrlInterface, name=u'get_updata_file_Url'),
+
+    #  流处理
+    url(r'^media/stream', StreamMedia.StreamMedia.as_view(), name=u'media_stream'),
+    url(r'^media/auth_stream', StreamMedia.Auth_Stream, name=u'auth_stream'),
+    url(r'^media/send_video_s3', StreamMedia.send_video_s3, name=u'auth_stream'),
+    url(r'^media/auth_live', StreamMedia.Auth_Live, name=u'auth_live'),
+    # url(r'^media/push_flv_s3', StreamMedia.push_flv_s3, name=u'push_flv_s3'),
+    # 传感器
+    url(r'^equipment/sensor', EquipmentSensor.EquipmentSensor.as_view(), name=u'equiment_sensor'),
+    # 设备推送信息
+    url(r'^equipment/info', EquipmentInfo.EquipmentInfo.as_view(), name=u'equiment_info'),
+    # 管理员专属view
+    url(r'^adminManage/manage', AdminManage.AdminManage.as_view(), name=u'adminManage'),
+    # OTA重构类
+    url(r'^equipment/OTA', EquipmentOTA.EquipmentOTA.as_view(), name=u'equipmentOTA'),
+    # 用户反馈信息
+    url(r'^feedbackInfo', FeedBackInfo.FeedBackInfo.as_view(), name=u'feedbackInfoView'),
+    # app版本信息
+    url(r'^appInfo', AppInfo.AppInfo.as_view(), name=u'AppInfo'),
+    # 访问日志new
+    url(r'^accesslog', AccessLog.AccessLog.as_view(), name=u'AccessLog'),
+
+    # 套餐信息管理
+    url(r'^meal/manage', MealManage.MealManage.as_view(), name=u'MealManage'),
+    # 设备套餐绑定
+    url(r'^device/meal$', DeviceMeal.DeviceMeal.as_view(), name=u'DeviceMeal'),
+    # hls put_object签名url
+    url(r'^HlsManage$', HlsManage.HlsManage.as_view(), name=u'get_sign_put_object'),
+    # 设备管理
+    url(r'^device/manage$', DeviceManage.DeviceManage.as_view(), name=u'device_manage'),
+    # 设备在线
+    url(r'^device/online$', EquipmentStatus.EquipmentOnline, name=u'device_online'),
+    # 设备离线
+    url(r'^device/offline$', EquipmentStatus.EquipmentOffline, name=u'device_offline'),
+    # 设备离线
+    url(r'^device/updateIP$', EquipmentStatus.updateIP, name=u'device_updateIP'),
+    # 系统ctr
+    url(r'^sys/updateLog', SysManage.updateLog, name=u'sys_update_log'),
+    # 设备日志
+    url(r'^devices/(\w+)/logs$', DeviceLog.DeviceLog, name=u'device_log'),
+    url(r'^devices/(\w+)$', DeviceManage.Devices, name=u'device_log'),
+    # 访问日志 mongodb版
+    url(r'^LogAccess$', LogAccess.LogAccess, name=u'device_log'),
+    # 上传操作文档
+    url(r'^HelpCHM/upload$', LogManager.upload_help_chm, name=u'upload_help'),
+    url(r'^admin/userIDs$', AdminManage.getUserIds, name=u'getUserIds'),
+
+    # 测试专用api
+    url(r'^Test$', Test.Test.as_view(), name=u'Test'),
+    # 路由加参数参考
+    # url(r'^(?P<path>.*)/(?P<UID>.*)/lls$', Test.Test.as_view(), name=u'gg'),
+    url(r'^(?P<path>.*)$', LogManager.errorPath, name=u'error_path'),
+]

Ansjer/wsgi.py

@@ -0,0 +1,16 @@
+"""
+WSGI config for Ansjer project.
+
+It exposes the WSGI callable as a module-level variable named ``application``.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/dev/howto/deployment/wsgi/
+"""
+
+import os
+
+from django.core.wsgi import get_wsgi_application
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "Ansjer.settings")
+
+application = get_wsgi_application()

Controller/AccessLog.py

@@ -0,0 +1,127 @@
+from django.views.generic.base import View
+from django.utils.decorators import method_decorator
+from django.views.decorators.csrf import csrf_exempt
+from Service.TokenManager import JSONTokenManager
+from Service.ModelService import ModelService
+from Service.CommonService import CommonService
+from Model.models import Access_Log
+import datetime
+from var_dump import var_dump
+from Service.ResponseService import *
+
+'''
+http://192.168.136.40:8077/accesslog?operation=queryByAdmin&token=test&page=1&line=5&order=-id
+http://192.168.136.40:8077/accesslog?operation=truncateByAdmin&token=test
+http://192.168.136.40:8077/accesslog?operation=searchByAdmin&token=test&page=1&line=10&content={"status":20}&order=-id
+'''
+
+
+class AccessLog(View):
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(AccessLog, self).dispatch(*args, **kwargs)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        return self.validation(request_dict=request.GET)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        return self.validation(request_dict=request.POST)
+
+    def validation(self, request_dict, *args, **kwargs):
+        token = request_dict.get('token', None)
+        if token is not None:
+            tokenManager = JSONTokenManager()
+            error_code = tokenManager.verify_AToken(token)
+            if error_code == 0:
+                userID = tokenManager.accessDict.get('userID', None)
+                operation = request_dict.get('operation', None)
+                param_flag = CommonService.get_param_flag(data=[userID, operation])
+                if param_flag is True:
+                    if operation == 'queryByAdmin':
+                        return self.query_by_admin(request_dict=request_dict, userID=userID)
+                    elif operation == 'searchByAdmin':
+                        return self.search_by_admin(request_dict=request_dict, userID=userID)
+                    elif operation == 'truncateByAdmin':
+                        return self.truncate_by_admin(userID=userID)
+                return ResponseJSON(444)
+            else:
+                return HttpResponse(tokenManager.errorCodeInfo(error_code))
+        else:
+            return ResponseJSON(311)
+
+    def query_by_admin(self, request_dict, userID):
+        page = int(request_dict.get('page', None))
+        line = int(request_dict.get('line', None))
+        order = request_dict.get('order', '-id')
+        if order == '':
+            order = '-id'
+        param_flag = CommonService.get_param_flag(data=[page, line])
+        if param_flag is True:
+            check_perm = ModelService.check_permission(userID=userID, permID=30)
+            if check_perm is True:
+                access_log_queryset = Access_Log.objects.all().order_by(order)
+                if access_log_queryset.exists():
+                    count = access_log_queryset.count()
+                    res = access_log_queryset[(page - 1) * line:page * line]
+                    send_json = CommonService.query_set_to_dict(res)
+                    send_json['count'] = count
+                    return ResponseJSON(0,send_json)
+                return ResponseJSON(0, {'datas': [], 'count': 0})
+            else:
+                return ResponseJSON(404)
+        else:
+            return ResponseJSON(444)
+
+    def truncate_by_admin(self, userID):
+        check_perm = ModelService.check_permission(userID=userID, permID=10)
+        if check_perm is True:
+            from django.db import connection
+            cursor = connection.cursor()
+            cursor.execute("TRUNCATE TABLE `access_log`")
+        return ResponseJSON(0)
+
+    def search_by_admin(self, request_dict, userID):
+        page = int(request_dict.get('page', None))
+        line = int(request_dict.get('line', None))
+        order = request_dict.get('order', '-id')
+        content = request_dict.get('content', None)
+        starttime = request_dict.get('starttime', None)
+        endtime = request_dict.get('endtime', None)
+        param_flag = CommonService.get_param_flag(data=[page, line])
+        if param_flag is True:
+            check_perm = ModelService.check_permission(userID=userID, permID=20)
+            if check_perm is True:
+                try:
+                    content = json.loads(content)
+                    search_kwargs = CommonService.get_kwargs(data=content)
+                except Exception as e:
+                    return ResponseJSON(444)
+                queryset = Access_Log.objects.filter(**search_kwargs).order_by(order)
+                if starttime is not None and starttime != '' and endtime is not None and endtime != '':
+                    startt = datetime.datetime.fromtimestamp(int(starttime))
+                    starttime = startt.strftime("%Y-%m-%d %H:%M:%S.%f")
+                    endt = datetime.datetime.fromtimestamp(int(endtime))
+                    endtime = endt.strftime("%Y-%m-%d %H:%M:%S.%f")
+                    var_dump(starttime,endtime)
+                    queryset = queryset.filter(time__range=(starttime, endtime))
+                elif starttime is not None and starttime != '':
+                    startt = datetime.datetime.fromtimestamp(int(starttime))
+                    starttime = startt.strftime("%Y-%m-%d %H:%M:%S.%f")
+                    queryset = queryset.filter(time__gte=starttime)
+                elif endtime is not None and endtime != '':
+                    endt = datetime.datetime.fromtimestamp(int(endtime))
+                    endtime = endt.strftime("%Y-%m-%d %H:%M:%S.%f")
+                    queryset = queryset.filter(time__lte=endtime)
+                if queryset.exists():
+                    count = queryset.count()
+                    res = queryset[(page - 1) * line:page * line]
+                    send_json = CommonService.query_set_to_dict(res)
+                    send_json['count'] = count
+                    return ResponseJSON(0,send_json)
+                return ResponseJSON(0,{'datas': [], 'count': 0})
+            else:
+                return ResponseJSON(404)
+        else:
+            return ResponseJSON(444)

Controller/AdminManage.py

@@ -0,0 +1,169 @@
+# -*- coding: utf-8 -*-
+from django.views.decorators.csrf import csrf_exempt
+from django.views.generic import TemplateView
+from django.utils.decorators import method_decorator
+from django.contrib.auth.hashers import make_password  # 对密码加密模块
+from Service.TokenManager import JSONTokenManager
+from Model.models import Device_User, Device_Info
+from Service.CommonService import CommonService
+from Service.ModelService import ModelService
+import datetime
+from Model.models import Access_Log
+from Service.ResponseService import *
+from django.views.decorators.http import require_http_methods
+'''
+http://13.56.215.252:8222/adminManage/manage?operation=getAllDeviceArea&token=test
+http://13.56.215.252:8222/adminManage/manage?operation=getAllUserName&token=test
+http://13.56.215.252:8222/adminManage/manage?operation=getAllUID&token=test
+
+'''
+
+
+class AdminManage(TemplateView):
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(AdminManage, self).dispatch(*args, **kwargs)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        return self.validation(request_dict=request.GET)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        return self.validation(request_dict=request.POST)
+
+    def validation(self, request_dict, *args, **kwargs):
+        token = request_dict.get('token', None)
+        if token is not None:
+            tokenManager = JSONTokenManager()
+            error_code = tokenManager.verify_AToken(token)
+            if error_code == 0:
+                userID = tokenManager.accessDict.get('userID', None)
+                operation = request_dict.get('operation', None)
+                param_flag = CommonService.get_param_flag(data=[userID, operation])
+                if param_flag is True:
+                    if operation == 'resetUserPwd':
+                        return self.resetUserPwd(request_dict=request_dict, userID=userID)
+                    if operation == 'getAllUserName':
+                        return self.getAllUserName(userID=userID)
+                    if operation == 'getStatisAccess':
+                        return self.getStatisAccess(userID=userID,request_dict=request_dict)
+                    if operation == 'getAllUID':
+                        return self.getAllUID(userID=userID)
+                    if operation == 'getAllDeviceArea':
+                        return self.getAllDeviceArea(userID=userID)
+                else:
+                    return ResponseJSON(444)
+            else:
+                return HttpResponse(tokenManager.errorCodeInfo(error_code))
+        else:
+            return ResponseJSON(311)
+
+    def resetUserPwd(self, request_dict, userID):
+        own_permission = ModelService.check_permission(userID=userID, permID=50)
+        if own_permission is True:
+            duserID = request_dict.get('duserID', None)
+            userPwd = request_dict.get('userPwd', None)
+            param_flag = CommonService.get_param_flag(data=[duserID])
+            if param_flag is True:
+                UserValid = Device_User.objects.filter(userID=duserID)
+                if UserValid:
+                    if userPwd is None:
+                        userPwd = '123456'
+                    is_update = UserValid.update(password=make_password(userPwd))
+                    if is_update:
+                        return ResponseJSON(0)
+                    else:
+                        return ResponseJSON(106)
+            else:
+                return ResponseJSON(444)
+        else:
+            return ResponseJSON(404)
+
+    def getAllUserName(self, userID):
+        own_permission = ModelService.check_permission(userID=userID, permID=30)
+        if own_permission is True:
+            username_list = Device_User.objects.all().values_list('username', flat=True)
+            if username_list:
+                return ResponseJSON(0,{'username_list': list(username_list)})
+            else:
+                return ResponseJSON(0)
+        else:
+            return ResponseJSON(404)
+
+
+    # 获取所有设备地区
+    def getAllDeviceArea(self, userID):
+        own_permission = ModelService.check_permission(userID=userID, permID=30)
+        if own_permission is True:
+            qs = Device_Info.objects.all().values('area','UID')
+            uid_area_dict = {}
+            for q in qs:
+                if q['UID'] and q['area']:
+                    uid_area_dict[q['UID']]=q['area']
+            if len(uid_area_dict):
+                area_dict = {}
+
+                for k,v in uid_area_dict.items():
+                    if v in area_dict:
+                        area_dict[v] += 1
+                    else:
+                        area_dict[v] = 1
+                return ResponseJSON(0,{'area':area_dict})
+            else:
+                return ResponseJSON(0)
+        else:
+            return ResponseJSON(404)
+
+    '''
+    统计一天访问量
+    http://192.168.136.45:8077/adminManage/manage?token=test&operation=getStatisAccess&timestamp=1528773308
+    '''
+    def getStatisAccess(self,userID,request_dict):
+        own_permission = ModelService.check_permission(userID=userID, permID=30)
+        if own_permission is True:
+            time_stamp = int(request_dict.get('timestamp', None))
+            times = datetime.datetime.fromtimestamp(time_stamp)
+            time_dict = CommonService.getTimeDict(times)
+            res = {}
+            for k, v in time_dict.items():
+                start_date = time_dict[k]
+                end_date = time_dict[k] + datetime.timedelta(hours=1)
+                count = Access_Log.objects.filter(time__range=(start_date, end_date)).count()
+                if count:
+                    res[k] = count
+                else:
+                    res[k] = 0
+            return ResponseJSON(0, {'count': res})
+        else:
+            return ResponseJSON(404)
+
+    def getAllUID(self,userID):
+        own_permission = ModelService.check_permission(userID=userID, permID=30)
+        if own_permission is True:
+            uid_list = Device_Info.objects.all().values_list('UID', flat=True)
+            if uid_list:
+                return ResponseJSON(0, {'count': len(uid_list),'uid_list':list(uid_list)})
+        else:
+            return ResponseJSON(404)
+
+@csrf_exempt
+@require_http_methods(["GET"])
+def getUserIds(request):
+    token = request.GET.get('token', None)
+    if token is not None:
+        tokenManager = JSONTokenManager()
+        error_code = tokenManager.verify_AToken(token)
+        if error_code == 0:
+            userID = tokenManager.accessDict.get('userID', None)
+            own_perm = ModelService.check_permission(userID,30)
+            if own_perm is True:
+                # userID_list = Device_User.objects.all().values_list('userID', flat=True)
+                dn = Device_User.objects.all().values('userID', 'username')
+                return ResponseJSON(0,{"datas":list(dn)})
+            else:
+                return ResponseJSON(404)
+        else:
+            return HttpResponse(tokenManager.errorCodeInfo(error_code))
+    else:
+        return ResponseJSON(311)

Controller/AppInfo.py

@@ -0,0 +1,218 @@
+from django.views.generic.base import View
+from django.utils.decorators import method_decorator
+from django.views.decorators.csrf import csrf_exempt
+from Service.TokenManager import JSONTokenManager
+from Service.ModelService import ModelService
+from Service.CommonService import CommonService
+from Model.models import App_Info
+import traceback
+from Service.ResponseService import *
+
+'''
+http://192.168.136.45:8077/appInfo?operation=add&token=test&appBundleId=123456&appName=%E8%AF%BA%E5%9F%BA%E4%BA%9A1%E5%8F%B7&systemLanguage=US&content=dladfjklsjfdsajkdfasjkljlk&app_type=2&newAppversion=1234&bundleVersion=1234
+http://192.168.136.45:8077/appInfo?operation=update&token=test&appBundleId=1234&appName=%E8%AF%BA%E5%9F%BA%E4%BA%9A3%E5%8F%B7&systemLanguage=US&content=dladfjklsjfdsajkdfasjkljlk&app_type=2&newAppversion=555&id=6
+http://192.168.136.45:8077/appInfo?operation=query&token=test&page=1&line=10
+http://192.168.136.45:8077/appInfo?operation=delete&token=test&id=1&id=2&id=3&id=4&id=5
+'''
+
+
+class AppInfo(View):
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(AppInfo, self).dispatch(*args, **kwargs)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        return self.validation(request_dict=request.GET)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        return self.validation(request_dict=request.POST)
+
+    def validation(self, request_dict, *args, **kwargs):
+        operation = request_dict.get('operation', None)
+        if operation is not None:
+            if operation == 'getAppNewVersion':
+                return self.getAppNewVersion(request_dict=request_dict)
+            else:
+                token = request_dict.get('token', None)
+                if token is not None:
+                    tokenManager = JSONTokenManager()
+                    error_code = tokenManager.verify_AToken(token)
+                    if error_code == 0:
+                        userID = tokenManager.accessDict.get('userID', None)
+                        param_flag = CommonService.get_param_flag(data=[userID])
+                        if param_flag is True:
+                            if operation == 'query':
+                                return self.query(request_dict=request_dict, userID=userID)
+                            elif operation == 'add':
+                                return self.add(request_dict=request_dict, userID=userID)
+                            elif operation == 'update':
+                                return self.update(request_dict=request_dict, userID=userID)
+                            elif operation == 'delete':
+                                return self.delete(request_dict=request_dict, userID=userID)
+                        return ResponseJSON(444)
+                    else:
+                        return HttpResponse(tokenManager.errorCodeInfo(error_code))
+                else:
+                    return ResponseJSON(311)
+        else:
+            return ResponseJSON(444)
+
+    def getAppNewVersion(self, request_dict):
+        appBundleId = request_dict.get('appBundleId', None)
+        app_type = request_dict.get('app_type', None)
+        # systemLanguage = request_dict.get('systemLanguage',None)
+        param_flag = CommonService.get_param_flag(data=[appBundleId, app_type])
+        if param_flag is True:
+            try:
+                app_info = App_Info.objects.get(appBundleId=appBundleId, app_type=app_type)
+            except Exception:
+                errorInfo = traceback.format_exc()
+                print(errorInfo)
+                return ResponseJSON(424, {'details': errorInfo})
+            else:
+                return ResponseJSON(0, {'appBundleId': app_info.appBundleId,
+                                        'appName': app_info.appName,
+                                        'newAppversion': app_info.newAppversion,
+                                        'systemLanguage': app_info.systemLanguage,
+                                        'content': app_info.content,
+                                        'app_type': app_info.app_type,
+                                        'id': app_info.id,
+                                        'bundleVersion': app_info.bundleVersion})
+        else:
+            return ResponseJSON(444)
+
+    def add(self, request_dict, userID):
+        own_perm = ModelService.check_permission(userID=userID, permID=40)
+        if own_perm is True:
+            appBundleId = request_dict.get('appBundleId', None)
+            appName = request_dict.get('appName', None)
+            systemLanguage = request_dict.get('systemLanguage', None)
+            newAppversion = request_dict.get('newAppversion', None)
+            content = request_dict.get('content', None)
+            app_type = request_dict.get('app_type', None)
+            bundleVersion = request_dict.get('bundleVersion', None)
+            param_flag = CommonService.get_param_flag(
+                data=[appBundleId, appName, systemLanguage, newAppversion, content, app_type, bundleVersion])
+            if param_flag is True:
+                try:
+                    has_app_info = App_Info.objects.filter(appBundleId=appBundleId)
+                except Exception:
+                    errorInfo = traceback.format_exc()
+                    print(errorInfo)
+                    return ResponseJSON(424, {'details': errorInfo})
+                else:
+                    if has_app_info.exists():
+                        return ResponseJSON(60)
+                    else:
+                        try:
+                            app_Info = App_Info(
+                                appBundleId=appBundleId,
+                                appName=appName,
+                                newAppversion=newAppversion,
+                                systemLanguage=systemLanguage,
+                                content=content,
+                                app_type=app_type,
+                                bundleVersion=bundleVersion,
+                            )
+                            app_Info.save()
+                        except Exception:
+                            errorInfo = traceback.format_exc()
+                            print(errorInfo)
+                            return ResponseJSON(500, {'details': errorInfo})
+                        else:
+                            app_Info.save()
+                            if app_Info.id:
+                                return ResponseJSON(0,
+                                                    {
+                                                        'appBundleId': app_Info.appBundleId,
+                                                        'appName': app_Info.appName,
+                                                        'newAppversion': app_Info.newAppversion,
+                                                        'systemLanguage': app_Info.systemLanguage,
+                                                        'content': app_Info.content,
+                                                        'app_type': app_Info.app_type,
+                                                        'id': app_Info.id,
+                                                        'bundleVersion': app_Info.bundleVersion,
+                                                    })
+                            else:
+                                return ResponseJSON(500)
+            return ResponseJSON(444)
+        else:
+            return ResponseJSON(404)
+
+    def query(self, request_dict, userID):
+        own_perm = ModelService.check_permission(userID=userID, permID=30)
+        if own_perm is True:
+            page = int(request_dict.get('page', None))
+            line = int(request_dict.get('line', None))
+            param_flag = CommonService.get_param_flag(data=[page, line])
+            if param_flag is True:
+                queryset = App_Info.objects.all()
+                if queryset.exists():
+                    count = queryset.count()
+                    res = queryset[(page - 1) * line:page * line]
+                    send_json = CommonService.query_set_to_dict(res)
+                    send_json['count'] = count
+                    return ResponseJSON(0, send_json)
+                return ResponseJSON(0)
+            else:
+                return ResponseJSON(444)
+        else:
+            return ResponseJSON(404)
+
+    def update(self, request_dict, userID):
+        own_perm = ModelService.check_permission(userID=userID, permID=30)
+        if own_perm is True:
+            id = request_dict.get('id', None)
+            appBundleId = request_dict.get('appBundleId', None)
+            appName = request_dict.get('appName', None)
+            systemLanguage = request_dict.get('systemLanguage', None)
+            newAppversion = request_dict.get('newAppversion', None)
+            content = request_dict.get('content', None)
+            app_type = request_dict.get('app_type', None)
+            bundleVersion = request_dict.get('bundleVersion', None)
+            param_flag = CommonService.get_param_flag(
+                data=[appBundleId, appName, systemLanguage, newAppversion, content, app_type, bundleVersion])
+            if param_flag is True:
+                try:
+                    app_info = App_Info.objects.get(id=id)
+                except Exception:
+                    errorInfo = traceback.format_exc()
+                    print(errorInfo)
+                    return ResponseJSON(424, {'details': errorInfo})
+                else:
+                    if app_info.id:
+                        app_info.appBundleId = appBundleId
+                        app_info.appName = appName
+                        app_info.systemLanguage = systemLanguage
+                        app_info.newAppversion = newAppversion
+                        app_info.content = content
+                        app_info.app_type = app_type
+                        app_info.bundleVersion = bundleVersion
+                        app_info.save()
+                        return ResponseJSON(0, {'update_id': app_info.id, 'update_time': str(app_info.update_time)})
+            else:
+                return ResponseJSON(444)
+        else:
+            return ResponseJSON(404)
+
+    def delete(self, request_dict, userID):
+        own_perm = ModelService.check_permission(userID=userID, permID=10)
+        if own_perm is True:
+            id_list = request_dict.getlist('id', None)
+            param_flag = CommonService.get_param_flag(data=[id_list])
+            if param_flag is True:
+                try:
+                    for id in id_list:
+                        App_Info.objects.filter(id=id).delete()
+                except Exception as e:
+                    errorInfo = traceback.format_exc()
+                    print(errorInfo)
+                    return ResponseJSON(424, {'details': repr(e)})
+                else:
+                    return ResponseJSON(0)
+            else:
+                return ResponseJSON(444)
+        else:
+            return ResponseJSON(404)

Controller/BatchProcessingDatabase.py

@@ -0,0 +1,446 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import traceback
+from Ansjer.settings import *
+from django.views.generic.base import View
+from django.views.decorators.csrf import csrf_exempt
+from openpyxl import load_workbook
+from openpyxl.compat import range
+import xlrd
+from Service.ResponseService import *
+from Service.CommonService import CommonService
+from Model.models import Device_Info, Device_User
+
+class batchAddEquipmentView(View):
+    @csrf_exempt
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        fileType = request.POST.get('fileType', None)
+        fileName = request.FILES.get('fileName', None)
+
+        if fileName != None and fileType != None:
+            return self.batchAddEquipment(fileType, fileName)
+        else:
+            return ResponseJSON(800)
+
+    @csrf_exempt
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'gb2312'
+
+        fileType = request.GET.get('fileType', None)
+        fileName = request.FILES.get('fileName', None)
+
+        if fileName != None and fileType != None:
+            return self.batchAddEquipment(fileType, fileName)
+        else:
+            return ResponseJSON(800)
+
+        #return HttpResponse(self.batchAddEquipmentfromTXTDict('D://1.txt'))
+        #return HttpResponse(self.batchAddEquipmentfromExecl2('D:/2.xlsx'))
+
+    def batchAddEquipment(self, fileType, fileName):
+        filename = fileName.name
+        filename = filename.replace(' ', '+')
+
+        try:
+            filePath = '/'.join((BASE_DIR, "static/SysFile", fileType)).replace('\\', '/') + '/'
+
+            if not os.path.exists(filePath):
+                os.makedirs(filePath)
+                fullPath = filePath + filename
+                if os.path.exists(fullPath):
+                    os.remove(fullPath)
+                destination = open(fullPath, 'wb+')
+                for chunk in fileName.chunks():
+                    destination.write(chunk)
+                destination.close()
+            else:
+                fullPath = filePath + filename
+                if os.path.exists(fullPath):
+                    os.remove(fullPath)
+                destination = open(fullPath, 'wb+')
+                for chunk in fileName.chunks():
+                    destination.write(chunk)
+                destination.close()
+        except Exception as e:
+            errorInfo = traceback.format_exc()
+            print('上传文件错误: %s' % errorInfo)
+            return ResponseJSON(700, {
+                'details': repr(e)
+            })
+
+        if fileType == 'TXT':
+            response = HttpResponse(self.batchAddEquipmentfromTXT(fullPath))
+            return response
+        elif fileType == 'Excel':
+            response = HttpResponse(self.batchAddEquipmentfromExecl(fullPath))
+            return response
+
+    def batchAddEquipmentfromExecl(self, filePath):
+        if not os.path.isfile(filePath):
+            return ResponseJSON(701)
+        else:
+            try:
+                xlsData = xlrd.open_workbook(filename = filePath)
+            except Exception as e:
+                errorInfo = traceback.format_exc()
+                print('Open the Excel file error: %s' % errorInfo)
+                return ResponseJSON(702, {
+                    'details': repr(e)
+                })
+            else:
+                sheetsCount = len(xlsData.sheets())
+                table = xlsData.sheets()[0]  # 打开第一张表
+                nrows = table.nrows  # 获取表的行数
+
+                eInfo = []
+                error_list = []
+                error_msg = {}
+                errorCount = addCount = 0
+
+                for index in range(nrows):  # 循环逐行添加
+                    eInfo = table.row_values(index)
+
+                    try:
+                        User = Device_User.objects.filter(userID = eInfo[0])
+                    except Exception as e:
+                        errorCount += 1
+                        errorInfo = traceback.format_exc()
+                        print('error message: %s' % errorInfo)
+
+                        errorDict = {'UID': eInfo[2], 'error_msg': u'error message: {0}'.format(repr(e))}
+                        error_list.append(errorDict)
+
+                        continue
+
+                    if not User:
+                        errorCount += 1
+                        errorDict = {'UID': eInfo[2], 'error_msg': u'error message: The UserID {0} does not exist!'.format(eInfo[0])}
+                        error_list.append(errorDict)
+
+                        continue
+                    try:
+                        tupleInfo = Device_Info.objects.get_or_create(userID_id=eInfo[0],
+                                                                      NickName=eInfo[1],
+                                                                      UID=eInfo[2], SID=eInfo[3],
+                                                                      View_Account=eInfo[4],
+                                                                      View_Password=eInfo[5],
+                                                                      AudioFormat=eInfo[6],
+                                                                      EventNotification=eInfo[7],
+                                                                      ChannelIndex=eInfo[8],
+                                                                      Online=eInfo[9],
+                                                                      mMonitorIndex=eInfo[10],
+                                                                      Type=eInfo[11],
+                                                                      DebugMode=eInfo[12],
+                                                                      NotificationMode=eInfo[13],
+                                                                      qvgaLevel=eInfo[14],
+                                                                      defaults={'id': CommonService.getUserID(getUser=False)})
+                    except Exception as e:
+                        errorCount += 1
+                        errorInfo = traceback.format_exc()
+                        print('error message: %s' % errorInfo)
+
+                        errorDict = {'UID': eInfo[2], 'error_msg': u'error message: {0}'.format(repr(e))}
+                        error_list.append(errorDict)
+
+                        continue
+                    else:
+                        if tupleInfo[1] == True:
+                            addCount += 1
+                        else:
+                            errorCount += 1
+
+                if len(error_list) > 0:
+                    error_msg['error'] = error_list
+
+                xlsData.release_resources()
+                if xlsData:
+                    del xlsData
+
+                resultDict = { "result_code": 0, "reason": u'Success'}
+                if errorCount > 0:
+                    if len(error_msg) > 0:
+                        if sheetsCount > 1:
+                            resultDict.update({
+                                "result": {'appending': addCount, 'errorCount': errorCount, 'error_msg': error_msg,
+                                           'sheetsCount': 'The Execl contains {0} tables!'.format(sheetsCount)},
+                                 "error_code": 704
+                            })
+                        else:
+                            resultDict.update({
+                                "result": {'appending': addCount, 'errorCount': errorCount, 'error_msg': error_msg},
+                                 "error_code": 705
+                            })
+
+                        errorJSON = json.dumps(resultDict, ensure_ascii=False)
+                        return errorJSON
+                    else:
+                        if sheetsCount > 1:
+                            resultDict.update({
+                                "result": {'appending': addCount, 'appended': errorCount,
+                                    'sheetsCount': 'The Execl contains {0} tables!'.format(sheetsCount)},
+                                "error_code": 704,
+                            })
+                        else:
+                            resultDict.update({
+                                "result": {'appending': addCount, 'appended': errorCount},
+                                "error_code": 705,
+                            })
+
+                        errorJSON = json.dumps(resultDict, ensure_ascii=False)
+                        return errorJSON
+                else:
+                    if sheetsCount > 1:
+                        resultDict.update({
+                            "result": {'appending': addCount,
+                                       'sheetsCount': 'The Execl contains {0} tables!'.format(sheetsCount)},
+                            "error_code": 704,
+                        })
+                    else:
+                        resultDict.update({
+                            "result": {'appending': addCount},
+                            "error_code": 0,
+                        })
+                    JSON = json.dumps(resultDict, ensure_ascii=False)
+                    return JSON
+
+    def batchAddEquipmentfromExecl2(self, filePath):
+        '''
+
+        :param filePath:
+        :return:
+        :remarks: 不支持旧版xls
+        '''
+        #filePath = 'D:/2.xlsx'
+        try:
+            wb = load_workbook(filename = filePath)
+            ws = wb.get_sheet_names()
+            ws = wb.get_sheet_by_name(ws[0])
+            rows = ws.iter_rows()
+            #cols = ws.iter_cols()
+            #rows = ws.rows  # 行数
+            #columns = ws.columns  # 列数
+        except Exception as e:
+            errorInfo = traceback.format_exc()
+            print('error message: %s' % errorInfo)
+            return ResponseFormal(702,repr(e))
+        error_list = []
+        error_msg = {}
+        equipmentlists = []
+        errorCount = addCount = 0
+        for row in rows:
+            eInfo = []
+            for cell in row:
+                #print(cell.coordinate, cell.value)
+                if cell.value == None:
+                    cell.value = ''
+                eInfo.append(cell.value)
+
+            try:
+                User = Device_User.objects.filter(userID = eInfo[0])
+            except Exception as e:
+                errorCount += 1
+                errorInfo = traceback.format_exc()
+                print('error message: %s' % errorInfo)
+
+                errorDict = {'UID': eInfo[2], 'error_msg': u'error message: {0}'.format(repr(e))}
+                error_list.append(errorDict)
+
+                continue
+
+            if not User:
+                errorCount += 1
+                errorDict = {'UID': eInfo[2],
+                             'error_msg': u'error message: The UserID {0} does not exist!'.format(eInfo[0])}
+                error_list.append(errorDict)
+                continue
+
+            eqValid = Device_Info.objects.filter(userID_id = eInfo[0], UID=eInfo[2])
+            if eqValid:
+                errorCount += 1
+                errorDict = {'UID': eInfo[2], 'error_msg': u'The UID has already existed!'}
+                error_list.append(errorDict)
+                continue
+
+            equipment = Device_Info(id=CommonService.getUserID(getUser=False), userID_id=eInfo[0],
+                                    NickName=eInfo[1], UID=eInfo[2], SID=eInfo[3],
+                                    View_Account=eInfo[4], View_Password=eInfo[5],
+                                    AudioFormat=eInfo[6], EventNotification=eInfo[7],
+                                    ChannelIndex=eInfo[8], Online=eInfo[9], mMonitorIndex=eInfo[10],
+                                    Type=eInfo[11], DebugMode=eInfo[12], NotificationMode=eInfo[13],
+                                    qvgaLevel=eInfo[14], )
+            equipmentlists.append(equipment)
+
+        try:
+            elists = Device_Info.objects.bulk_create(equipmentlists)
+        except Exception as e:
+            errorCount += 1
+            errorInfo = traceback.format_exc()
+            print('error message: %s' % errorInfo)
+
+            errorDict = {'UID': eInfo[2], 'error_msg': u'error message: {0}'.format(repr(e))}
+            error_list.append(errorDict)
+        else:
+            if len(equipmentlists) != len(elists):
+                addCount += len(elists)
+                errorCount += (len(equipmentlists) - len(elists))
+            else:
+                addCount += len(elists)
+
+        if len(error_list) > 0:
+            error_msg['error'] = error_list
+
+        if errorCount == 0:
+            return ResponseFormal(0, {
+                'appending': addCount
+            })
+        else:
+            return ResponseFormal(0, {
+                'appending': addCount,
+                'errorCount': errorCount,
+                'error_msg': error_msg,
+            })
+
+    def batchAddEquipmentfromTXT(self, filePath):
+        '''
+        txt文件批量导入数据库，通过list方式
+        :param filePath:
+        :return:
+        '''
+        if os.path.isfile(filePath):
+            file = open(filePath, encoding='utf-8')
+            eInfo = []
+            error_list = []
+            error_msg = errorDict = {}
+            errorCount = addCount = 0
+
+            for line in file:
+                eInfo = line.split(';')
+                for index in range(len(eInfo)):
+                    if index > 5:
+                        eInfo[index] = int(eInfo[index])
+                    else:
+                        continue
+
+                dUser = Device_User.objects.filter(userID = eInfo[0])
+                if not dUser:
+                    errorCount += 1
+                    errorDict = {"userID": eInfo[0], "error_msg'": u"The userID_id is no exist!"}
+                    error_list.append(errorDict)
+
+                    continue
+
+                try:
+                    tupleInfo = Device_Info.objects.get_or_create(userID_id=eInfo[0], NickName=eInfo[1],
+                                                      UID=eInfo[2], SID=eInfo[3], View_Account=eInfo[4],
+                                                      View_Password=eInfo[5], AudioFormat=eInfo[6],
+                                                      EventNotification=eInfo[7], ChannelIndex=eInfo[8],
+                                                      Online=eInfo[9], mMonitorIndex=eInfo[10],
+                                                      Type=eInfo[11], DebugMode=eInfo[12],
+                                                      NotificationMode=eInfo[13], qvgaLevel=eInfo[14],
+                                                      defaults={'id': CommonService.getUserID(getUser=False)})
+                except Exception as e:
+                    errorCount += 1
+                    errorInfo = traceback.format_exc()
+                    print('error message: %s' % errorInfo)
+
+                    errorDict = {'UID': eInfo[2], 'error_msg': u'error message: {0}'.format(repr(e))}
+                    error_list.append(errorDict)
+
+                    continue
+                else:
+                    if tupleInfo[1] == True:
+                        addCount += 1
+                    else:
+                        errorDict = {'UID': eInfo[2], 'error_msg': u'The UID is existed!'}
+                        error_list.append(errorDict)
+                        errorCount += 1
+
+            file.close()
+
+            if len(error_list) > 0:
+                error_msg['error'] = error_list
+
+            if errorCount > 0:
+                if len(error_msg) > 0:
+                    return ResponseFormal(0, {
+                        'appending': addCount,
+                        'errorCount': errorCount,
+                        'error_msg': error_msg,
+                    })
+                else:
+                    return ResponseFormal(0, {'appending': addCount,'appended': errorCount,})
+            else:
+                return ResponseFormal(0,{'appending': addCount})
+        else:
+            return ResponseFormal(701)
+
+    def batchAddEquipmentfromTXTDict(self, filePath):
+        if os.path.isfile(filePath):
+            file = open(filePath, encoding='utf-8')
+
+            error_list = []
+            error_msg = {}
+            errorCount = addCount = 0
+            equipmentList = []
+            equipmentDict = {}
+
+            try:
+                for line in file:
+                    equipmentStr = eval(line)
+                    if isinstance(eval(equipmentStr), dict):
+                        equipmentDict.update(eval(equipmentStr))
+                    else:
+                        return ResponseFormal(706)
+                    UID = equipmentDict.get('UID', None)
+                    userID_id = equipmentDict.get('userID_id', None)
+
+                    dUser = Device_User.objects.filter(userID = userID_id)
+                    if dUser:
+                        if UID != None and userID_id != None:
+                            dInfo = Device_Info.objects.filter(userID_id = userID_id, UID = UID)
+                            if dInfo:
+                                errorCount += 1
+                                continue
+                            else:
+                                equipment = Device_Info(id = CommonService.getUserID(getUser=False), **equipmentDict)
+                                equipmentList.append(equipment)
+                        else:
+                            errorCount += 1
+                            errorDict = {'userID_id': userID_id, 'error_msg': u'The userID_id is None or UID is None!'}
+                            error_list.append(errorDict)
+
+                            continue
+
+                    else:
+                        errorCount += 1
+                        errorDict = {'userID_id': userID_id, 'error_msg': u'The userID_id is no exist!'}
+                        error_list.append(errorDict)
+
+                        continue
+
+                file.close()
+                sss = Device_Info.objects.bulk_create(equipmentList)
+                print(type(sss), sss)
+
+            except Exception as e:
+                errorInfo = traceback.format_exc()
+                print('The error Info: %s' % errorInfo)
+                return ResponseFormal(707,{'details':repr(e)})
+            else:
+                if len(error_list) > 0:
+                    error_msg['error'] = error_list
+
+                if errorCount > 0:
+                    if error_msg != None:
+                        return ResponseFormal(0, {'errorCount': errorCount,
+                                    'error': error_msg,
+                                    'appending': len(equipmentList)})
+                    else:
+                        return ResponseFormal(0, { 'errorCount': errorCount,
+                                    'appending': len(equipmentList)})
+                else:
+                    return ResponseFormal(0,{'appending':len(equipmentList)})
+        else:
+            return ResponseFormal(701)

Controller/CheckUserData.py

@@ -0,0 +1,410 @@
+# -*- coding: utf-8 -*-
+
+from random import Random # 用于生成随机码
+from wsgiref.util import FileWrapper
+from django.utils.timezone import utc
+from django.views.decorators.csrf import csrf_exempt
+from django.views.generic import TemplateView, View
+from django.utils.decorators import method_decorator
+from django.contrib.auth.hashers import make_password
+from django.shortcuts import HttpResponseRedirect
+from itsdangerous import URLSafeTimedSerializer as utsr # itsdangerous序列化
+import re, base64, json, traceback, random, string
+from qcloudsms_py.httpclient import HTTPError
+from qcloudsms_py import SmsSingleSender
+from qcloudsms_py import SmsVoiceVerifyCodeSender, SmsVoicePromptSender
+from Ansjer.settings import *
+from Model.models import Email_Captcha, Device_User, Auth_Captcha
+from Service.ResponseService import *
+
+#生成随机字符串
+def RandomStr(randomlength = 8, number = False):
+    str = ''
+    if number == False:
+        characterSet = 'AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsT' \
+                   'tUuVvWwXxYyZz0123456789'
+    else:
+        characterSet = '0123456789'
+
+    length = len(characterSet) - 1
+
+    random = Random()
+    for index in range(randomlength):
+        str += characterSet[random.randint(0, length)]
+
+    return str
+
+def Active_User(request, token):
+    tokenConfirm = TokenLink(SECRET_KEY)
+    try:
+        username = tokenConfirm.confirm_validate_token(token)
+    except:
+        return ResponseJSON(1000)
+    try:
+        UserValid = Device_User.objects.get(userName=username)
+    except Device_User.DoesNotExist:
+        return ResponseJSON(113)
+    UserValid = Device_User.objects.get(username=username)
+    UserValid.is_active = True
+    UserValid.user_isValid = True
+    UserValid.save()
+    return ResponseJSON(0)
+
+class MobiletoResetPwdView(TemplateView):
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(MobiletoResetPwdView, self).dispatch(*args, **kwargs)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'gb2312'
+
+        userName = request.POST.get('userName', None)
+        authCode = request.POST.get('identifyingCode', None)
+        newPwd = request.POST.get('newPwd', None)
+
+        return self.ValidationError(userName, newPwd, authCode)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        userName = request.GET.get('userName', None)
+        authCode = request.GET.get('identifyingCode', None)
+        newPwd = request.GET.get('newPwd', None)
+
+        return self.ValidationError(userName, newPwd, authCode)
+
+    def ValidationError(self, userName, newPwd, authCode):
+        if userName != None and authCode != None and newPwd != None:
+            return self.MobiletoResetPwd(userName, authCode, newPwd)
+        else:
+            return ResponseJSON(800)
+    def MobiletoResetPwd(self, userName, authCode, newPwd):
+        UserValid = Device_User.objects.filter(username = userName).order_by('-data_joined')
+        if UserValid:
+            Users = Auth_Captcha.objects.filter(username = userName).order_by('-sendtime')
+
+            if Users:
+                for User in Users:
+                    if User.authcaptca == authCode and User.sendtype == 'forget':
+                        now_time = datetime.datetime.utcnow().replace(tzinfo=utc).astimezone(utc)
+                        timeValid = (now_time - User.sendtime).total_seconds()
+
+                        if timeValid < 300:
+                            is_flag = UserValid.update(password=make_password(newPwd))
+                            if is_flag:
+                                return ResponseJSON(0)
+                            else:
+                                return ResponseJSON(405)
+                        else:
+                            return ResponseJSON(120)
+        else:
+            return ResponseJSON(102)
+
+def date_handler(obj):
+    return  obj.isoformat()
+
+class ActiveUserView(View):
+    """账户激活的View"""
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(ActiveUserView, self).dispatch(*args, **kwargs)
+
+    def get(self, request, active_code):
+        # 用code在数据库中过滤处信息
+        all_records = Email_Captcha.objects.filter(userCaptcha = active_code)
+        if all_records:
+            for record in all_records:
+                # 通过邮箱查找到对应的用户
+                userEmail = record.userEmail
+                user = Device_User.objects.get(userEmail = userEmail)
+                Device_User.objects.filter(userEmail = userEmail).update(user_isValid=True, is_active = True)
+
+        response = HttpResponseRedirect('/login/')
+        return response
+
+class TokenLink:
+    '''
+    1. security_key就是settings.py中设置的SECRET_KEY
+    2. generate_validate_token函数通过URLSafeTimedSerializer
+    在用户注册时生成一个令牌。用户名在令牌中被编了码。生成令牌之后，
+    会将带有token的验证链接发送到注册邮箱。
+    3.在confirm_validate_token函数中，只要令牌没过期，
+    那它就会返回一个用户名，过期时间为3600秒
+    '''
+    def __init__(self, security_key):
+        self.security_key = security_key
+        self.salt = base64.encodestring(security_key.encode())
+
+    def generate_validate_token(self, token):
+        serializer = utsr(self.security_key)
+        return serializer.dumps(token, self.salt)
+
+    def confirm_validate_token(self, token, expiration=3600):
+        serializer = utsr(self.security_key)
+        return serializer.loads(token, salt=self.salt, max_age=expiration)
+
+    def remove_validate_token(self, token):
+        serializer = utsr(self.security_key)
+        return serializer.loads(token, salt=self.salt)
+
+
+class getRandom:
+    def __init__(self):
+        self.__seed = '1234567890abcdefghijklmnopqrstuvwxyzABCDEFGH' \
+               'IJKLMNOPQRSTUVWXYZ!@#$%^&*()_+=-'
+    def getSalt (self, strlen = 8):
+        sa = []
+        for index in range (strlen):
+            sa.append(random.choice(self.__seed))
+        salt = ''.join(sa)
+        return salt
+    def getSaltStr(self, strlen = 8):
+        salt = ''.join(random.sample(string.ascii_letters + string.digits, strlen))
+        return salt
+
+class ModifyPwdView(TemplateView):
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(ModifyPwdView, self).dispatch(*args, **kwargs)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        userEmail = request.POST.get('userEmail', None)
+        oldPwd = request.POST.get('oldPwd', None)
+        newPwd = request.POST.get('newPwd', None)
+
+        return self.ValidationError(userEmail, oldPwd, newPwd)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'gb2312'
+        userEmail = request.GET.get('userEmail', None)
+        oldPwd = request.GET.get('oldPwd', None)
+        newPwd = request.GET.get('newPwd', None)
+
+        return self.ValidationError(userEmail, oldPwd, newPwd)
+
+    def ValidationError(self, userEmail, oldPwd, newPwd):
+        dataValid = DataValid()
+        if dataValid.password_validate(newPwd):
+            if oldPwd != newPwd:
+                return ResponseJSON(118)
+            try:
+                User = Device_User.objects.get(userEmail = userEmail)
+                User.userPwd = make_password(newPwd)
+                User.save()
+            except Exception as e:
+                errorInfo = traceback.format_exc()
+                print('更新密码到数据库: %s' % errorInfo)
+                return ResponseJSON(501,{'msg':repr(e)})
+            else:
+                return ResponseJSON(0)
+        else:
+            return ResponseJSON(109)
+
+class DataValid:
+
+    def __init__(self):
+        # 用户名正则
+        # self.re_name = re.compile(r'^[A-Za-z0-9\u4e00-\u9fa5\.\_]{1,16}$')
+        self.re_name = re.compile(r'^[A-Za-z0-9\u4e00-\u9fa5\.\_\-\@]{4,40}$')
+        # 密码强度正则
+        self.re_password = re.compile(r'^\w{1,16}$')
+        # 手机号码正则
+        self.re_mobile = re.compile(r'^\d{1,16}$')
+        # 邮箱地址正则
+        self.re_email = re.compile(r'^[A-Za-z0-9\u4e00-\u9fa5\.\_\-]+@[A-Za-z0-9_-]+(\.[A-Za-z0-9_-]+)+$')
+
+    def name_validate(self, value):
+        if self.re_name.match(value):
+            return True
+        else:
+            return False
+
+    def password_validate(self, value):
+        if self.re_password.match(value):
+            return True
+        else:
+            return False
+
+    def email_validate(self, value):
+        if self.re_email.match(value):
+            return True
+        else:
+            return False
+
+    def mobile_validate(self, value):
+        if self.re_mobile.match(value):
+            return True
+        else:
+            return False
+
+def sms(phoneNumbers, sendModel, msg, sendType = 'register', template_id = 7839):
+    appid = SDK_AppID
+    appkey = App_Key
+
+    print(phoneNumbers, msg, sendModel, template_id)
+    ssender = SmsSingleSender(appid, appkey)
+    try:
+        if sendType == 'register':
+            result = ssender.send(0, "86", phoneNumbers, u"{authCode}为您的注册验证码，请于2分钟内填写。"
+                                               u"如非本人操作，请忽略本短信。".format(authCode=msg), "", "")
+        elif sendType == 'forget':
+            result = ssender.send(0, "86", phoneNumbers, u"{userPwd}为您的账号新密码,请登录账号后,修改为"
+                                                                u"用户自定义密码.".format(userPwd=msg), "", "")
+    except HTTPError as e:
+        errorInfo = traceback.format_exc()
+        print('发送手机验证码出现网络错误: %s' % errorInfo)
+        return ResponseFormal(1022,{'msg':repr(e)})
+
+    except Exception as e:
+        errorInfo = traceback.format_exc()
+        print('发送手机短信验证码错误: %s' % errorInfo)
+        return ResponseFormal(1021)
+    else:
+        resultCode = result.get('result', None)
+        if resultCode == 0:
+            JSON = json.dumps(result, ensure_ascii=False)
+            return JSON
+        else:
+            errorJSON = json.dumps(result, ensure_ascii=False)
+            return errorJSON
+
+class QCloudSms(object):
+    def __init__(self, nationcode, msg, template_id):
+        self.appid = SDK_AppID
+        self.appkey = App_Key
+        self.msg = msg # 验证码msg
+        self.nationcode = nationcode # 国家码
+        self.template_id = template_id # 模板ID
+
+    def sms(self, mobiles, model, type = 'register'):
+        ssender = SmsSingleSender(self.appid, self.appkey)
+        try:
+            if type == 'register':
+                result = ssender.send(0, "86", mobiles, u"{authCode}为您的注册验证码，请于2分钟内填写。"
+                                                             u"如非本人操作，请忽略本短信。".format(authCode= self.msg), "", "")
+            elif type == 'forget':
+                result = ssender.send(0, "86", mobiles, u"{userPwd}为您的账号新密码,请登录账号后,修改为"
+                                                             u"用户自定义密码.".format(userPwd = self.msg), "", "")
+        except HTTPError as e:
+            errorInfo = traceback.format_exc()
+            print('发送手机短信验证码出现网络错误: %s' % errorInfo)
+            return ResponseFormal(1022,repr(e))
+        except Exception as e:
+            errorInfo = traceback.format_exc()
+            print('发送手机验证码错误: %s' % errorInfo)
+            return ResponseFormal(1021,repr(e))
+        else:
+            resultCode = result.get('result', None)
+            if resultCode == 0:
+                JSON = json.dumps(result, ensure_ascii=False)
+                return JSON
+            else:
+                errorJSON = json.dumps(result, ensure_ascii=False)
+                return errorJSON
+
+    def voice(self, mobiles, model, type = 'register'):
+        # 语音验证码请求
+        vvcsender = SmsVoiceVerifyCodeSender(appid = self.appid, appkey = self.appkey)
+        try:
+            result = vvcsender.send(nation_code=self.nationcode, phone_number = \
+                mobiles, playtimes = 2, msg = self.msg, ext = '')
+        except HTTPError as e:
+            errorInfo = traceback.format_exc()
+            print('发送手机验证码出现网络错误: %s' % errorInfo)
+            return ResponseFormal(1022,repr(e))
+        except Exception as e:
+            errorInfo = traceback.format_exc()
+            print('发送手机语音验证码错误: %s' % errorInfo)
+            return ResponseFormal(1023,repr(e))
+        else:
+            resultCode = result.get('result', None)
+            if resultCode == 0:
+                JSON = json.dumps(result, ensure_ascii=False)
+                return JSON
+            else:
+                errorJSON = json.dumps(result, ensure_ascii=False)
+                return errorJSON
+
+        # 发送语音通知
+        vpsender = SmsVoicePromptSender(appid=self.appid, appkey=self.appkey)
+        # note: msg内容，首先需要申请内容模板，通过后才可以发送
+        try:
+            result = vpsender.send(nation_code=self.nationcode, phone_number = \
+                mobiles, playtimes = 2, msg = self.msg, ext= '')
+        except HTTPError as e:
+            errorInfo = traceback.format_exc()
+            print('发送手机验证码出现网络错误: %s' % errorInfo)
+            return ResponseFormal(1022,repr(e))
+        except Exception as e:
+            errorInfo = traceback.format_exc()
+            print('发送手机语音验证码错误: %s' % errorInfo)
+            return ResponseFormal(1023,repr(e))
+        else:
+            resultCode = result.get('result', None)
+            if resultCode == 0:
+                JSON = json.dumps(result, ensure_ascii=False)
+                return JSON
+            else:
+                errorJSON = json.dumps(result, ensure_ascii=False)
+                return errorJSON
+
+def upload_file(request):
+    """
+    文件接收
+    :param request: 请求
+    :return:
+    """
+    if request.method == "POST":    # 请求方法为POST时，进行处理
+        upFile =request.FILES.get("upfile", None)    # 获取上传的文件，如果没有文件，则默认为None
+        if not upFile:
+            return HttpResponse("no files for upload!")
+
+        else:
+            upgradePath = os.path.join(MEDIA_URL, '/Upgrade/IPC/')
+            destination = open(os.path.join(upgradePath, upFile.name), 'wb+')    # 打开特定的文件进行二进制的写操作
+            for chunk in upFile.chunks():      # 分块写入文件
+                destination.write(chunk)
+            destination.close()
+            return HttpResponse("upload over!")
+
+@csrf_exempt
+def download_file(request, Upgradename, *callback_args, **callback_kwargs):
+    """
+    下载单个文件
+    :param request:
+    :param Upgradename:
+    :param callback_args:
+    :param callback_kwargs:
+    :return:
+    """
+    print(Upgradename)
+    print(callback_args, callback_kwargs)
+    for value in callback_args:
+        print("other args:", value)
+    # 打印dict类型的不定长参数 args
+    for key in callback_kwargs:
+        print("dictargs:" + key + ":" + bytes(callback_kwargs[key]))
+    #received_json_data = json.loads(request.body)
+    print(request.body)
+    file_name = os.path.join(BASE_DIR, "static/Upgrade/DVR/").replace('\\', '/') + Upgradename
+
+    if os.path.isfile(file_name):
+        try:
+            print(file_name)
+            JSON = ResponseFormal(0)
+            wrapper = FileWrapper(open(file_name, 'rb'))
+            response = HttpResponse(wrapper, content_type="application/octet-stream")
+            response['Content-Length'] = os.path.getsize(file_name)
+            response['Content-Disposition'] = 'attachment; filename=%s' % os.path.basename(file_name)
+            response['Content-Error'] = JSON
+            return response
+        except Exception as e:
+            errorJSON = ResponseFormal(10,'Wrong reason:' + repr(e))
+            response = HttpResponse(errorJSON, content_type='text/plain', charset='utf-8')
+            response['Content-Error'] = errorJSON
+            return response
+    else:
+        errorJSON = ResponseFormal(907)
+        response = HttpResponse(errorJSON, content_type='text/plain', charset='utf-8')
+        response['Content-Error'] = errorJSON
+        return response

Controller/DeviceLog.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3  
+# -*- coding: utf-8 -*-  
+"""
+@Copyright (C) ansjer cop Video Technology Co.,Ltd.All rights reserved.
+@AUTHOR: ASJRD018
+@NAME: Ansjer
+@software: PyCharm
+@DATE: 2018/6/15 16:47
+@Version: python3.6
+@MODIFY DECORD:ansjer dev
+@file: DeviceLog.py
+@Contact: chanjunkai@163.com
+"""
+import datetime
+from django.views.decorators.csrf import csrf_exempt
+from Model.models import Device_Info
+from Object.mongodb import mongodb
+from Service.TokenManager import JSONTokenManager
+from Service.CommonService import CommonService
+from Service.ModelService import ModelService
+from Service.DeviceOperation import DeviceOperation
+from Service.ResponseService import *
+'''
+curl http://192.168.136.45:8077/devices/C2887N9EBS87ZAT1111A/logs -d "deviceData={\"UID\":\"C2887N9EBS87ZAT1111A\",\"type\":\"0x10014\",\"UserIP\":\"127.0.0.1\",\"time\":1529474865,\"name\":\"admin\"}"
+http://192.168.136.40:8077/devices/2N1K3LE78TYJ38CE111A/logs?type=All&starttime=1529462169&endtime=1529462169
+'''
+
+
+@csrf_exempt
+def DeviceLog(request, uid):
+    # 存储设备日志
+    if request.method == 'POST':
+        request.encoding = 'utf-8'
+        deviceData = request.POST.get('deviceData', None)
+        device_info = Device_Info.objects.filter(UID=uid)
+        if device_info.exists():
+            try:
+                data = json.loads(deviceData)
+                mdb = mongodb()
+                data['et'] = datetime.datetime.utcnow()
+                col = "log_device_operation"
+                id = mdb.insert_one(col=col, data=data)
+                return ResponseJSON(0)
+                # qs = mdb.findAll(col=col, page=1, line=10)
+            except Exception as e:
+                print(repr(e))
+                return ResponseJSON(48,repr(e))
+        else:
+            return ResponseJSON(13)
+    # 查找设备日志
+    if request.method == 'GET':
+        request.encoding = 'utf-8'
+        token = request.GET.get('token', None)
+        page = request.GET.get('page', None)
+        line = request.GET.get('line', None)
+        type = request.GET.get('type', None)
+        search_class = request.GET.get('class', None)
+        starttime = request.GET.get('starttime', None)
+        endtime = request.GET.get('endtime', None)
+        if token is not None:
+            tokenManager = JSONTokenManager()
+            error_code = tokenManager.verify_AToken(token)
+            if error_code == 0:
+                userID = tokenManager.accessDict.get('userID', None)
+                if page is None and line is None:
+                    page = 1
+                    line = 10000
+                param_flag = CommonService.get_param_flag(data=[userID, page, line, uid])
+                own_dev = ModelService.check_own_device(userID=userID, UID=uid)
+                own_per = ModelService.check_permission(userID=userID, permID=30)
+                if own_dev is True or own_per is True:
+                    if param_flag is True:
+                        query = {'uid': uid}
+                        if search_class == 'All' or type == 'All':
+                            pass
+                        else:
+                            try:
+                                class_data= DeviceOperation.getODla(search_class=search_class)
+                                query['type'] = {'$gte': class_data[0], '$lte': class_data[1]}
+                            except Exception as e:
+                                if type is not None:
+                                    query['type'] = type
+                        # if starttime is not None and endtime is not None and starttime != '' and endtime != '':
+                        #     query['time'] = {'$gte': int(starttime), '$lte': int(endtime)}
+                        if starttime is not None and starttime != '' and endtime is not None and endtime != '':
+                            query['time'] = {'$gte': int(starttime), '$lte': int(endtime)}
+                        elif starttime is not None and starttime != '':
+                            query['time'] = {'$gte': int(starttime)}
+                        elif endtime is not None and endtime != '':
+                            query['time'] = {'$lte': int(endtime)}
+                        print('___________query____________')
+                        print(query)
+                        print('___________query____________')
+                        mdb = mongodb()
+                        col = "log_device_operation"
+                        # if int(page) < 0:
+                        #     count = mdb.cout(col=col,query=query)
+                        #     total = math.ceil(count/int(line))
+                        #     page = int(total)+int(page)+1
+                        qs = mdb.findAll(col=col, page=int(page), line=int(line), query=query)
+                        if qs is not False:
+                            data_list = []
+                            for i in qs['data']:
+                                i['type'] = DeviceOperation.getOperation(type=i['type'])
+                                data_list.append(i)
+                            qs['data'] = data_list
+                        return ResponseJSON(0,qs)
+                else:
+                    return ResponseJSON(404)
+                return ResponseJSON(444)
+            else:
+                return HttpResponse(tokenManager.errorCodeInfo(error_code))
+        else:
+            return ResponseJSON(311)

Controller/DeviceManage.py

@@ -0,0 +1,176 @@
+#!/usr/bin/env python3  
+# -*- coding: utf-8 -*-  
+"""
+@Copyright (C) ansjer cop Video Technology Co.,Ltd.All rights reserved.
+@AUTHOR: ASJRD018
+@NAME: Ansjer
+@software: PyCharm
+@DATE: 2018/6/1 10:20
+@Version: python3.6
+@MODIFY DECORD:ansjer dev
+@file: DeviceManage.py
+@Contact: chanjunkai@163.com
+"""
+from django.shortcuts import HttpResponse
+from django.views.generic.base import View
+from django.utils.decorators import method_decorator
+from django.views.decorators.csrf import csrf_exempt
+from Service.ResponseService import *
+from Service.TokenManager import JSONTokenManager
+from Service.ModelService import ModelService
+from Service.CommonService import CommonService
+from Model.models import Device_Info
+import traceback,datetime
+from django.utils import timezone
+'''
+http://192.168.136.40:8077/device/manage?operation=query&token=test&page=1&line=10
+http://192.168.136.40:8077/device/manage?operation=delete&id=1&id=2
+http://192.168.136.45:8077/device/manage?operation=findByUser&token=test&username=13800138001&page=1&line=10
+-----------------------
+
+'''
+
+
+class DeviceManage(View):
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(DeviceManage, self).dispatch(*args, **kwargs)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        return self.validation(request_dict=request.GET)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        return self.validation(request_dict=request.POST)
+
+    def validation(self, request_dict, *args, **kwargs):
+        operation = request_dict.get('operation', None)
+        if operation is not None:
+            token = request_dict.get('token', None)
+            if token is not None:
+                tokenManager = JSONTokenManager()
+                error_code = tokenManager.verify_AToken(token)
+                if error_code == 0:
+                    userID = tokenManager.accessDict.get('userID', None)
+                    if userID is not None:
+                        if operation == 'query':
+                            return self.query(request_dict=request_dict, userID=userID)
+                        elif operation == 'findByUser':
+                            return self.findByUser(request_dict=request_dict, userID=userID)
+                        elif operation == 'delete':
+                            return self.delete(request_dict=request_dict, userID=userID)
+                    return ResponseJSON(444)
+                else:
+                    return HttpResponse(tokenManager.errorCodeInfo(error_code))
+            else:
+                return ResponseJSON(311)
+        else:
+            return ResponseJSON(444)
+
+    def query(self, request_dict, userID):
+        own_perm = ModelService.check_permission(userID=userID, permID=30)
+        if own_perm is True:
+            page = int(request_dict.get('page', None))
+            line = int(request_dict.get('line', None))
+            param_flag = CommonService.get_param_flag(data=[page, line])
+            if param_flag is True:
+                queryset = Device_Info.objects.all()
+                if queryset.exists():
+                    count = queryset.count()
+                    res = queryset[(page - 1) * line:page * line]
+                    send_dict = CommonService.query_set_to_dict(res)
+                    for k, v in enumerate(send_dict["datas"]):
+                        for val in res:
+                            if v['pk'] == val.id:
+                                if send_dict["datas"][k]['fields']['Online'] is True:
+                                    dl_time = val.update_time+datetime.timedelta(minutes=60)
+                                    now_time = timezone.localtime(timezone.now())
+                                    if now_time > dl_time:
+                                        pass
+                                        # send_dict["datas"][k]['fields']['Online'] = False
+                                username= ModelService.get_user_name(send_dict["datas"][k]['fields']['userID'])
+                                send_dict["datas"][k]['fields']['username']=username
+                                primary= ModelService.get_user_name(send_dict["datas"][k]['fields']['primaryUserID'])
+                                send_dict["datas"][k]['fields']['primaryusername']=primary
+                    send_dict['count'] = count
+                    return ResponseJSON(0, send_dict)
+                return ResponseJSON(0,{'count':0})
+            else:
+                return ResponseJSON(444)
+        else:
+            return ResponseJSON(404)
+
+    def delete(self, request_dict, userID):
+        own_perm = ModelService.check_permission(userID=userID, permID=10)
+        if own_perm is True:
+            id_list = request_dict.getlist('id', None)
+            param_flag = CommonService.get_param_flag(data=[id_list])
+            if param_flag is True:
+                try:
+                    for id in id_list:
+                        Device_Info.objects.filter(id=id).delete()
+                except Exception as e:
+                    errorInfo = traceback.format_exc()
+                    print(errorInfo)
+                    return ResponseJSON(424, {'details': repr(e)})
+                else:
+                    return ResponseJSON(0)
+            else:
+                return ResponseJSON(444)
+        else:
+            return ResponseJSON(404)
+
+    def findByUser(self, request_dict, userID):
+        own_perm = ModelService.check_permission(userID=userID, permID=30)
+        if own_perm is True:
+            page = int(request_dict.get('page', None))
+            line = int(request_dict.get('line', None))
+            username = request_dict.get('username', None)
+            param_flag = CommonService.get_param_flag(data=[page, line, username])
+            if param_flag is True:
+                userID_id= ModelService.get_userID_byname(username=username)
+                print(userID_id)
+                queryset = Device_Info.objects.filter(userID_id=userID_id)
+                if queryset.exists():
+                    count = queryset.count()
+                    res = queryset[(page - 1) * line:page * line]
+                    send_dict = CommonService.query_set_to_dict(res)
+                    for k, v in enumerate(send_dict["datas"]):
+                        for val in res:
+                            if v['pk'] == val.id:
+                                if send_dict["datas"][k]['fields']['Online'] is True:
+                                    dl_time = val.update_time + datetime.timedelta(minutes=1)
+                                    now_time = timezone.localtime(timezone.now())
+                                    if now_time > dl_time:
+                                        send_dict["datas"][k]['fields']['Online'] = False
+                                send_dict["datas"][k]['fields']['username']=username
+                                primary= ModelService.get_user_name(send_dict["datas"][k]['fields']['primaryUserID'])
+                                send_dict["datas"][k]['fields']['primaryusername']=primary
+                    send_dict['count'] = count
+                    return ResponseJSON(0, send_dict)
+                return ResponseJSON(0,{'count':0})
+            else:
+                return ResponseJSON(444)
+        else:
+            return ResponseJSON(404)
+
+
+@csrf_exempt
+def Devices(request, UID):
+    # 获取指定用户指定设备详细信息
+    if request.method == 'GET':
+        request.encoding = 'utf-8'
+        token = request.GET.get('token', None)
+        if token is not None:
+            tokenManager = JSONTokenManager()
+            error_code = tokenManager.verify_AToken(token)
+            if error_code == 0:
+                userID = tokenManager.accessDict.get('userID', None)
+                res = Device_Info.objects.filter(userID_id=userID,UID=UID)
+                send_dict = CommonService.query_set_to_dict(res)
+                return ResponseJSON(0, send_dict)
+            else:
+                return HttpResponse(tokenManager.errorCodeInfo(error_code))
+        else:
+            return ResponseJSON(311)

Controller/DeviceMeal.py

@@ -0,0 +1,340 @@
+#!/usr/bin/env python3  
+# -*- coding: utf-8 -*-  
+"""
+@Copyright (C) ansjer cop Video Technology Co.,Ltd.All rights reserved.
+@AUTHOR: ASJRD018
+@NAME: Ansjer
+@software: PyCharm
+@DATE: 2018/5/30 14:13
+@Version: python3.6
+@MODIFY DECORD:ansjer dev
+@file: DeviceMeal.py
+@Contact: chanjunkai@163.com
+"""
+from django.views.generic.base import View
+from django.utils.decorators import method_decorator
+from django.views.decorators.csrf import csrf_exempt
+from Service.TokenManager import JSONTokenManager
+from Service.ModelService import ModelService
+from Service.CommonService import CommonService
+from Model.models import Device_Meal, Store_Meal
+import traceback, datetime
+from django.utils import timezone
+from Service.ResponseService import *
+
+'''
+http://192.168.136.40:8077/device/meal?operation=add&token=test&uid=UKPAH63V23U4ZHEB111A&channel=1&rank=2&days=1
+http://192.168.136.40:8077/device/meal?operation=query&token=test&page=1&line=10
+http://192.168.136.40:8077/device/meal?operation=delete&token=test&id=1&id=2&id=3&id=4&id=5
+http://192.168.136.45:8077/device/meal?operation=update&token=test&status=1&uid=UKPAH63V23U4ZHEB111A&channel=2&rank=2&days=1&id=6
+用户:
+http://13.56.215.252:82/device/meal?operation=querybyuser&token=test&uid=L59KVYDAEPHR1T6M111A&channel=0
+http://13.56.215.252:82/device/meal?operation=addbyuser&token=test&uid=L59KVYDAEPHR1T6M111A&channel=11&rank=2
+http://13.56.215.252:82/device/meal?operation=updatebyuser&token=test&status=1&uid=L59KVYDAEPHR1T6M111A&channel=0&rank=2
+http://13.56.215.252:82/device/meal?operation=updatestatusbyuser&token=test&status=1&uid=L59KVYDAEPHR1T6M111A&channel=0
+'''
+
+
+class DeviceMeal(View):
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(DeviceMeal, self).dispatch(*args, **kwargs)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        return self.validation(request_dict=request.GET)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        return self.validation(request_dict=request.POST)
+
+    def validation(self, request_dict, *args, **kwargs):
+        operation = request_dict.get('operation', None)
+        if operation is not None:
+            token = request_dict.get('token', None)
+            if token is not None:
+                tokenManager = JSONTokenManager()
+                error_code = tokenManager.verify_AToken(token)
+                if error_code == 0:
+                    userID = tokenManager.accessDict.get('userID', None)
+                    param_flag = CommonService.get_param_flag(data=[userID])
+                    if param_flag is True:
+                        if operation == 'query':
+                            return self.query(request_dict=request_dict, userID=userID)
+                        elif operation == 'add':
+                            return self.add(request_dict=request_dict, userID=userID)
+                        elif operation == 'update':
+                            return self.update(request_dict=request_dict, userID=userID)
+                        elif operation == 'delete':
+                            return self.delete(request_dict=request_dict, userID=userID)
+                        # 用户付费成功调用
+                        elif operation == 'addbyuser':
+                            return self.addbyuser(request_dict=request_dict, userID=userID)
+                        elif operation == 'querybyuser':
+                            return self.querybyuser(request_dict=request_dict, userID=userID)
+                        elif operation == 'updatebyuser':
+                            return self.updatebyuser(request_dict=request_dict, userID=userID)
+                        elif operation == 'updatestatusbyuser':
+                            return self.updatestatusbyuser(request_dict=request_dict, userID=userID)
+                    return ResponseJSON(444)
+                else:
+                    return HttpResponse(tokenManager.errorCodeInfo(error_code))
+            else:
+                return ResponseJSON(311)
+        else:
+            return ResponseJSON(444)
+
+    def add(self, request_dict, userID):
+        own_perm = ModelService.check_permission(userID=userID, permID=40)
+        if own_perm is True:
+            uid = request_dict.get('uid', None)
+            channel = request_dict.get('channel', None)
+            rank = request_dict.get('rank', None)
+            param_flag = CommonService.get_param_flag(data=[uid, channel, rank])
+            if param_flag is True:
+                is_exist = Device_Meal.objects.filter(uid=uid, channel=channel)
+                if is_exist.exists():
+                    return ResponseJSON(54)
+                else:
+                    try:
+                        store_meal = Store_Meal.objects.get(id=rank)
+                        days = store_meal.day
+                        end_time = datetime.timedelta(days=int(days)) + datetime.datetime.now()
+                        print(end_time)
+                        device_meal = Device_Meal(
+                            status=1,
+                            uid=uid,
+                            channel=channel,
+                            end_time=end_time,
+                            rank=store_meal,
+                        )
+                        device_meal.save()
+                    except Exception as e:
+                        return ResponseJSON(500, {'details': repr(e)})
+                    else:
+                        if device_meal.id:
+                            return ResponseJSON(0, {'id': device_meal.id,
+                                                    'status': device_meal.status,
+                                                    'uid': device_meal.uid,
+                                                    'rank': rank,
+                                                    'channel': device_meal.channel,
+                                                    'add_time': str(device_meal.add_time),
+                                                    'update_time': str(device_meal.update_time),
+                                                    'end_time': str(device_meal.end_time)})
+            return ResponseJSON(444)
+        else:
+            return ResponseJSON(404)
+
+    def query(self, request_dict, userID):
+        own_perm = ModelService.check_permission(userID=userID, permID=30)
+        if own_perm is True:
+            page = int(request_dict.get('page', None))
+            line = int(request_dict.get('line', None))
+            param_flag = CommonService.get_param_flag(data=[page, line])
+            if param_flag is True:
+                queryset = Device_Meal.objects.all()
+                if queryset.exists():
+                    count = queryset.count()
+                    res = queryset[(page - 1) * line:page * line]
+                    send_dict = CommonService.query_set_to_dict(res)
+                    for k, v in enumerate(send_dict["datas"]):
+                        for val in res:
+                            if v['pk'] == val.id:
+                                title = Store_Meal.objects.get(id=v['fields']['rank']).title
+                                send_dict["datas"][k]['fields']['title'] = title
+                    send_dict['count'] = count
+                    return ResponseJSON(0, send_dict)
+                return ResponseJSON(0)
+            else:
+                return ResponseJSON(444)
+        else:
+            return ResponseJSON(404)
+
+    def update(self, request_dict, userID):
+        own_perm = ModelService.check_permission(userID=userID, permID=30)
+        if own_perm is True:
+            id = request_dict.get('id', None)
+            status = request_dict.get('status', None)
+            uid = request_dict.get('uid', None)
+            channel = request_dict.get('channel', None)
+            rank = request_dict.get('rank', None)
+            # days = request_dict.get('days', None)
+            param_flag = CommonService.get_param_flag(data=[status, uid, channel, rank, id])
+            if param_flag is True:
+                try:
+                    store_meal = Store_Meal.objects.get(id=rank)
+                    device_meal = Device_Meal.objects.get(id=id)
+                    days = store_meal.day
+                    now_time = timezone.localtime(timezone.now())
+                    if now_time > device_meal.end_time:
+                        end_time = now_time + datetime.timedelta(days=int(days))
+                    else:
+                        end_time = device_meal.end_time + datetime.timedelta(days=int(days))
+                except Exception as e:
+                    errorInfo = traceback.format_exc()
+                    print(errorInfo)
+                    return ResponseJSON(424, {'details': repr(e)})
+                else:
+                    if device_meal.id:
+                        device_meal.status = status
+                        device_meal.uid = uid
+                        device_meal.channel = channel
+                        device_meal.end_time = end_time
+                        device_meal.rank = store_meal
+                        device_meal.save()
+                        return ResponseJSON(0, {'update_id': device_meal.id,
+                                                'update_time': str(now_time),
+                                                'end_time': str(end_time)})
+            else:
+                return ResponseJSON(444)
+        else:
+            return ResponseJSON(404)
+
+    def delete(self, request_dict, userID):
+        own_perm = ModelService.check_permission(userID=userID, permID=10)
+        if own_perm is True:
+            id_list = request_dict.getlist('id', None)
+            param_flag = CommonService.get_param_flag(data=[id_list])
+            if param_flag is True:
+                try:
+                    for id in id_list:
+                        Device_Meal.objects.filter(id=id).delete()
+                except Exception as e:
+                    errorInfo = traceback.format_exc()
+                    print(errorInfo)
+                    return ResponseJSON(424, {'details': repr(e)})
+                else:
+                    return ResponseJSON(0)
+            else:
+                return ResponseJSON(444)
+        else:
+            return ResponseJSON(404)
+
+    def addbyuser(self, request_dict, userID):
+        uid = request_dict.get('uid', None)
+        channel = request_dict.get('channel', None)
+        rank = request_dict.get('rank', None)
+        param_flag = CommonService.get_param_flag(data=[uid, channel, rank])
+        if param_flag is True:
+            own_dev = ModelService.check_own_device(userID=userID, UID=uid)
+            if own_dev is True:
+                is_exist = Device_Meal.objects.filter(uid=uid, channel=channel)
+                if is_exist.exists():
+                    return ResponseJSON(54)
+                else:
+                    try:
+                        store_meal = Store_Meal.objects.get(id=rank)
+                        days = store_meal.day
+                        end_time = datetime.timedelta(days=int(days)) + datetime.datetime.now()
+                        print(end_time)
+                        device_meal = Device_Meal(
+                            status=1,
+                            uid=uid,
+                            channel=channel,
+                            end_time=end_time,
+                            rank=store_meal,
+                        )
+                        device_meal.save()
+                    except Exception as e:
+                        return ResponseJSON(500, {'details': repr(e)})
+                    else:
+                        if device_meal.id:
+                            return ResponseJSON(0,
+                                                {
+                                                    'id': device_meal.id,
+                                                    'status': device_meal.status,
+                                                    'uid': device_meal.uid,
+                                                    'rank': rank,
+                                                    'channel': device_meal.channel,
+                                                    'add_time': str(device_meal.add_time),
+                                                    'update_time': str(device_meal.update_time),
+                                                    'end_time': str(device_meal.end_time),
+                                                })
+            else:
+                return ResponseJSON(14)
+        return ResponseJSON(444)
+
+    # 查询设备是否开通
+    def querybyuser(self, request_dict, userID):
+        uid = request_dict.get('uid', None)
+        channel = request_dict.get('channel', None)
+        param_flag = CommonService.get_param_flag(data=[uid, channel])
+        if param_flag is True:
+            own_dev = ModelService.check_own_device(userID=userID, UID=uid)
+            if own_dev is True:
+                queryset = Device_Meal.objects.filter(uid=uid, channel=channel)
+                if queryset.exists():
+                    send_dict = CommonService.query_set_to_dict(queryset)
+                    for k, v in enumerate(send_dict["datas"]):
+                        for val in queryset:
+                            if v['pk'] == val.id:
+                                title = Store_Meal.objects.get(id=v['fields']['rank']).title
+                                send_dict["datas"][k]['fields']['title'] = title
+                    return ResponseJSON(0, send_dict)
+                return ResponseJSON(0)
+            else:
+                return ResponseJSON(14)
+        else:
+            return ResponseJSON(444)
+
+    def updatebyuser(self, request_dict, userID):
+        uid = request_dict.get('uid', None)
+        channel = request_dict.get('channel', None)
+        rank = request_dict.get('rank', None)
+        param_flag = CommonService.get_param_flag(data=[uid, channel, rank])
+        if param_flag is True:
+            own_dev = ModelService.check_own_device(userID=userID, UID=uid)
+            if own_dev is True:
+                try:
+                    store_meal = Store_Meal.objects.get(id=rank)
+                    device_meal = Device_Meal.objects.get(uid=uid, channel=channel)
+                    days = store_meal.day
+                    now_time = timezone.localtime(timezone.now())
+                    if now_time > device_meal.end_time:
+                        end_time = now_time + datetime.timedelta(days=int(days))
+                    else:
+                        end_time = device_meal.end_time + datetime.timedelta(days=int(days))
+                except Exception as e:
+                    errorInfo = traceback.format_exc()
+                    print(errorInfo)
+                    return ResponseJSON(424, {'details': repr(e)})
+                else:
+                    if device_meal.id:
+                        device_meal.uid = uid
+                        device_meal.channel = channel
+                        device_meal.end_time = end_time
+                        device_meal.rank = store_meal
+                        device_meal.save()
+                        return ResponseJSON(0, {'update_id': device_meal.id,
+                                                'update_time': str(now_time),
+                                                'end_time': str(end_time)})
+            else:
+                return ResponseJSON(14)
+        else:
+            return ResponseJSON(444)
+
+    def updatestatusbyuser(self, request_dict, userID):
+        uid = request_dict.get('uid', None)
+        channel = request_dict.get('channel', None)
+        status = request_dict.get('status', None)
+        param_flag = CommonService.get_param_flag(data=[uid, channel, id])
+        if param_flag is True:
+            own_dev = ModelService.check_own_device(userID=userID, UID=uid)
+            if own_dev is True:
+                try:
+                    device_meal = Device_Meal.objects.get(uid=uid, channel=channel)
+                except Exception as e:
+                    errorInfo = traceback.format_exc()
+                    print(errorInfo)
+                    return ResponseJSON(424, {'details': repr(e)})
+                else:
+                    if device_meal.id:
+                        device_meal.status = status
+                        device_meal.save()
+                        now_time = timezone.localtime(timezone.now())
+                        return ResponseJSON(0, {'update_id': device_meal.id,
+                                                'update_time': str(now_time)})
+            else:
+                return ResponseJSON(14)
+        else:
+            return ResponseJSON(444)

Controller/EquipmentInfo.py

@@ -0,0 +1,247 @@
+from django.shortcuts import HttpResponse
+from django.views.generic.base import View
+from django.utils.decorators import method_decorator
+from django.views.decorators.csrf import csrf_exempt
+from Service.TokenManager import JSONTokenManager
+from Service.ModelService import ModelService
+from Service.CommonService import CommonService
+from Model.models import Equipment_Info, Device_Info
+import traceback
+from Service.ResponseService import ResponseJSON
+
+'''
+http://192.168.136.45:8077/equipment/info?token=test&devUid=2N1K3LE78TYJ38CE111A&Channel=0&eventType=1&eventTime=1234567890&operation=add&alarm=21342134&receiveTime=1234567891234567
+http://192.168.136.45:8077/equipment/info?token=test&operation=query&page=1&line=10
+http://192.168.136.45:8077/equipment/info?token=test&operation      =delete&devUid=UKPAH63V23U4ZHEB111A&id=5&id=6&id=7
+http://192.168.136.40:8077/equipment/info?token=test&operation=update&devUid=UKPAH63V23U4ZHEB111A&id=3&id=4
+http://192.168.136.45:8077/equipment/info?token=test&operation=queryByAdmin&page=1&line=10&userID_id=151547867345163613800138001
+http://192.168.136.45:8077/equipment/info?token=test&operation=deleteByAdmin&id=5&id=6&id=7
+
+'''
+
+
+class EquipmentInfo(View):
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(EquipmentInfo, self).dispatch(*args, **kwargs)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        return self.validation(request_dict=request.GET)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        return self.validation(request_dict=request.POST)
+
+    def validation(self, request_dict, *args, **kwargs):
+        token = request_dict.get('token', None)
+        if token is not None:
+            tokenManager = JSONTokenManager()
+            error_code = tokenManager.verify_AToken(token)
+            if error_code == 0:
+                userID = tokenManager.accessDict.get('userID', None)
+                operation = request_dict.get('operation', None)
+                param_flag = CommonService.get_param_flag(data=[userID, operation])
+                if param_flag is True:
+                    if operation == 'query':
+                        return self.query_info(request_dict=request_dict, userID=userID)
+                    elif operation == 'add':
+                        return self.add_info(request_dict=request_dict, userID=userID)
+                    elif operation == 'update':
+                        return self.update_info(request_dict=request_dict, userID=userID)
+                    elif operation == 'delete':
+                        return self.delete_info(request_dict=request_dict, userID=userID)
+                    elif operation == 'findByTime':
+                        return self.findByTime_info(request_dict=request_dict, userID=userID)
+                    if operation == 'queryByAdmin':
+                        return self.query_all_info(request_dict=request_dict, userID=userID)
+                    if operation == 'deleteByAdmin':
+                        return self.delete_by_admin(request_dict=request_dict, userID=userID)
+                return ResponseJSON(444)
+            else:
+                return HttpResponse(tokenManager.errorCodeInfo(error_code))
+        else:
+            return ResponseJSON(311)
+
+    def add_info(self, request_dict, userID):
+        devUid = request_dict.get('devUid', None)
+        Channel = request_dict.get('Channel', None)
+        eventType = request_dict.get('eventType', None)
+        eventTime = request_dict.get('eventTime', None)
+        receiveTime = request_dict.get('receiveTime', None)
+        alarm = request_dict.get('alarm', None)
+        param_flag = CommonService.get_param_flag(data=[devUid, Channel, eventType, eventTime, alarm, receiveTime])
+        if param_flag is True:
+            own_device = ModelService.check_own_device(userID, UID=devUid)
+            if own_device is True:
+                try:
+                    device_info = Device_Info.objects.filter(UID=devUid,userID_id=userID)
+                except Exception:
+                    errorInfo = traceback.format_exc()
+                    print(errorInfo)
+                    return ResponseJSON(424, errorInfo)
+                else:
+                    if device_info.exists():
+                        try:
+                            equipment_info = Equipment_Info(
+                                devUid=devUid,
+                                Channel=Channel,
+                                eventType=eventType,
+                                receiveTime=receiveTime,
+                                eventTime=eventTime,
+                                viewPwd=device_info[0].View_Password,
+                                devNickName=device_info[0].NickName,
+                                viewAccont=device_info[0].View_Account,
+                                alarm=alarm
+                            )
+                            equipment_info.save()
+                        except Exception:
+                            errorInfo = traceback.format_exc()
+                            print(errorInfo)
+                            return ResponseJSON(500, errorInfo)
+                        else:
+                            if equipment_info.id:
+                                return ResponseJSON(0, {'infoID': equipment_info.id,
+                                                        'devUid': devUid,
+                                                        'Channel': Channel,
+                                                        'alarm': alarm,
+                                                        'eventType': eventType,
+                                                        'eventTime': eventTime,
+                                                        'receiveTime': receiveTime,
+                                                        'viewPwd': equipment_info.viewPwd,
+                                                        'devNickName': equipment_info.devNickName,
+                                                        'viewAccont': equipment_info.viewAccont})
+                            else:
+                                return ResponseJSON(500)
+                    else:
+                        return ResponseJSON(14)
+            else:
+                return ResponseJSON(14)
+        return ResponseJSON(444)
+
+    def query_info(self, request_dict, userID):
+        page = int(request_dict.get('page', None))
+        line = int(request_dict.get('line', None))
+        param_flag = CommonService.get_param_flag(data=[page, line])
+        if param_flag is True:
+            try:
+                uid_list = Device_Info.objects.filter(userID_id=userID).values_list('UID', flat=True)
+            except Exception:
+                pass
+            if len(uid_list):
+                equipment_info_queryset = Equipment_Info.objects.filter(devUid__in=uid_list).order_by(
+                    '-id')
+                if equipment_info_queryset.exists():
+                    equipment_info_count = equipment_info_queryset.count()
+                    equipment_info_res = equipment_info_queryset[(page - 1) * line:page * line]
+                    send_json = CommonService.query_set_to_dict(equipment_info_res)
+                    send_json['count'] = equipment_info_count
+                    return ResponseJSON(0, send_json)
+            return ResponseJSON(0, {'datas': [], 'count': 0})
+        else:
+            return ResponseJSON(444)
+
+    def update_info(self, request_dict, userID):
+        id_list = request_dict.getlist('id[]', None)
+        if id_list is None or len(id_list) < 1:
+            id_list = request_dict.getlist('id', None)
+        param_flag = CommonService.get_param_flag(data=[id_list])
+        if param_flag is True:
+            count = 0
+            for id in id_list:
+                eq = Equipment_Info.objects.filter(id=id)
+                if eq.exists():
+                    own_dev = ModelService.check_own_device(userID, eq[0].devUid)
+                    if own_dev is True:
+                        count += 1
+                        eq.update(status=1)
+            return ResponseJSON(0,{'update_success': count})
+        else:
+            return ResponseJSON(444)
+
+    def delete_info(self, request_dict, userID):
+        id_list = request_dict.getlist('id[]', None)
+        if id_list is None or len(id_list) < 1:
+            id_list = request_dict.getlist('id', None)
+        param_flag = CommonService.get_param_flag(data=[id_list])
+        if param_flag is True:
+            try:
+                for id in id_list:
+                    eq = Equipment_Info.objects.filter(id=id)
+                    if eq.exists():
+                        own_dev = ModelService.check_own_device(userID, eq[0].devUid)
+                        if own_dev is True:
+                            eq.delete()
+            except Exception as e:
+                errorInfo = traceback.format_exc()
+                print(errorInfo)
+                return ResponseJSON(424,repr(e))
+            else:
+                return ResponseJSON(0)
+        else:
+            return ResponseJSON(444)
+
+    def findByTime_info(self, request_dict, userID):
+        startTime = request_dict.get('startTime')
+        endTime = request_dict.get('endTime')
+        page = int(request_dict.get('page', None))
+        line = int(request_dict.get('line', None))
+        param_flag = CommonService.get_param_flag(data=[startTime, endTime, page, line])
+        if param_flag is True:
+            uid_list = Device_Info.objects.filter(userID_id=userID).values_list('UID', flat=True)
+            if len(uid_list):
+                equipment_info_queryset = Equipment_Info.objects.filter(devUid__in=uid_list,
+                                                                        eventTime__range=(startTime, endTime)).order_by(
+                    '-id')
+                if equipment_info_queryset.exists():
+                    equipment_info_count = equipment_info_queryset.count()
+                    equipment_info_res = equipment_info_queryset[(page - 1) * line:page * line]
+                    send_json = CommonService.query_set_to_dict(equipment_info_res)
+                    send_json['count'] = equipment_info_count
+                    return ResponseJSON(0,send_json)
+            return ResponseJSON(0,{'datas': [], 'count': 0})
+        else:
+            return ResponseJSON(444)
+
+    def query_all_info(self, request_dict, userID):
+        page = int(request_dict.get('page', None))
+        line = int(request_dict.get('line', None))
+        userID_id = request_dict.get('userID_id', None)
+        param_flag = CommonService.get_param_flag(data=[page, line])
+        if param_flag is True:
+            check_perm = ModelService.check_permission(userID=userID, permID=30)
+            if check_perm is True:
+                uid_list = Device_Info.objects.filter(userID_id=userID_id).values_list('UID', flat=True)
+                if len(uid_list):
+                    equipment_info_queryset = Equipment_Info.objects.filter(devUid__in=uid_list).order_by(
+                        '-id')
+                    if equipment_info_queryset.exists():
+                        equipment_info_count = equipment_info_queryset.count()
+                        equipment_info_res = equipment_info_queryset[(page - 1) * line:page * line]
+                        send_json = CommonService.query_set_to_dict(equipment_info_res)
+                        send_json['count'] = equipment_info_count
+                        return ResponseJSON(0,send_json)
+                return ResponseJSON(0,{'datas': [], 'count': 0})
+            else:
+                return ResponseJSON(404)
+        else:
+            return ResponseJSON(444)
+
+    def delete_by_admin(self, request_dict, userID):
+        id_list = request_dict.getlist('id', None)
+        param_flag = CommonService.get_param_flag(data=[id_list])
+        if param_flag is True:
+            check_perm = ModelService.check_permission(userID=userID, permID=10)
+            if check_perm is True:
+                try:
+                    is_delete = Equipment_Info.objects.filter(id__in=id_list).delete()
+                except Exception as e:
+                    errorInfo = traceback.format_exc()
+                    print(errorInfo)
+                    return ResponseJSON(424,{'details': repr(e)})
+                else:
+                    return ResponseJSON(0,{'delete_count': is_delete[0]})
+            else:
+                return ResponseJSON(404)
+        else:
+            return ResponseJSON(444)

Controller/EquipmentManager.py

@@ -0,0 +1,430 @@
+from django.views.decorators.csrf import csrf_exempt
+from django.core import serializers
+import traceback
+from Service.ResponseService import *
+from Service.ModelService import ModelService
+from Model.models import Device_User, Device_Info
+from Service.TokenManager import JSONTokenManager
+from Service.CommonService import CommonService
+
+
+def queryUserEquipment(userID):
+    try:
+        deviceValid = Device_Info.objects.filter(userID_id = userID)
+    except Exception as e:
+        errorInfo = traceback.format_exc()
+        print('查询数据库错误: %s' % errorInfo)
+        return ResponseFormal(500, repr(e))
+    else:
+        if deviceValid:
+            sqlJSON = serializers.serialize('json', Device_Info.objects.filter(userID_id = userID))
+            sqlList = json.loads(sqlJSON)
+            sqlDict = dict(zip(["datas"], [sqlList]))
+            return ResponseFormal(0,sqlDict)
+        else:
+            UserValid = Device_User.objects.filter(userID=userID)
+            if UserValid:
+                return ResponseFormal(172)
+            else:
+                return ResponseFormal(113)
+
+def addNewUserEquipment(userID, deviceContent, bulk = False):
+    userIDValid = Device_User.objects.filter(userID = userID)
+    if userIDValid:
+        try:
+            try:
+                deviceData = json.loads(deviceContent)
+            except Exception as e:
+                return ResponseFormal(803,repr(e))
+            else:
+                UID = deviceData.get('UID', None)
+                if UID != None:
+                    # is_bind = Device_Info.objects.filter(UID = UID,isShare=False)
+                    # if is_bind:
+                    #     return ResponseFormal(175)
+                    dValid = Device_Info.objects.filter(userID = userID, UID = UID)
+                    if dValid:
+                        return ResponseFormal(174)
+                    else:
+                        if 'NickName' in deviceData:
+                            nValid = Device_Info.objects.filter(userID=userID, NickName=deviceData['NickName'])
+                            if nValid.exists():
+                                return ResponseJSON(179)
+                        userDevice = Device_Info(id=CommonService.getUserID(getUser=False), userID_id=userID, **deviceData)
+                        userDevice.save()
+                else:
+                    return ResponseFormal(806)
+
+        except Exception as e:
+            errorInfo = traceback.format_exc()
+            print('添加设备错误: %s ' % errorInfo)
+            return ResponseFormal(178,repr(e))
+        else:
+            sqlJSON = serializers.serialize('json', [userDevice])
+            sqlList = json.loads(sqlJSON)
+            sqlDict =dict(zip(["datas"], [sqlList]))
+            return ResponseFormal(0,sqlDict)
+    else:
+        return ResponseFormal(113)
+
+
+def delUserEquipment(userID, id):
+    try:
+        deviceValid = Device_Info.objects.filter(userID_id = userID, id = id)
+    except Exception as e:
+        errorInfo = traceback.format_exc()
+        print('查询数据库错误: %s' % errorInfo)
+        return ResponseFormal(500, repr(e))
+    else:
+        if deviceValid:
+            try:
+                Device_Info.objects.filter(userID_id = userID, id = id).delete()
+            except Exception as e:
+                errorInfo = traceback.format_exc()
+                print('删除数据库记录错误: %s' % errorInfo)
+                return ResponseFormal(176,repr(e))
+            else:
+                return ResponseFormal(0)
+        else:
+            UserValid = Device_User.objects.filter(userID = userID)
+            if UserValid:
+                return ResponseFormal(172)
+            else:
+                return ResponseFormal(113)
+
+def modifyUserEquipment(userID, deviceContent, id):
+    try:
+        deviceValid = Device_Info.objects.filter(userID_id = userID, id = id)
+    except Exception as e:
+        errorInfo = traceback.format_exc()
+        print('查询数据库错误: %s' % errorInfo)
+        return ResponseFormal(500, repr(e))
+    else:
+        if deviceValid:
+            deviceData = json.loads(deviceContent)
+            try:
+                userDevice = Device_Info.objects.filter(userID_id = userID, id = id).update(**deviceData)
+            except Exception as e:
+                errorInfo = traceback.format_exc()
+                print('修改设备信息错误: %s ' % errorInfo)
+                return ResponseFormal(177,repr(e))
+            else:
+                sqlJSON = serializers.serialize('json', Device_Info.objects.filter(userID_id = userID, id = id))
+                sqlList = json.loads(sqlJSON)
+                sqlDict = dict(zip(["datas"], [sqlList]))
+                return ResponseFormal(0,sqlDict)
+        else:
+            UserValid = Device_User.objects.filter(userID=userID)
+            if UserValid:
+                return ResponseFormal(172)
+            else:
+                return ResponseFormal(113)
+
+def showAllUserEquipment(userID):
+
+    try:
+        userValid = Device_User.objects.filter(userID = userID).order_by('-data_joined')
+    except Exception as e:
+        errorInfo = traceback.format_exc()
+        print('查询数据库错误: %s' % errorInfo)
+        return ResponseFormal(500,repr(e))
+
+    else:
+        if userValid:
+            # own_permission = ModelService.check_permission(userID=userID,permID=30)
+            if userValid[0].is_superuser != 100 and userValid[0].is_superuser != 1:
+                return ResponseFormal(604)
+            else:
+                sqlJSON = serializers.serialize('json', Device_Info.objects.all())#.order_by('-data_joined'))
+                sqlList = json.loads(sqlJSON)
+                print(sqlList, sqlJSON)
+                sqlDict = dict(zip(["datas"], [sqlList]))
+                return ResponseFormal(0,sqlDict)
+        else:
+            return ResponseFormal(113)
+
+def showAllUserEquipmentPC(userID,fieldDict):
+    try:
+        user_valid = Device_User.objects.filter(userID=userID).order_by('-data_joined')
+    except Exception as e:
+        errorInfo = traceback.format_exc()
+        print('查询数据库错误: %s' % errorInfo)
+        return ResponseJSON(500,repr(e))
+    else:
+        if user_valid:
+            own_permission = ModelService.check_permission(userID=userID, permID=30)
+            if own_permission:
+                page = int(fieldDict['page'])
+                line = int(fieldDict['line'])
+                device_info_query_set = Device_Info.objects.all()
+                device_info_count = device_info_query_set.count()
+                device_info_res = device_info_query_set[(page - 1) * line:page * line]
+                sqlDict = CommonService.query_set_to_dict(query_set=device_info_res)
+                sqlDict['count'] = device_info_count
+                return ResponseJSON(0, sqlDict)
+            else:
+                return ResponseJSON(604)
+        else:
+            return ResponseJSON(113)
+
+def getKwargs(data={}):
+    kwargs = {}
+    for (k, v) in data.items():
+        if v is not None and v != u'':
+            kwargs[k+'__icontains'] = v
+    return kwargs
+
+def findEquipmentInfo(content,type,fieldDict):
+    if type ==1:
+        Device_Info_QuerySet=Device_Info.objects.all()
+    if type==2:
+        searchCondition=content
+        kwargs = getKwargs(data=searchCondition)
+        Device_Info_QuerySet=Device_Info.objects.filter(**kwargs)
+    page = int(fieldDict['page'])
+    line = int(fieldDict['line'])
+    device_info_count = Device_Info_QuerySet.count()
+    res = Device_Info_QuerySet[(page - 1) * line:page * line]
+    send_dict = CommonService.query_set_to_dict(query_set=res)
+    for k, v in enumerate(send_dict["datas"]):
+        for val in res:
+            if v['pk'] == val.id:
+                username = ModelService.get_user_name(send_dict["datas"][k]['fields']['userID'])
+                send_dict["datas"][k]['fields']['username'] = username
+                primary = ModelService.get_user_name(send_dict["datas"][k]['fields']['primaryUserID'])
+                send_dict["datas"][k]['fields']['primaryusername'] = primary
+    send_dict['count'] = device_info_count
+    return send_dict
+@csrf_exempt
+def queryUserEquipmentInterface(request, *callback_args,
+                                **callback_kwargs):
+    '''
+    查询用户设备
+    :param request:
+    :param callback_args:
+    :param callback_kwargs:
+    :return:
+    '''
+
+    if request.method == 'POST':
+        request.encoding = 'utf-8'
+        token = request.POST.get('token', None)
+
+        if token is not None:
+            tM = JSONTokenManager()
+            error_code = tM.verify_AToken(token)
+            if error_code == 0:
+                userID = tM.accessDict.get('userID', None)
+                if userID:
+                    response = HttpResponse(queryUserEquipment(userID))
+                    return response
+                else:
+                    return ResponseJSON(310)
+            else:
+                response = HttpResponse(tM.errorCodeInfo(error_code))
+                return response
+        else:
+            return ResponseJSON(800)
+
+    elif request.method == 'GET':
+        request.encoding = 'gb2312'
+        token = request.GET.get('token', None)
+
+        if token is not None:
+            tM = JSONTokenManager()
+            error_code = tM.verify_AToken(token)
+            if error_code == 0:
+                userID = tM.accessDict.get('userID', None)
+                # userID = '151547899913020418607560093'
+
+                if userID:
+                    response = HttpResponse(queryUserEquipment(userID))
+                    return response
+                else:
+                    return ResponseJSON(310)
+
+            else:
+                response = HttpResponse(tM.errorCodeInfo(error_code))
+                return response
+        else:
+            return ResponseJSON(800)
+
+    else:
+        return ResponseJSON(801)
+
+@csrf_exempt
+def addNewUserEquipmentInterface(request, *callback_args,
+                                 **callback_kwargs):
+    if request.method == 'POST':
+        request.encoding = 'utf-8'
+        request_dict = request.POST
+    elif request.method == 'GET':
+        request.encoding = 'utf-8'
+        request_dict = request.GET
+    else:
+        return ResponseJSON(801)
+    token = request_dict.get('token', None)
+    deviceContent = request_dict.get('content', None)
+    if token is not None and deviceContent is not None:
+        tM = JSONTokenManager()
+        error_code = tM.verify_AToken(token)
+        if error_code == 0:
+            userID = tM.accessDict.get('userID', None)
+            if userID:
+                response = HttpResponse(addNewUserEquipment(userID, deviceContent))
+                return response
+            else:
+                return ResponseJSON(310)
+        else:
+            response = HttpResponse(tM.errorCodeInfo(error_code))
+            return response
+    else:
+        return ResponseJSON(800)
+
+
+@csrf_exempt
+def delUserEquipmentInterface(request, *callback_args,
+                                 **callback_kwargs):
+    '''
+    删除用户设备
+    :param request:
+    :param callback_args: 表示任何多个无名参数，tuple类型
+    :param callback_kwargs: 表示关键字参数，dict类型
+    :return:
+    '''
+    if request.method == 'POST':
+        request.encoding = 'utf-8'
+
+        token = request.POST.get('token', None)
+        id = request.POST.get('id', None)
+
+        if token is not None and id is not None:
+            tM = JSONTokenManager()
+            error_code = tM.verify_AToken(token)
+            if error_code == 0:
+                userID = tM.accessDict.get('userID', None)
+                if userID:
+                    response = HttpResponse(delUserEquipment(userID, id))
+                    return response
+                else:
+                    return ResponseJSON(310)
+            else:
+                response = HttpResponse(tM.errorCodeInfo(error_code))
+                return response
+
+        else:
+            return ResponseJSON(800)
+
+    elif request.method == 'GET':
+        request.encoding = 'gb2312'
+        token = request.GET.get('token', None)
+        id = request.GET.get('id', None)
+
+        if token is not None and id is not None:
+            tM = JSONTokenManager()
+            error_code = tM.verify_AToken(token)
+            if error_code == 0:
+                userID = tM.accessDict.get('userID', None)
+                if userID:
+                    response = HttpResponse(delUserEquipment(userID, id))
+                    return response
+                else:
+                    return ResponseJSON(310)
+            else:
+                response = HttpResponse(tM.errorCodeInfo(error_code))
+                return response
+        else:
+            return ResponseJSON(800)
+    else:
+        return ResponseJSON(801)
+
+@csrf_exempt
+def modifyUserEquipmentInterface(request, *callback_args,
+                                 **callback_kwargs):
+    '''
+    修改用户设备
+    :param request:
+    :param callback_args:
+    :param callback_kwargs:
+    :return:
+    '''
+    if request.method == 'POST':
+        request.encoding = 'utf-8'
+        request_dict = request.POST
+    elif request.method == 'GET':
+        request.encoding = 'gb2312'
+        request_dict = request.GET
+    token = request_dict.get('token', None)
+    deviceContent = request_dict.get('content', None)
+    id = request_dict.get('id', None)
+    if token is not None and deviceContent is not None and id is not None:
+        tM = JSONTokenManager()
+        error_code = tM.verify_AToken(token)
+        if error_code == 0:
+            userID = tM.accessDict.get('userID', None)
+            if userID:
+                response = HttpResponse(modifyUserEquipment(userID, deviceContent, id))
+                return response
+            else:
+                return ResponseJSON(310)
+        else:
+            response = HttpResponse(tM.errorCodeInfo(error_code))
+            return response
+    else:
+        return ResponseJSON(444)
+
+@csrf_exempt
+def showAllUserEquipmentInterface(request, *callback_args, **callback_kwargs):
+    if request.method == 'POST':
+        request.encoding = 'utf-8'
+        fieldDict = request.POST
+    if request.method == 'GET':
+        request.encoding = 'utf-8'
+        fieldDict = request.GET
+    token = request.POST.get('token', None)
+    type = request.POST.get('type', None)
+    if token != None:
+        tM = JSONTokenManager()
+        error_code = tM.verify_AToken(token)
+        if error_code == 0:
+            userID = tM.accessDict.get('userID', None)
+            if userID:
+                if type == 'PC':
+                    return showAllUserEquipmentPC(userID, fieldDict)
+                else:
+                    return showAllUserEquipment(userID)
+            else:
+                return ResponseJSON(310)
+        else:
+            return HttpResponse(tM.errorCodeInfo(error_code))
+
+    else:
+        return ResponseJSON(800)
+
+@csrf_exempt
+def findEquipmentInfoInterface(request, *callback_args, **callback_kwargs):
+    if request.method == 'GET':
+        request.encoding = 'gb2312'
+        token = request.GET.get('token',None)
+        fieldDict = request.GET
+        deviceContent = request.GET.get('content',None)
+    if request.method == 'POST':
+        request.encoding = 'utf-8'
+        token = request.POST.get('token', None)
+        fieldDict = request.POST
+        deviceContent = request.POST.get('content', None)
+
+    if token != None:
+        tM = JSONTokenManager()
+        error_code = tM.verify_AToken(token)
+        if error_code == 0:
+            if deviceContent:
+                deviceContent=json.loads(deviceContent)
+                resultDict=findEquipmentInfo(content=deviceContent,type=2,fieldDict=fieldDict)
+            else:
+                resultDict=findEquipmentInfo(content='',type=1,fieldDict=fieldDict)
+            return ResponseJSON(0,resultDict)
+        else:
+            return ResponseJSON(310)
+    else:
+        return ResponseJSON(800)

Controller/EquipmentOTA.py

@@ -0,0 +1,143 @@
+from django.views.generic.base import View
+from django.utils.decorators import method_decorator
+from django.views.decorators.csrf import csrf_exempt
+from Service.TokenManager import JSONTokenManager
+from Service.ModelService import ModelService
+from Service.CommonService import CommonService
+from Model.models import Equipment_Version
+from Ansjer.config import *
+from django.utils import timezone
+import os
+from Service.ResponseService import *
+'''
+http://192.168.136.45:8077/equipment/OTA?token=test&operation=query&page=1&line=10
+http://192.168.136.45:8077/equipment/OTA?token=test&operation=find&page=1&line=10&content={}
+http://192.168.136.40:8077/equipment/OTA?eid=138001524641441203480138000&token=test&operation=delete
+http://192.168.136.40:8077/equipment/OTA?eid=138001524641441203480138000&token=test&operation=update&status=1
+'''
+
+class EquipmentOTA(View):
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(EquipmentOTA, self).dispatch(*args, **kwargs)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        return self.validation(request_dict=request.GET)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        return self.validation(request_dict=request.POST)
+
+    def validation(self, request_dict, *args, **kwargs):
+        token = request_dict.get('token', None)
+        if token is not None:
+            tokenManager = JSONTokenManager()
+            error_code = tokenManager.verify_AToken(token)
+            if error_code == 0:
+                userID = tokenManager.accessDict.get('userID', None)
+                operation = request_dict.get('operation', None)
+                param_flag = CommonService.get_param_flag(data=[userID, operation])
+                if param_flag is True:
+                    if operation == 'delete':
+                        return self.delete(request_dict=request_dict, userID=userID)
+                    elif operation == 'query':
+                        return self.query(request_dict=request_dict, userID=userID)
+                    elif operation == 'find':
+                        return self.find(request_dict=request_dict, userID=userID)
+                    elif operation == 'update':
+                        return self.update(request_dict=request_dict, userID=userID)
+
+                return ResponseJSON(444)
+            else:
+                return HttpResponse(tokenManager.errorCodeInfo(error_code))
+        else:
+            return ResponseJSON(311)
+
+    def delete(self, request_dict, userID):
+        eid = request_dict.get('eid', None)
+        param_flag = CommonService.get_param_flag(data=[eid])
+        if param_flag is True:
+            own_permission = ModelService.check_permission(userID=userID,permID=230)
+            if own_permission is True:
+                ev = Equipment_Version.objects.filter(eid=eid)
+                if ev.exists():
+                    try:
+                        has_ev = EquipmentOTA.objects.filter(filePath = ev[0].filePath)
+                        if has_ev.exists():
+                            pass
+                        else:
+                            filepath = os.path.join(BASE_DIR,ev[0].filePath)
+                            os.remove(filepath)
+                    except Exception as e:
+                        pass
+                    ev.delete()
+                    return ResponseJSON(0)
+            else:
+                return ResponseJSON(404)
+        return ResponseJSON(444)
+
+    def query(self, request_dict,userID):
+        page = int(request_dict.get('page', None))
+        line = int(request_dict.get('line', None))
+        param_flag = CommonService.get_param_flag(data=[page,line])
+        if param_flag is True:
+            own_permission = ModelService.check_permission(userID=userID, permID=240)
+            if own_permission is True:
+                equipment_version_queryset = Equipment_Version.objects.all().order_by('-data_joined')
+                if equipment_version_queryset.exists():
+                    count = equipment_version_queryset.count()
+                    res = equipment_version_queryset[(page - 1) * line:page * line]
+                    send_json = CommonService.query_set_to_dict(res)
+                    send_json['count'] = count
+                    return ResponseJSON(0, send_json)
+            else:
+                return ResponseJSON(404)
+        else:
+            return ResponseJSON(444)
+
+    def find(self, request_dict,userID):
+        page = int(request_dict.get('page', None))
+        line = int(request_dict.get('line', None))
+        content = request_dict.get('content', None)
+        param_flag = CommonService.get_param_flag(data=[page,line,content])
+        if param_flag is True:
+            own_permission = ModelService.check_permission(userID=userID, permID=250)
+            if own_permission is True:
+                content = json.loads(content)
+                search_kwargs = CommonService.get_kwargs(data=content)
+                equipment_version_queryset = Equipment_Version.objects.filter(**search_kwargs)
+                if equipment_version_queryset.exists():
+                    count = equipment_version_queryset.count()
+                    res = equipment_version_queryset[(page - 1) * line:page * line]
+                    send_json = CommonService.query_set_to_dict(res)
+                    send_json['count'] = count
+                    return ResponseJSON(0, send_json)
+                else:
+                    return ResponseJSON(0)
+            else:
+                return ResponseJSON(404)
+        else:
+            return ResponseJSON(444)
+
+    def update(self,request_dict,userID):
+        eid = request_dict.get('eid', None)
+        param_flag = CommonService.get_param_flag(data=[eid])
+        if param_flag is True:
+            own_permission = ModelService.check_permission(userID=userID, permID=230)
+            if own_permission is True:
+                ev = Equipment_Version.objects.filter(eid=eid)
+                if ev.exists():
+                    status = request_dict.get('status',None)
+                    try:
+
+                        update_time = timezone.localtime(timezone.now())
+                        ev.update(status=status,update_time=update_time)
+                    except Exception as e:
+                        print(repr(e))
+                        pass
+                    return ResponseJSON(0,{'update_time':str(update_time)})
+            else:
+                return ResponseJSON(404)
+        return ResponseJSON(444)
+

Controller/EquipmentSensor.py

@@ -0,0 +1,213 @@
+from django.views.generic.base import View
+from django.utils.decorators import method_decorator
+from django.views.decorators.csrf import csrf_exempt
+from Service.ResponseService import *
+from Service.TokenManager import JSONTokenManager
+from Service.ModelService import ModelService
+from Service.CommonService import CommonService
+from Model.models import Device_Info, Equipment_Sensor
+import traceback
+
+'''
+增加,关联设备传感器:
+params:{
+    did：设备主键did
+    name:传感器名称
+    status:设备状态值
+    type:设备类型
+    token:令牌
+    operation:add
+}
+http://192.168.136.40:8077/equipment/sensor?token=test&name=1&status=1&did=138001380001515727362917767&type=1&operation=add
+删除设备关联的传感器:
+params:{
+    id：传感器主键id
+    token:令牌
+    operation:delete
+     did：设备主键did
+}
+http://192.168.136.40:8077/equipment/sensor?token=test&id=2&id=3&operation=delete&did=did
+改，状态名称:
+params:{
+    id：传感器主键id
+    token:令牌
+    status:状态值
+    operation:update
+    name:name
+    did：设备主键did
+}
+http://192.168.136.40:8077/equipment/sensor?token=test&id=19&did=138001380001515727362917767&status=1&name=555&operation=update
+查找当前指定用户所有传感器
+params:{
+    token:令牌
+    operation:query
+    did：设备主键did
+}
+http://192.168.136.40:8077/equipment/sensor?token=test&operation=query&did=138001380001515727362917767
+后台
+查找所有传感器信息
+http://192.168.136.40:8077/equipment/sensor?token=test&page=1&line=5&operation=queryall
+'''
+
+
+class EquipmentSensor(View):
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(EquipmentSensor, self).dispatch(*args, **kwargs)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        return self.validation(request_dict=request.GET)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        return self.validation(request_dict=request.POST)
+
+    def validation(self, request_dict, *args, **kwargs):
+        token = request_dict.get('token', None)
+        if token is not None:
+            tokenManager = JSONTokenManager()
+            error_code = tokenManager.verify_AToken(token)
+            if error_code == 0:
+                userID = tokenManager.accessDict.get('userID', None)
+                operation = request_dict.get('operation', None)
+                if operation == 'add':
+                    return self.add_sensor(request_dict=request_dict, userID=userID)
+                elif operation == 'delete':
+                    return self.delete_sensor(request_dict=request_dict, userID=userID)
+                elif operation == 'update':
+                    return self.update_sensor(userID=userID, request_dict=request_dict)
+                elif operation == 'query':
+                    return self.query_sensor(userID=userID,request_dict=request_dict)
+                elif operation == 'queryall':
+                    return self.admin_query_all_sensor(userID=userID,request_dict=request_dict)
+            else:
+                return HttpResponse(tokenManager.errorCodeInfo(error_code))
+        else:
+            return ResponseJSON(311)
+
+    def add_sensor(self, userID, request_dict):
+        # 设备PK
+        did = request_dict.get('did', None)
+        name = request_dict.get('name', None)
+        status = request_dict.get('status', None)
+        type = request_dict.get('type', None)
+        if did is not None and name is not None and status is not None and type is not None:
+            is_user = ModelService.check_user_own_device(userID=userID,deviceID=did)
+            if is_user is True:
+                try:
+                    device_info = Device_Info.objects.get(id=did)
+                except Exception as e:
+                    errorInfo = traceback.format_exc()
+                    print('database error: %s' % errorInfo)
+                    return ResponseJSON(424)
+                else:
+                    if device_info:
+                        equipment_sensor = Equipment_Sensor(name=name, status=status, type=type, uid=device_info.UID)
+                        equipment_sensor.save()
+                        if equipment_sensor.id:
+                            return ResponseJSON(0,
+                                                                             {'id': equipment_sensor.id,
+                                                                                       'status': equipment_sensor.status,
+                                                                                       'name': equipment_sensor.name,
+                                                                                       'type': equipment_sensor.type})
+                        else:
+                            return ResponseJSON(4)
+            else:
+                return ResponseJSON(14)
+        return ResponseJSON(444)
+
+    def delete_sensor(self, request_dict,userID):
+        # deletelist
+        did = request_dict.get('did',None)
+        id_list = request_dict.getlist('id', None)
+        if len(id_list)>0 and id_list is not None and did is not None:
+            is_user = ModelService.check_user_own_device(userID=userID, deviceID=did)
+            is_superadmin = ModelService.check_permission(userID=userID, permID=10)
+            if is_user is True or is_superadmin is True:
+                try:
+                    device_info = Device_Info.objects.get(id=did)
+                except Exception as e:
+                    errorInfo = traceback.format_exc()
+                    print('database error: %s' % errorInfo)
+                    return ResponseJSON(424)
+                else:
+                    if device_info:
+                        for id in id_list:
+                            Equipment_Sensor.objects.filter(id=id, uid=device_info.UID).delete()
+                        return ResponseJSON(0)
+            else:
+                return ResponseJSON(14)
+        return ResponseJSON(444)
+
+    def update_sensor(self,request_dict,userID):
+        id = request_dict.get('id', None)
+        did = request_dict.get('did',None)
+        status = request_dict.get('status', None)
+        name = request_dict.get('name', None)
+        if id is not None and status is not None:
+            is_user = ModelService.check_user_own_device(userID=userID, deviceID=did)
+            is_superadmin = ModelService.check_permission(userID=userID, permID=50)
+            if is_user is True or is_superadmin is True:
+                try:
+                    device_info = Device_Info.objects.get(id=did)
+                except Exception as e:
+                    errorInfo = traceback.format_exc()
+                    print('database error: %s' % errorInfo)
+                    return ResponseJSON(424)
+                else:
+                    is_update = Equipment_Sensor.objects.filter(id=id, uid=device_info.UID).update(status=status,
+                                                                                                  name=name)
+                    if is_update:
+                        return ResponseJSON(0, {'id': id, 'status': status,
+                                                                                           'name': name})
+                return ResponseJSON(4)
+            else:
+                return ResponseJSON(14)
+        else:
+            return ResponseJSON(444)
+
+
+    def query_sensor(self,request_dict,userID):
+        did = request_dict.get('did', None)
+        if did is not None:
+            is_user = ModelService.check_user_own_device(userID=userID, deviceID=did)
+            is_superadmin = ModelService.check_permission(userID=userID,permID=30)
+            if is_user is True or is_superadmin is True:
+                try:
+                    device_info = Device_Info.objects.get(id=did)
+                except Exception as e:
+                    errorInfo = traceback.format_exc()
+                    print('database error: %s' % errorInfo)
+                    return ResponseJSON(424)
+                else:
+                    equipment_sensor_queryset = Equipment_Sensor.objects.filter(uid=device_info.UID)
+                    if equipment_sensor_queryset.exists():
+                        send_json = CommonService.query_set_to_dict(equipment_sensor_queryset)
+                        return ResponseJSON(0, send_json)
+                    else:
+                        return ResponseJSON(0, {})
+            return ResponseJSON(14)
+        else:
+            return ResponseJSON(444)
+
+    def admin_query_all_sensor(self,request_dict,userID):
+        page = int(request_dict.get('page', None))
+        line = int(request_dict.get('line', None))
+        if userID is not None:
+            is_own = ModelService.check_permission(userID=userID, permID=30)
+            if is_own is True:
+                equipment_sensor_queryset = Equipment_Sensor.objects.all()
+                if equipment_sensor_queryset.exists():
+                    equipment_stream_count = equipment_sensor_queryset.count()
+                    equipment_stream_res = equipment_sensor_queryset[(page - 1) * line:page * line]
+                    send_json = CommonService.query_set_to_dict(equipment_stream_res)
+                    send_json['count'] = equipment_stream_count
+                    return ResponseJSON(0, send_json)
+                else:
+                    return ResponseJSON(0, {})
+            return ResponseJSON(604)
+        else:
+            return ResponseJSON(444)
+
+

Controller/EquipmentStatus.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python3  
+# -*- coding: utf-8 -*-  
+"""
+@Copyright (C) ansjer cop Video Technology Co.,Ltd.All rights reserved.
+@AUTHOR: ASJRD018
+@NAME: Ansjer
+@software: PyCharm
+@DATE: 2018/6/7 9:27
+@Version: python3.6
+@MODIFY DECORD:ansjer dev
+@file: EquipmentStat.py
+@Contact: chanjunkai@163.com
+"""
+from django.views.decorators.csrf import csrf_exempt
+from Model.models import Device_Info
+from django.utils import timezone
+from Service.CommonService import CommonService
+from Service.ResponseService import *
+'''
+http://192.168.136.45:8077/device/online?UID=C2887N9EBS87ZAT1111A
+http://192.168.136.45:8077/device/offline?UID=C2887N9EBS87ZAT1111A
+http://192.168.136.45:8077/device/updateIP?UID=C2887N9EBS87ZAT1111A?ip=190.9.194.216
+'''
+
+
+@csrf_exempt
+def EquipmentOnline(request, *callback_args, **callback_kwargs):
+    if request.method == 'GET':
+        request.encoding = 'utf-8'
+        UID = request.GET.get('UID', None)
+    if request.method == 'POST':
+        request.encoding = 'utf-8'
+        UID = request.POST.get('UID', None)
+    device_info = Device_Info.objects.filter(UID=UID)
+    if device_info.exists():
+        try:
+            now_time = timezone.localtime(timezone.now())
+            device_info.update(Online=True, update_time=now_time)
+        except Exception as e:
+            print(repr(e))
+        return ResponseJSON(0)
+    else:
+        return ResponseJSON(13)
+
+
+@csrf_exempt
+def EquipmentOffline(request, *callback_args, **callback_kwargs):
+    if request.method == 'GET':
+        request.encoding = 'utf-8'
+        UID = request.GET.get('UID', None)
+    if request.method == 'POST':
+        request.encoding = 'utf-8'
+        UID = request.POST.get('UID', None)
+    device_info = Device_Info.objects.filter(UID=UID)
+    if device_info.exists():
+        try:
+            device_info.update(Online=False)
+        except Exception as e:
+            print(repr(e))
+        return ResponseJSON(0)
+    else:
+        return ResponseJSON(13)
+
+
+@csrf_exempt
+def updateIP(request, *callback_args, **callback_kwargs):
+    if request.method == 'GET':
+        request.encoding = 'utf-8'
+        UID = request.GET.get('UID', None)
+        ip = request.GET.get('ip', None)
+    if request.method == 'POST':
+        request.encoding = 'utf-8'
+        UID = request.POST.get('UID', None)
+        ip = request.POST.get('ip', None)
+    device_info = Device_Info.objects.filter(UID=UID)
+    if device_info.exists():
+        area = ''
+        try:
+            # area = MiscellService.getArea(ip)
+            area = CommonService.getAddr(ip=ip)
+            device_info.update(ip=ip, area=area)
+        except Exception as e:
+            print(repr(e))
+        return ResponseJSON(0,{'area': area})
+    else:
+        return ResponseJSON(13)

Controller/FeedBackInfo.py

@@ -0,0 +1,191 @@
+from django.views.generic.base import View
+from django.utils.decorators import method_decorator
+from django.views.decorators.csrf import csrf_exempt
+from Service.TokenManager import JSONTokenManager
+from Service.ModelService import ModelService
+from Model.models import Feedback_Info
+from django.utils import timezone
+import traceback
+from Service.ResponseService import *
+'''
+http://192.168.136.45:8077/feedbackInfo?operation=add&token=test&content=12341234
+http://192.168.136.45:8077/feedbackInfo?operation=query&token=test&page=1&line=10
+http://192.168.136.45:8077/feedbackInfo?operation=update&token=test&id=1&content=gggggggggggggggg
+http://192.168.136.45:8077/feedbackInfo?operation=delete&token=test&id=11&id=13&id=14
+
+http://192.168.136.40:8077/feedbackInfo?operation=queryAll&token=test&page=1&line=5
+http://192.168.136.45:8077/feedbackInfo?operation=deleteByAdmin&token=test&id=11&id=13&id=14
+http://192.168.136.45:8077/feedbackInfo?operation=deleteByAdmin&token=test&id=11&id=13&id=14
+http://192.168.136.45:8077/feedbackInfo?operation=updateByAdmin&token=test&id=1&status=1
+'''
+
+
+class FeedBackInfo(View):
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(FeedBackInfo, self).dispatch(*args, **kwargs)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        return self.validation(request_dict=request.GET)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        return self.validation(request_dict=request.POST)
+
+    def validation(self, request_dict, *args, **kwargs):
+        token = request_dict.get('token', None)
+        if token is not None:
+            tokenManager = JSONTokenManager()
+            error_code = tokenManager.verify_AToken(token)
+            if error_code == 0:
+                userID = tokenManager.accessDict.get('userID', None)
+                operation = request_dict.get('operation', None)
+                param_flag = CommonService.get_param_flag(data=[userID, operation])
+                if param_flag is True:
+                    if operation == 'query':
+                        return self.query_info(request_dict=request_dict, userID=userID)
+                    elif operation == 'add':
+                        return self.add_info(request_dict=request_dict, userID=userID)
+                    elif operation == 'update':
+                        return self.update_info(request_dict=request_dict,userID=userID)
+                    elif operation == 'delete':
+                        return self.delete_info(request_dict=request_dict, userID=userID)
+                    elif operation == 'queryAll':
+                        return self.query_all_info(request_dict=request_dict,userID=userID)
+                    elif operation == 'deleteByAdmin':
+                        return self.delete_by_admin(request_dict=request_dict,userID=userID)
+                    elif operation == 'updateByAdmin':
+                        return self.update_by_admin(request_dict=request_dict,userID=userID)
+                return ResponseJSON(444)
+            else:
+                return HttpResponse(tokenManager.errorCodeInfo(error_code))
+        else:
+            return ResponseJSON(311)
+
+    def add_info(self, request_dict, userID):
+        content = request_dict.get('content', None)
+        param_flag = CommonService.get_param_flag(data=[content])
+        if param_flag is True:
+            try:
+                feedback_info = Feedback_Info(
+                    userID=userID,
+                    content=content,
+                )
+                feedback_info.save()
+            except Exception:
+                errorInfo = traceback.format_exc()
+                print(errorInfo)
+                return ResponseJSON(424, {'details': errorInfo})
+            else:
+                print(type(feedback_info.add_time))
+                return ResponseJSON(0,{'id':feedback_info.id})
+        return ResponseJSON(444)
+
+    def query_info(self, request_dict, userID):
+        page = int(request_dict.get('page', None))
+        line = int(request_dict.get('line', None))
+        param_flag = CommonService.get_param_flag(data=[page, line])
+        if param_flag is True:
+            feedback_info_queryset = Feedback_Info.objects.filter(userID=userID).order_by('-id')
+            if feedback_info_queryset.exists():
+                count = feedback_info_queryset.count()
+                res = feedback_info_queryset[(page - 1) * line:page * line]
+                send_json = CommonService.query_set_to_dict(res)
+                send_json['count'] = count
+                return ResponseJSON(0, send_json)
+            return ResponseJSON(0, {'datas': [], 'count': 0})
+        else:
+            return ResponseJSON(444)
+
+    def update_info(self, request_dict, userID):
+        content = request_dict.get('content', None)
+        id = request_dict.get('id',None)
+
+        param_flag = CommonService.get_param_flag(data=[id, content])
+        if param_flag is True:
+            try:
+                feedback_info = Feedback_Info.objects.get(userID=userID, id=id)
+                feedback_info.content = content
+                feedback_info.save()
+            except Exception as e:
+                return ResponseJSON(302, {'details': repr(e)})
+            else:
+                now_time = timezone.localtime(timezone.now())
+                return ResponseJSON(0, {'update_success': 1,
+                                                                                   'update_time': str(now_time)})
+        else:
+            return ResponseJSON(444)
+
+    def delete_info(self, request_dict, userID):
+        id_list = request_dict.getlist('id',None)
+        param_flag = CommonService.get_param_flag(data=[id_list])
+        if param_flag is True:
+            is_delete = Feedback_Info.objects.filter(id__in=id_list, userID=userID).delete()
+            return ResponseJSON(0,{'delete_count':is_delete[0]})
+        else:
+            return ResponseJSON(444)
+
+    def query_all_info(self, request_dict, userID):
+        page = int(request_dict.get('page', None))
+        line = int(request_dict.get('line', None))
+        order = request_dict.get('order','-id')
+        status = request_dict.get('status',None)
+        if order == '':
+            order ='-id'
+        param_flag = CommonService.get_param_flag(data=[page, line])
+        if param_flag is True:
+            check_perm = ModelService.check_permission(userID=userID,permID=30)
+            if check_perm is True:
+                if status is not None:
+                    feedback_info_queryset = Feedback_Info.objects.filter(status=status).order_by(order)
+                else:
+                    feedback_info_queryset = Feedback_Info.objects.all().order_by(order)
+                if feedback_info_queryset.exists():
+                    count = feedback_info_queryset.count()
+                    res = feedback_info_queryset[(page - 1) * line:page * line]
+                    send_json = CommonService.query_set_to_dict(res)
+                    for k, v in enumerate(send_json["datas"]):
+                        username = ModelService.get_user_name(userID=send_json["datas"][k]['fields']['userID'])
+                        send_json["datas"][k]['fields']['username']=username
+                    send_json['count'] = count
+                    return ResponseJSON(0, send_json)
+                return ResponseJSON(0, {'datas': [], 'count': 0})
+            else:
+                return ResponseJSON(404)
+        else:
+            return ResponseJSON(444)
+
+    def delete_by_admin(self, request_dict, userID):
+        id_list = request_dict.getlist('id', None)
+        param_flag = CommonService.get_param_flag(data=[id_list])
+        if param_flag is True:
+            check_perm = ModelService.check_permission(userID=userID, permID=10)
+            if check_perm is True:
+                is_delete = Feedback_Info.objects.filter(id__in=id_list).delete()
+                return ResponseJSON(0, {'delete_count': is_delete[0]})
+            else:
+                return ResponseJSON(404)
+        else:
+            return ResponseJSON(444)
+
+    def update_by_admin(self, request_dict, userID):
+        id = request_dict.get('id',None)
+        status = request_dict.get('status',None)
+        param_flag = CommonService.get_param_flag(data=[id, status])
+        if param_flag is True:
+            check_perm = ModelService.check_permission(userID=userID, permID=50)
+            if check_perm is True:
+                try:
+                    feedback_info = Feedback_Info.objects.get(id=id)
+                    feedback_info.status = status
+                    feedback_info.save()
+                except Exception as e:
+                    return ResponseJSON(302, {'details': repr(e)})
+                else:
+                    now_time = timezone.localtime(timezone.now())
+                    return ResponseJSON(0, {'update_id': feedback_info.id,'update_time':str(now_time)})
+            else:
+                return ResponseJSON(404)
+        else:
+            return ResponseJSON(444)

Controller/HlsManage.py

@@ -0,0 +1,240 @@
+#!/usr/bin/env python3  
+# -*- coding: utf-8 -*-  
+"""
+@Copyright (C) ansjer cop Video Technology Co.,Ltd.All rights reserved.
+@AUTHOR: ASJRD018
+@NAME: Ansjer
+@software: PyCharm
+@DATE: 2018/5/30 17:53
+@Version: python3.6
+@MODIFY DECORD:ansjer dev
+@file: HlsManage.py
+@Contact: chanjunkai@163.com
+"""
+from django.views.generic.base import View
+from django.utils.decorators import method_decorator
+from django.views.decorators.csrf import csrf_exempt
+from Service.TokenManager import JSONTokenManager
+from Service.ModelService import ModelService
+from Service.CommonService import CommonService
+from Model.models import Device_Meal
+from Object.AWS.S3ClassObject import S3ClassObject
+from Object.AWS.CloudfrontSignUrl import CloudfrontSignUrl
+from Object.encryHlsVodUrl import getSignUrl
+from Object.m3u8generate import PlaylistGenerator
+from Service.ResponseService import *
+'''
+设备端
+http://13.56.215.252:82/HlsManager?operation=signPutObj&key=555666.mp4&uid=L59KVYDAEPHR1T6M111A&channel=0
+http://13.56.215.252:82/HlsManager?operation=signPostObj&key=ppp.mp4&uid=L59KVYDAEPHR1T6M111A&channel=0
+移动端
+http://13.56.215.252:82/HlsManager?operation=getHlsVod&uid=L59KVYDAEPHR1T6M111A&channel=0&token=test&key=234234234.ts
+http://13.56.215.252:82/HlsManager?operation=getAllTs&uid=L59KVYDAEPHR1T6M111A&channel=0&token=test
+http://13.56.215.252:82/HlsManager?operation=getVodUrl&uid=L59KVYDAEPHR1T6M111A&channel=0&token=test&key=121212.mp4
+'''
+
+
+class HlsManage(View):
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(HlsManage, self).dispatch(*args, **kwargs)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        return self.validation(request_dict=request.GET)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        return self.validation(request_dict=request.POST)
+
+    def validation(self, request_dict, *args, **kwargs):
+        operation = request_dict.get('operation', None)
+        if operation is not None:
+            if operation == 'signPutObj':
+                return self.sign_put_obj(request_dict=request_dict)
+            elif operation == 'signPostObj':
+                return self.sign_post_obj(request_dict=request_dict)
+            elif operation == 'getHlsVod':
+                return self.get_hls_vod(request_dict=request_dict)
+            elif operation == 'getAllTs':
+                return self.get_all_ts(request_dict=request_dict)
+            elif operation == 'getVodUrl':
+                return self.get_vod_url(request_dict=request_dict)
+        return ResponseJSON(444)
+
+    def sign_put_obj(self, request_dict):
+        key = request_dict.get('key', None)
+        uid = request_dict.get('uid', None)
+        channel = request_dict.get('channel', None)
+        param_flag = CommonService.get_param_flag(data=[key, uid, channel])
+        if param_flag is True:
+            device_meal_queryset = Device_Meal.objects.filter(uid=uid, channel=channel, status=1)
+            if device_meal_queryset.exists():
+                path = uid + '_' + channel + '/' + key
+                meal_id = device_meal_queryset[0].rank_id
+                bucket_meal={
+                    1:'ansjer.meal.1',# 7
+                    2:'ansjer.meal.2',# 30
+                    # 3:'ansjer.meal.3',
+                }
+                s3 = S3ClassObject()
+                sign_url = s3.sign_put_object(key=path, bucket_meal=bucket_meal[meal_id])
+                if sign_url is not False:
+                    return ResponseJSON(0, {'url': sign_url})
+                else:
+                    return ResponseJSON(48)
+            else:
+                return ResponseJSON(444)
+        else:
+            return ResponseJSON(444)
+
+    def sign_post_obj(self, request_dict):
+        key = request_dict.get('key', None)
+        uid = request_dict.get('uid', None)
+        channel = request_dict.get('channel', None)
+        param_flag = CommonService.get_param_flag(data=[key, uid, channel])
+        if param_flag is True:
+            device_meal_queryset = Device_Meal.objects.filter(uid=uid, channel=channel, status=1)
+            if device_meal_queryset.exists():
+                path = uid + '_' + channel + '/' + key
+                meal_id = device_meal_queryset[0].rank_id
+                bucket_meal = {
+                    1: 'ansjer.meal.1',  # 7
+                    2: 'ansjer.meal.2',  # 30
+                    # 3:'ansjer.meal.3',
+                }
+                s3 = S3ClassObject()
+                data = s3.sign_post_object(key=path, bucket_meal=bucket_meal[meal_id])
+                if data is not False:
+                    return ResponseJSON(0, {'url': data})
+                else:
+                    return ResponseJSON(48)
+            else:
+                return ResponseJSON(444)
+        else:
+            return ResponseJSON(444)
+
+    def get_all_ts(self, request_dict):
+        token = request_dict.get('token', None)
+        if token is not None:
+            tokenManager = JSONTokenManager()
+            error_code = tokenManager.verify_AToken(token)
+            if error_code == 0:
+                uid = request_dict.get('uid', None)
+                channel = request_dict.get('channel', None)
+                userID = tokenManager.accessDict.get('userID', None)
+                param_flag = CommonService.get_param_flag(data=[userID, uid, channel])
+                if param_flag is True:
+                    own_permission = ModelService.check_permission(userID=userID, permID=30)
+                    own_device = ModelService.check_own_device(userID=userID, UID=uid)
+                    if own_permission is True or own_device is True:
+                        device_meal_queryset = Device_Meal.objects.filter(uid=uid, channel=channel, status=1)
+                        if device_meal_queryset.exists():
+                            meal_id = device_meal_queryset[0].rank_id
+                            bucket_meal = {
+                                1: 'ansjer.meal.1',  # 7
+                                2: 'ansjer.meal.2',  # 30
+                            }
+                            s3 = S3ClassObject()
+                            data = s3.get_prefix_obj(prefix=uid + '_' + channel + '/', bucket=bucket_meal[meal_id])
+                            # return ResponseJSON(0, {'files': data,'bk':bucket_meal[meal_id]})
+                            return ResponseJSON(0, {'files': data})
+                        else:
+                            return ResponseJSON(444)
+                    else:
+                        return ResponseJSON(404)
+                else:
+                    return ResponseJSON(444)
+            else:
+                return HttpResponse(tokenManager.errorCodeInfo(error_code))
+        else:
+            return ResponseJSON(311)
+
+    def get_hls_vod(self, request_dict):
+        token = request_dict.get('token', None)
+        if token is not None:
+            tokenManager = JSONTokenManager()
+            error_code = tokenManager.verify_AToken(token)
+            if error_code == 0:
+                key = request_dict.get('key', None)
+                uid = request_dict.get('uid', None)
+                channel = request_dict.get('channel', None)
+                userID = tokenManager.accessDict.get('userID', None)
+                param_flag = CommonService.get_param_flag(data=[userID, key, uid, channel])
+                if param_flag is True:
+                    own_device = ModelService.check_own_device(userID=userID, UID=uid)
+                    if own_device is True:
+                        device_meal_queryset = Device_Meal.objects.filter(uid=uid, channel=channel, status=1)
+                        if device_meal_queryset.exists():
+                            meal_id = device_meal_queryset[0].rank_id
+                            cf_domain = {
+                                1: 'http://d3om3d8c0l14oc.cloudfront.net/',
+                                2:'http://d4neaolnu8h83.cloudfront.net/',
+                            }
+                            url = cf_domain[meal_id]+uid + '_' + channel + '/' + key
+                            # url = 'http://d3om3d8c0l14oc.cloudfront.net/'+uid + '_' + channel + '/' + key
+                            sign_url = CloudfrontSignUrl(url=url)
+                            playlist_entries = [
+                                {
+                                    'name': sign_url,
+                                    'duration': '60',
+                                }
+                            ]
+                            playlist = PlaylistGenerator(playlist_entries).generate()
+                            response = HttpResponse(content_type='application/force-download',content=playlist)
+                            response['Content-Disposition'] = 'attachment; filename='+key+'.m3u8'
+                            # response['X-Sendfile'] = playlist
+                            # return ResponseJSON(404)
+                            return response
+                            # return HttpResponse(playlist)
+                        else:
+                            return ResponseJSON(0)
+                    else:
+                        return ResponseJSON(15)
+                else:
+                    return ResponseJSON(444)
+            else:
+                return HttpResponse(tokenManager.errorCodeInfo(error_code))
+        else:
+            return ResponseJSON(311)
+
+    # mp4
+    def get_vod_url(self, request_dict):
+        token = request_dict.get('token', None)
+        if token is not None:
+            tokenManager = JSONTokenManager()
+            error_code = tokenManager.verify_AToken(token)
+            if error_code == 0:
+                key = request_dict.get('key', None)
+                uid = request_dict.get('uid', None)
+                channel = request_dict.get('channel', None)
+                userID = tokenManager.accessDict.get('userID', None)
+                param_flag = CommonService.get_param_flag(data=[userID, key, uid, channel])
+                if param_flag is True:
+                    own_device = ModelService.check_own_device(userID=userID, UID=uid)
+                    if own_device is True:
+                        device_meal_queryset = Device_Meal.objects.filter(uid=uid, channel=channel, status=1)
+                        if device_meal_queryset.exists():
+                            meal_id = device_meal_queryset[0].rank_id
+                            bucket_meal = {
+                                1: 'ansjer.meal.1',  # 7
+                                2: 'ansjer.meal.2',  # 30
+                            }
+                            bk = bucket_meal[meal_id]
+                            path = '/'+bk+'/'+uid+'_'+channel+'/'+key
+                            signUrl = getSignUrl(path=path)
+                            return ResponseJSON(0,{'signUrl':signUrl})
+                        else:
+                            return ResponseJSON(0)
+                    else:
+                        return ResponseJSON(15)
+                else:
+                    return ResponseJSON(444)
+            else:
+                return HttpResponse(tokenManager.errorCodeInfo(error_code))
+        else:
+            return ResponseJSON(311)
+
+
+
+

Controller/LogAccess.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3  
+# -*- coding: utf-8 -*-  
+"""
+@Copyright (C) ansjer cop Video Technology Co.,Ltd.All rights reserved.
+@AUTHOR: ASJRD018
+@NAME: Ansjer
+@software: PyCharm
+@DATE: 2018/6/22 11:42
+@Version: python3.6
+@MODIFY DECORD:ansjer dev
+@file: LogAccess.py
+@Contact: chanjunkai@163.com
+"""
+from Service.TokenManager import JSONTokenManager
+from Service.CommonService import CommonService
+from Service.ModelService import ModelService
+from Object.mongodb import mongodb
+from django.views.decorators.csrf import csrf_exempt
+from var_dump import var_dump
+from Service.ResponseService import *
+
+@csrf_exempt
+def LogAccess(request):
+    # 查找设备日志
+    if request.method == 'GET':
+        request.encoding = 'utf-8'
+        token = request.GET.get('token', None)
+        page = request.GET.get('page', None)
+        line = request.GET.get('line', None)
+        # order = request.GET.get('order', None)
+        # 开始时间
+        starttime = request.GET.get('starttime', None)
+        # 结束时间
+        endtime = request.GET.get('endtime', None)
+        if token is not None:
+            tokenManager = JSONTokenManager()
+            error_code = tokenManager.verify_AToken(token)
+            if error_code == 0:
+                userID = tokenManager.accessDict.get('userID', None)
+                param_flag = CommonService.get_param_flag(data=[userID, page, line])
+                if param_flag is True:
+                    own_per = ModelService.check_permission(userID=userID, permID=30)
+                    if own_per is True:
+                        query = {}
+                        if starttime is not None and starttime != '' and endtime is not None and endtime != '':
+                            query['time'] = {'$gte': int(starttime),'$lte': int(endtime)}
+                        elif starttime is not None and starttime != '':
+                            query['time'] = {'$gte': int(starttime)}
+                        elif endtime is not None and endtime != '':
+                            query['time'] = {'$lte': int(endtime)}
+                        var_dump(query)
+                        col = "log_access"
+                        mdb = mongodb()
+                        qs = mdb.findAll(col=col, page=int(page), line=int(line), query=query)
+                        return ResponseJSON(0,qs)
+                    else:
+                        return ResponseJSON(404)
+                else:
+                    return ResponseJSON(444)
+            else:
+                return HttpResponse(tokenManager.errorCodeInfo(error_code))
+        else:
+            return ResponseJSON(311)

Controller/LogManager.py

@@ -0,0 +1,270 @@
+from Controller import OTAEquipment
+from django.views.decorators.csrf import csrf_exempt
+from django.views.generic import TemplateView
+from django.utils.decorators import method_decorator
+import Ansjer.settings as api_settings
+from Service.ModelService import ModelService
+import time
+from Service.ResponseService import *
+from Ansjer.config import *
+from Service.TokenManager import JSONTokenManager
+
+
+def StatisticsData(request):
+    print('------request------')
+
+    print(request)
+    print('---------------')
+    try:
+        real_ip = request.META['HTTP_X_FORWARDED_FOR']
+        clientIP = real_ip.split(",")[0]
+    except:
+        try:
+            clientIP = request.META['REMOTE_ADDR']
+        except Exception as e:
+            clientIP = ''
+
+    nowTime = time.strftime('%Y-%m-%d', time.localtime(time.time()))
+
+    print(u'当前用户: %s , 访问时间: %s' % (clientIP, nowTime))
+
+    print(u'~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
+    for cookKey, cookValue in request.COOKIES.items():
+        print("COOKIES:", cookKey, cookValue)
+
+    for sessionKey, sessionValue in request.session.items():
+        print("session:", sessionKey, sessionValue)
+
+    print('HTTP_COOKIE', request.META.get('HTTP_COOKIE', 'unknown'))
+    print('CSRF_COOKIE', request.META.get('CSRF_COOKIE', 'unknown'))
+
+    print('user', request.user)
+
+    print(u'~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
+
+    # print("body:", request.body)
+    print('path', request.path)
+    print('path_info', request.path_info)
+
+    print('encoding', request.encoding)
+    print('resolver_match', request.resolver_match)
+
+    for fileKey, fileValue in request.FILES.items():
+        print("FILES:", fileKey, fileValue)
+    #print('META', request.META)
+
+    print(u'******************************************************')
+    print('DOCUMENT_ROOT', request.META.get('DOCUMENT_ROOT', 'unknown'))
+    print('QUERY_STRING: ', request.META.get('QUERY_STRING', 'unknown'))
+    print('REMOTE_ADDR', request.META.get('REMOTE_ADDR', 'unknown'))
+    print('HTTP_HOST', request.META.get('HTTP_HOST', u'unknown'))
+    print('HTTP_REFERER', request.META.get('HTTP_REFERER', 'unknown'))
+    print('HTTP_COOKIE', request.META.get('HTTP_COOKIE', 'unknown'))
+    print('CSRF_COOKIE', request.META.get('CSRF_COOKIE', 'unknown'))
+    print('HTTP_CONNECTION', request.META.get('HTTP_CONNECTION', 'unknown'))
+    print('wsgi.errors', request.META.get('wsgi.errors', 'unknown'))
+    print('mod_wsgi.application_group', request.META.get('mod_wsgi.application_group', 'unknown'))
+    print('mod_wsgi.callable_object', request.META.get('mod_wsgi.callable_object', 'unknown'))
+    print('mod_wsgi.listener_host', request.META.get('mod_wsgi.listener_host', 'unknown'))
+    print('mod_wsgi.listener_port', request.META.get('mod_wsgi.listener_port', 'unknown'))
+    print('mod_wsgi.process_group', request.META.get('mod_wsgi.process_group', 'unknown'))
+    print('mod_wsgi.reload_mechanism', request.META.get('mod_wsgi.reload_mechanism', 'unknown'))
+    print('mod_wsgi.script_reloading', request.META.get('mod_wsgi.script_reloading', 'unknown'))
+    print('mod_wsgi.version', request.META.get('mod_wsgi.version', 'unknown'))
+    print('PATH', request.META.get('PATH', 'unknown'))
+    print('PATH_INFO', request.META.get('PATH_INFO', 'unknown'))
+    print('PATH_TRANSLATED', request.META.get('PATH_TRANSLATED', 'unknown'))
+    print('QUERY_STRING', request.META.get('QUERY_STRING', 'unknown'))
+    print('QUERY_STRING', request.META.get('REMOTE_ADDR', 'unknown'))
+    print('REMOTE_PORT', request.META.get('REMOTE_PORT', 'unknown'))
+    print('REQUEST_METHOD', request.META.get('REQUEST_METHOD', 'unknown'))
+    print('REQUEST_URI', request.META.get('REQUEST_URI', 'unknown'))
+    print('SCRIPT_FILENAME', request.META.get('SCRIPT_FILENAME', 'unknown'))
+    print('SCRIPT_NAME', request.META.get('SCRIPT_NAME', 'unknown'))
+    print('SERVER_ADDR', request.META.get('SERVER_ADDR', 'unknown'))
+    print('SERVER_ADMIN', request.META.get('SERVER_ADMIN', 'unknown'))
+    print('SERVER_NAME', request.META.get('SERVER_NAME', 'unknown'))
+    print('SERVER_PORT', request.META.get('SERVER_PORT', 'unknown'))
+    print('SERVER_PROTOCOL', request.META.get('SERVER_PROTOCOL', 'unknown'))
+    print('SERVER_SIGNATURE', request.META.get('SERVER_SIGNATURE', 'unknown'))
+    print('SERVER_SOFTWARE', request.META.get('SERVER_SOFTWARE', 'unknown'))
+    print('wsgi.input', request.META.get('wsgi.input', 'unknown'))
+    print('wsgi.multiprocess', request.META.get('wsgi.multiprocess', 'unknown'))
+    print('wsgi.multithread', request.META.get('wsgi.multithread', 'unknown'))
+    print('wsgi.run_once', request.META.get('wsgi.run_once', 'unknown'))
+    print('wsgi.url_scheme', request.META.get('wsgi.url_scheme', 'unknown'))
+    print('wsgi.version', request.META.get('wsgi.version', 'unknown'))
+    print('get_host', request.get_host())
+    print('get_full_path', request.get_full_path())
+    print('build_absolute_uri', request.build_absolute_uri())
+    print('is_secure', request.is_secure())
+    print('is_ajax', request.is_ajax())
+    print(u'******************************************************')
+
+    print('CONTENT_LENGTH: ', request.META.get('CONTENT_LENGTH', 'unknown'))
+    print('CONTENT_TYPE', request.META.get('CONTENT_TYPE', 'unknown'))
+    print('HTTP_ACCEPT', request.META.get('HTTP_ACCEPT', 'unknown'))
+    print('HTTP_ACCEPT_ENCODING', request.META.get('HTTP_ACCEPT_ENCODING', 'unknown'))
+    print('REMOTE_HOST', request.META.get('REMOTE_HOST', 'unknown'))
+    print('REMOTE_USER', request.META.get('REMOTE_USER', 'unknown'))
+    print('REQUEST_METHOD', request.META.get('REQUEST_METHOD', 'unknown'))
+    print('SERVER_NAME', request.META.get('SERVER_NAME', 'unknown'))
+    print('SERVER_PORT', request.META.get('SERVER_PORT', 'unknown'))
+    print('HTTP_USER_AGENT', request.META.get('HTTP_USER_AGENT', 'unknown'))
+    print('HTTP_AUTHORIZATION', request.META.get('HTTP_AUTHORIZATION', b'unknown'))
+
+class HelpView(TemplateView):
+    '''
+    帮助说明，包括版本信息，帮助文件等
+    '''
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(HelpView, self).dispatch(*args, **kwargs)
+
+    def get(self, request, *args, **kwargs):
+        reInfoType = request.GET.get('reInfoType', None)
+        token = request.GET.get('token', None)
+
+        return self.getRequestInfo(reInfoType,token)
+
+    def post(self, request, *args, **kwargs):
+        reInfoType = request.POST.get('reInfoType', None)
+        token = request.POST.get('token', None)
+        return self.getRequestInfo(reInfoType,token)
+
+    def getRequestInfo(self, reInfoType,token):
+        if reInfoType is not None and token is not None:
+            tokenManager = JSONTokenManager()
+            error_code = tokenManager.verify_AToken(token)
+            if error_code == 0:
+                userID = tokenManager.accessDict.get('userID', None)
+                own_permission = ModelService.check_permission(userID=userID, permID=30)
+                if own_permission is True:
+                    vInfo = versionInfo()
+                    if reInfoType == 'version':
+                        response = HttpResponse(vInfo.readInfo())
+                        return response
+                    elif reInfoType == 'requirements':
+                        response = HttpResponse(vInfo.requirementsInfo())
+                        return response
+                    elif reInfoType == 'helpfile':
+                        response = vInfo.getHelpCHM()
+                        return response
+                    else:
+                        return ResponseJSON(801)
+                else:
+                    return ResponseJSON(404)
+            else:
+                return HttpResponse(tokenManager.errorCodeInfo(error_code))
+        else:
+            return ResponseJSON(800)
+
+class versionInfo:
+    def __init__(self):
+        return
+
+    def readInfo(self):
+        verfilePath = '/'.join((api_settings.BASE_DIR, 'static/Help/')).replace('\\', '/') + 'version.txt'
+        if os.path.isfile(verfilePath):
+            file = open(verfilePath, encoding='utf-8')
+            versionStr = ''
+            for line in file:
+                versionStr += line
+            return ResponseFormal(0,{'versioninfo':versionStr})
+        else:
+            return ResponseFormal(701)
+
+    def requirementsInfo(self):
+        requirementsPath = '/'.join((api_settings.BASE_DIR, 'requirements.txt')).replace('\\', '/')
+        print(requirementsPath)
+        if os.path.isfile(requirementsPath):
+            file = open(requirementsPath, encoding='utf-8')
+            requirementsStr = ''
+            for line in file:
+                requirementsStr += line
+            return ResponseFormal(0,{'requirementsinfo': requirementsStr})
+        else:
+            return ResponseFormal(701)
+
+    def getHelpCHM(self):
+        verHelpCHM = '/'.join((api_settings.BASE_DIR, 'static/Help/')).replace('\\', '/') + 'AnsjerHelp.CHM'
+        print(verHelpCHM)
+        if os.path.isfile(verHelpCHM):
+            return OTAEquipment.downloadUrl(fileType='CHM', fileCode='', fileVersion='', fileName=verHelpCHM)
+        else:
+            return ResponseFormal(code=701)
+
+from django.core.cache import cache
+class ZxMiddleware(object):
+    def __init__(self):
+        self.online_ips = ()
+        self.online_count = 0
+
+    def process_request(self, request):
+        if 'HTTP_X_FORWARDED_FOR' in request.META:
+            ip = request.META['HTTP_X_FORWARDED_FOR']
+        else:
+            ip = request.META['REMOTE_ADDR']
+        online_ips = cache.get("online_ips", [])
+        if online_ips:
+            online_ips = cache.get_many(online_ips).keys()
+        cache.set(ip, 0, 15 * 60)
+        if ip not in online_ips:
+            online_ips.append(ip)
+        cache.set("online_ips", online_ips)
+
+def get_online_count():
+    online_ips = cache.get("online_ips", [])
+    if online_ips:
+        online_ips = cache.get_many(online_ips).keys()
+        return len(online_ips)
+    return 0
+
+class BlockedIpMiddleware3:
+    def __init__(self, get_response):
+        print(get_response, 'dddddddddddddd')
+        self.get_response = get_response
+        # One-time configuration and initialization.
+
+    def __call__(self, request):
+        # Code to be executed for each request before
+        # the view (and later middleware) are called.
+        print('sdcall', request)
+        response = self.get_response(request)
+
+        # Code to be executed for each request/response after
+        # the view is called.
+        return response
+
+@csrf_exempt
+def upload_help_chm(request):
+    token = request.POST.get('token', None)
+    if token is not None:
+        tokenManager = JSONTokenManager()
+        error_code = tokenManager.verify_AToken(token)
+        if error_code == 0:
+            userID = tokenManager.accessDict.get('userID', None)
+            own_permission = ModelService.check_permission(userID=userID, permID=30)
+            if own_permission is True:
+                f = request.FILES.get('file', None)
+                path = os.path.join(BASE_DIR, 'static/Help/AnsjerHelp.CHM')
+                try:
+                    if os.path.exists(path):
+                        os.remove(path)
+                    with open(path, 'wb+') as destination:
+                        for chunk in f.chunks():
+                            destination.write(chunk)
+                except Exception as e:
+                    print('error:' + repr(e))
+                    return ResponseJSON(700,{'details': repr(e)})
+                return ResponseJSON(0)
+            else:
+                return ResponseJSON(404)
+        else:
+            return HttpResponse(tokenManager.errorCodeInfo(error_code))
+    else:
+        return ResponseJSON(311)
+
+@csrf_exempt
+def errorPath(request,**kwargs):
+    return ResponseFormal(414)

Controller/MealManage.py

@@ -0,0 +1,203 @@
+#!/usr/bin/env python3  
+# -*- coding: utf-8 -*-  
+"""
+@Copyright (C) ansjer cop Video Technology Co.,Ltd.All rights reserved.
+@AUTHOR: ASJRD018
+@NAME: Ansjer
+@software: PyCharm
+@DATE: 2018/5/29 17:07
+@Version: python3.6
+@MODIFY DECORD:ansjer dev
+@file: MealManage.py
+@Contact: chanjunkai@163.com
+"""
+from django.shortcuts import HttpResponse
+from django.views.generic.base import View
+from django.utils.decorators import method_decorator
+from django.views.decorators.csrf import csrf_exempt
+from Service.TokenManager import JSONTokenManager
+from Service.ModelService import ModelService
+from Service.CommonService import CommonService
+from Model.models import Store_Meal
+import traceback
+from django.utils import timezone
+from Service.ResponseService import ResponseJSON
+'''
+http://192.168.136.40:8077/meal/manage?operation=add&token=test&title=套餐A&price=$199&content=存7天&day=7&id=1
+http://192.168.136.45:8077/meal/manage?operation=update&token=test&id=1&title=套餐A&price=$199&content=存3天&day=7
+http://192.168.136.40:8077/meal/manage?operation=query&token=test&page=1&line=10
+http://192.168.136.40:8077/meal/manage?operation=delete&token=test&id=1&id=2&id=3&id=4&id=5
+'''
+
+
+class MealManage(View):
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(MealManage, self).dispatch(*args, **kwargs)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        return self.validation(request_dict=request.GET)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        return self.validation(request_dict=request.POST)
+
+    def validation(self, request_dict, *args, **kwargs):
+        operation = request_dict.get('operation', None)
+        if operation is not None:
+            token = request_dict.get('token', None)
+            if token is not None:
+                tokenManager = JSONTokenManager()
+                error_code = tokenManager.verify_AToken(token)
+                if error_code == 0:
+                    userID = tokenManager.accessDict.get('userID', None)
+                    param_flag = CommonService.get_param_flag(data=[userID])
+                    if param_flag is True:
+                        if operation == 'query':
+                            return self.query(request_dict=request_dict)
+                        elif operation == 'add':
+                            return self.add(request_dict=request_dict, userID=userID)
+                        elif operation == 'update':
+                            return self.update(request_dict=request_dict, userID=userID)
+                        elif operation == 'delete':
+                            return self.delete(request_dict=request_dict, userID=userID)
+                        elif operation == 'find':
+                            return self.find(request_dict=request_dict, userID=userID)
+                    return ResponseJSON(444)
+                else:
+                    return HttpResponse(tokenManager.errorCodeInfo(error_code))
+            else:
+                return ResponseJSON(311)
+        else:
+            return ResponseJSON(444)
+
+    def add(self, request_dict, userID):
+        own_perm = ModelService.check_permission(userID=userID, permID=40)
+        if own_perm is True:
+            title = request_dict.get('title', None)
+            id = request_dict.get('id', None)
+            price = request_dict.get('price', None)
+            content = request_dict.get('content', None)
+            day = request_dict.get('day', None)
+            param_flag = CommonService.get_param_flag(data=[title, price, content])
+            if param_flag is True:
+                try:
+                    store_meal = Store_Meal(
+                        id = id,
+                        title=title,
+                        price=price,
+                        content=content,
+                        day=day,
+                    )
+                    store_meal.save()
+                except Exception:
+                    errorInfo = traceback.format_exc()
+                    print(errorInfo)
+                    return ResponseJSON(500, {'details': errorInfo})
+                else:
+                    if store_meal.id:
+                        return ResponseJSON(0,
+                                                                         {
+                                                                             'id': store_meal.id,
+                                                                             'title': store_meal.title,
+                                                                             'price': store_meal.price,
+                                                                             'content': store_meal.content,
+                                                                             'day': store_meal.day,
+                                                                             'add_time': str(store_meal.add_time),
+                                                                             'update_time': str(store_meal.update_time),
+                                                                         })
+
+            return ResponseJSON(444)
+        else:
+            return ResponseJSON(404)
+
+    def query(self, request_dict):
+        page = int(request_dict.get('page', None))
+        line = int(request_dict.get('line', None))
+        param_flag = CommonService.get_param_flag(data=[page, line])
+        if param_flag is True:
+            queryset = Store_Meal.objects.all()
+            if queryset.exists():
+                count = queryset.count()
+                res = queryset[(page - 1) * line:page * line]
+                send_json = CommonService.query_set_to_dict(res)
+                send_json['count'] = count
+                return ResponseJSON(0, send_json)
+            return ResponseJSON(0)
+        else:
+            return ResponseJSON(444)
+
+    def update(self, request_dict, userID):
+        own_perm = ModelService.check_permission(userID=userID, permID=30)
+        if own_perm is True:
+            id = request_dict.get('id', None)
+            title = request_dict.get('title', None)
+            price = request_dict.get('price', None)
+            day = request_dict.get('day', None)
+            content = request_dict.get('content', None)
+
+            param_flag = CommonService.get_param_flag(
+                data=[id, title, price, content,day])
+            if param_flag is True:
+                try:
+                    store_meal = Store_Meal.objects.get(id=id)
+                except Exception:
+                    errorInfo = traceback.format_exc()
+                    print(errorInfo)
+                    return ResponseJSON(424, {'details': errorInfo})
+                else:
+                    if store_meal.id:
+                        now_time = timezone.localtime(timezone.now())
+                        print(now_time)
+                        store_meal.title = title
+                        store_meal.price = price
+                        store_meal.content = content
+                        store_meal.day = day
+                        store_meal.save()
+                        return ResponseJSON(0, {'update_id': store_meal.id,
+                                                                                           'update_time': str(now_time)})
+            else:
+                return ResponseJSON(444)
+        else:
+            return ResponseJSON(404)
+
+    def delete(self, request_dict, userID):
+        own_perm = ModelService.check_permission(userID=userID, permID=10)
+        if own_perm is True:
+            id_list = request_dict.getlist('id', None)
+            param_flag = CommonService.get_param_flag(data=[id_list])
+            if param_flag is True:
+                try:
+                    for id in id_list:
+                        Store_Meal.objects.filter(id=id).delete()
+                except Exception as e:
+                    errorInfo = traceback.format_exc()
+                    print(errorInfo)
+                    return ResponseJSON(424, {'details': repr(e)})
+                else:
+                    return ResponseJSON(0)
+            else:
+                return ResponseJSON(444)
+        else:
+            return ResponseJSON(404)
+
+    def find(self, request_dict, userID):
+        own_perm = ModelService.check_permission(userID=userID, permID=30)
+        if own_perm is True:
+            page = int(request_dict.get('page', None))
+            line = int(request_dict.get('line', None))
+            param_flag = CommonService.get_param_flag(data=[page, line])
+            if param_flag is True:
+                queryset = Store_Meal.objects.all()
+                if queryset.exists():
+                    count = queryset.count()
+                    res = queryset[(page - 1) * line:page * line]
+                    send_json = CommonService.query_set_to_dict(res)
+                    send_json['count'] = count
+                    return ResponseJSON(0, send_json)
+                return ResponseJSON(0)
+            else:
+                return ResponseJSON(444)
+        else:
+            return ResponseJSON(404)

Controller/OTAEquipment.py

@@ -0,0 +1,641 @@
+from zlib import crc32
+from Ansjer.settings import *
+from django.core import serializers
+from wsgiref.util import FileWrapper
+import traceback, hashlib
+from Ansjer.settings import SERVER_DOMAIN
+from django.views.decorators.csrf import csrf_exempt
+from django.views.generic import TemplateView
+from django.utils.decorators import method_decorator
+from Model.models import Equipment_Version
+from Model.models import Device_User
+from Service.TokenManager import JSONTokenManager
+from Service.ModelService import ModelService
+from Service.CommonService import CommonService
+from Service.ResponseService import *
+
+
+def getEquipmentVersion(code):
+    if code == '31162001A':
+        return ResponseFormal(0,{'softwareVersion': '1.4.3'})
+    try:
+        equipmentValid = Equipment_Version.objects.filter(code = code,status=1).order_by('-data_joined')
+    except Exception as e:
+        errorInfo = traceback.format_exc()
+        print('查询数据库错误: %s' % errorInfo)
+        return ResponseFormal(500,{'details':repr(e)})
+    else:
+        if equipmentValid:
+            equipment = equipmentValid[0]
+            return ResponseFormal(0, {'softwareVersion': equipment.softwareVersion})
+        else:
+            return ResponseFormal(900)
+
+
+def getUrl(filePath):
+    urls = []
+    filePaths = filePath.split(',')
+    if len(filePaths) > 0:
+        for path in filePaths:
+            if path.find('static/Upgrade/') != -1:
+                path = path.replace('static/Upgrade/', '').replace('\\', '/')
+                url = SERVER_DOMAIN + '/OTA/downloads/' + path
+                urls.append(url)
+            else:
+                url = SERVER_DOMAIN + 'OTA/downloads/' + filePath.replace('\\', '/')
+                urls.append(url)
+        return urls
+    else:
+        return ''
+
+def getUpdataFileUrl(code):
+    try:
+        equipmentValid = Equipment_Version.objects.filter(code=code,status=1).order_by('-data_joined')
+    except Exception as e:
+        errorInfo = traceback.format_exc()
+        print('查询数据库错误: %s' % errorInfo)
+        return ResponseFormal(500,{'details':repr(e)})
+    else:
+        if equipmentValid:
+            equipment = equipmentValid[0]
+            url = getUrl(equipment.filePath)
+            if len(url) > 0:
+                return ResponseFormal(0,{
+                    "urlCount": len(url),
+                    "url": url,
+                    "fileSize": equipment.fileSize,
+                    "Description": equipment.Description,
+                })
+            else:
+                return ResponseFormal(901)
+        else:
+            return ResponseFormal(902)
+
+#from django.core.files.uploadedfile import TemporaryUploadedFile
+def getDir(fileType, fileName, fileCode, fileVersion):
+    try:
+        if fileCode != None and fileVersion != None:
+            path = '/'.join((BASE_DIR, 'static/Upgrade', fileType, fileCode, fileVersion)).replace('\\', '/') + '/'
+        else:
+            if fileType != 'IPC' and fileType != 'DVR' and fileType != 'NVR' and fileType != 'XVR':
+                path = '/'.join((BASE_DIR, "static/Upgrade", 'Other')).replace('\\', '/')  + '/'
+
+        if not os.path.exists(path):
+            os.makedirs(path)
+            file_name = path + str(fileName)
+            if os.path.exists(file_name):
+                os.remove(file_name)
+            destination = open(file_name, 'wb+')
+            for chunk in fileName.chunks():
+                destination.write(chunk)
+            destination.close()
+        else:
+            file_name = path + str(fileName)
+            if os.path.exists(file_name):
+                os.remove(file_name)
+
+            destination = open(file_name, 'wb+')
+            for chunk in fileName.chunks():
+                destination.write(chunk)
+            destination.close()
+    except Exception as e:
+        errorInfo = traceback.format_exc()
+        print('上传文件错误: %s' % errorInfo)
+        return ResponseFormal(700,{'details':repr(e)})
+    else:
+        index = file_name.find('static/')
+        filePath = file_name[index:]
+        return ResponseFormal(0,{'filePath':filePath})
+
+
+def addNewEquipmentVersion(deviceContent,token):
+    """
+    :param deviceContent:
+    :return:
+    """
+    if token is None:
+        return ResponseJSON(311)
+    tokenManager = JSONTokenManager()
+    error_code = tokenManager.verify_AToken(token)
+    if error_code == 0:
+        pass
+    else:
+        return tokenManager.errorCodeInfo(error_code)
+    userID = tokenManager.accessDict.get('userID', None)
+    own_permission = ModelService.check_permission(userID=userID, permID=220)
+    if own_permission is not True:
+        # pass
+        return ResponseFormal(404)
+    try:
+        # print(deviceContent)
+        deviceData = json.loads(deviceContent)
+        print('----------')
+        print(deviceData)
+    except Exception as e:
+        return ResponseFormal(803)
+    else:
+        version = deviceData.get('version', None)
+        if version != None:
+            eVersionValid = Equipment_Version.objects.filter(version = version)
+            # if eVersionValid:
+            #     return ResponseFormal(904)
+        else:
+            return ResponseFormal(806)
+        try:
+            filePath = deviceData.get('filePath', None)
+
+            if filePath == None:
+                return ResponseFormal(806)
+            deviceData['filePath'] = ','.join(filePath)
+            equipmentVersion = Equipment_Version(eid = CommonService.getUserID(getUser=False, setOTAID=True), **deviceData)
+            equipmentVersion.save()
+        except Exception as e:
+            errorInfo = traceback.format_exc()
+            print('添加设备错误: %s ' % errorInfo)
+            return ResponseFormal(806,{'details':repr(e)})
+        else:
+            sqlJSON = serializers.serialize('json', [equipmentVersion])
+            sqlList = json.loads(sqlJSON)
+            sqlDict =dict(zip(["datas"], [sqlList]))
+            return ResponseFormal(0,sqlDict)
+
+def downloadUrl(fileType, fileCode, fileVersion, fileName):
+    fullPath = os.path.join(BASE_DIR, "static/Upgrade").replace('\\', '/')
+    if fileType == 'IPC':
+        Path = '/'.join((fullPath, 'IPC', fileCode, fileVersion, fileName)).replace('\\', '/')
+    elif fileType == 'DVR':
+        Path = '/'.join((fullPath, 'DVR', fileCode, fileVersion, fileName)).replace('\\', '/')
+    elif fileType == 'NVR':
+        Path = '/'.join((fullPath, 'NVR', fileCode, fileVersion, fileName)).replace('\\', '/')
+    elif fileType == 'XVR':
+        Path = '/'.join((fullPath, 'IPC', fileCode, fileVersion, fileName)).replace('\\', '/')
+    else:
+        if fileType == 'CHM':
+            Path = fileName
+        else:
+            Path = '/'.join((fullPath, 'Other', fileName)).replace('\\', '/')
+
+    if os.path.isfile(Path):
+        try:
+            JSON = json.dumps(
+                {
+                    "result_code": 0,
+                    "reason": 'Success',
+                    "result": {},
+                    "error_code": 0,
+                }, ensure_ascii=False
+            )
+            wrapper = FileWrapper(open(Path, 'rb'))
+            response = HttpResponse(wrapper, content_type="application/octet-stream")
+            response['Content-Length'] = os.path.getsize(Path)
+            response['Content-Disposition'] = 'attachment; filename=%s' % os.path.basename(Path)
+            response['Content-MD5'] = getMD5orSHA265(Path)
+            response['Content-SHA265'] = getMD5orSHA265(Path, 'SHA265')
+            response['Content-CRC32'] = getMD5orSHA265(Path, 'CRC32')
+            response['Content-Error'] = JSON
+            return response
+
+        except Exception as e:
+            errorJSON = ResponseFormal(906,{'details':repr(e)})
+            response = HttpResponse(errorJSON, content_type='text/plain', charset='utf-8')
+            response['Content-Error'] = errorJSON
+            return response
+    else:
+        errorJSON = ResponseFormal(907)
+        response = HttpResponse(errorJSON, content_type='text/plain', charset='utf-8')
+        response['Content-Error'] = errorJSON
+        return response
+
+@csrf_exempt
+def downloadUpdataFileUrl(request, *callback_args, **callback_kwargs):
+    if request.method == 'GET':
+        request_dict = request.GET
+    elif request.method == 'POST':
+        request_dict = request.POST
+    else:
+        errorJSON = ResponseFormal(801)
+        response = HttpResponse(errorJSON, content_type='text/plain', charset='utf-8')
+        response['Content-Error'] = errorJSON
+        return response
+    fileType = request_dict.get('fileType', None)
+    fileCode = request_dict.get('fileCode', None)
+    fileVersion = request_dict.get('fileVersion', None)
+    fileName = request_dict.get('fileName', None)
+    if fileType != None and fileCode != None and fileVersion != \
+            None and fileName != None:
+        response = downloadUrl(fileType, fileCode, fileVersion, fileName)
+        return response
+    else:
+        errorJSON = ResponseFormal(800)
+        response = HttpResponse(errorJSON, content_type='text/plain', charset='utf-8')
+        response['Content-Error'] = errorJSON
+        return response
+
+'''
+http://192.168.136.40:8077/OTA/getEquipmentVersion?31AX162001A
+'''
+@csrf_exempt
+def getEquipmentVersionInterface(request,
+                                 *callback_args, **callback_kwargs):
+    if request.method == "POST":
+        request.encoding ='utf-8'
+        code = request.POST.get('code', None)
+
+        if code is not None:
+            response = HttpResponse(getEquipmentVersion(code))
+            return response
+
+        else:
+            return ResponseJSON(800)
+    elif request.method == "GET":
+        request.encoding = 'gb2312'
+        code = request.GET.get('code', None)
+
+        if code is not None:
+            response = HttpResponse(getEquipmentVersion(code))
+            return response
+
+        else:
+            return ResponseJSON(800)
+
+    else:
+        return ResponseJSON(801)
+
+@csrf_exempt
+def getUpdataFileUrlInterface(request,
+                              *callback_args, **callback_kwargs):
+    if request.method == "POST":
+        request.encoding = 'utf-8'
+
+        code = request.POST.get('code', None)
+
+        if code is not None:
+            response = HttpResponse(getUpdataFileUrl(code))
+            return response
+        else:
+            return ResponseJSON(800)
+    elif request.method == "GET":
+        request.encoding = 'utf-8'
+        code = request.GET.get('code', None)
+
+        if code is not None:
+            response = HttpResponse(getUpdataFileUrl(code))
+            return response
+        else:
+            return ResponseJSON(800)
+
+    else:
+        return ResponseJSON(801)
+
+@csrf_exempt
+def downloadUpdataFileUrlInterface(request, fileType, fileName,
+                                   *callback_args, **callback_kwargs):
+    if fileType is not None and fileName is not None:
+        fullPath = os.path.join(BASE_DIR, "static/Upgrade/").replace('\\', '/')
+        if fileType == 'IPC':
+            fullPath += 'IPC/' + fileName
+        elif fileType == 'DVR':
+            fullPath += 'DVR/' + fileName
+        elif fileType == 'NVR':
+            fullPath += 'NVR/' + fileName
+        elif fileType == 'XVR':
+            fullPath += 'XVR/' + fileName
+        elif fileType == 'User':
+            fullPath = os.path.join(BASE_DIR, "static/").replace('\\', '/')
+            fullPath += 'User/' + fileName
+        elif fileType == 'ADCloud':
+            fullPath = os.path.join(BASE_DIR, "static/APK/").replace('\\', '/')
+            fullPath += 'ADCloud/' + fileName
+        elif fileType == 'ACCloud':
+            fullPath = os.path.join(BASE_DIR, "static/APK/").replace('\\', '/')
+            fullPath += 'ACCloud/' + fileName
+        else:
+            fullPath += 'Other/' + fileName
+
+        print(fullPath)
+        if os.path.isfile(fullPath):
+            try:
+                JSON = ResponseFormal(0)
+                if fileType != 'User':
+                    wrapper = FileWrapper(open(fullPath, 'rb'))
+                    response = HttpResponse(wrapper, content_type="application/octet-stream")
+                    response['Content-Length'] = os.path.getsize(fullPath)
+                    response['Content-Disposition'] = 'attachment; filename=%s' % os.path.basename(fullPath)
+                    response['Content-MD5'] = getMD5orSHA265(fullPath)
+                    #校验文件md5值
+                    # if response['Content-MD5'] ==
+                    # print(response['Content-MD5'])
+                    response['Content-SHA265'] = getMD5orSHA265(fullPath, 'SHA265')
+                    response['Content-CRC32'] = getMD5orSHA265(fullPath, 'CRC32')
+                    response['Content-Error'] = JSON
+                    return response
+                else:
+                    Imagedata = open(fullPath, 'rb').read()
+                    response = HttpResponse(Imagedata, content_type="image/jpeg")
+                    return response
+            except Exception as e:
+                errorJSON = ResponseFormal(906)
+                response = HttpResponse(errorJSON, content_type='text/plain', charset='utf-8')
+                response['Content-Error'] = errorJSON
+                return response
+        else:
+            errorJSON = ResponseFormal(907)
+            response = HttpResponse(errorJSON, content_type='text/plain', charset='utf-8')
+            response['Content-Error'] = errorJSON
+            return response
+
+    else:
+        errorJSON = ResponseFormal(800)
+        response = HttpResponse(errorJSON, content_type='text/plain', charset='utf-8')
+        response['Content-Error'] = errorJSON
+        return response
+
+class getUploadFiletoDirView(TemplateView):
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(getUploadFiletoDirView, self).dispatch(*args, **kwargs)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+
+        token = request.POST.get('token', None)
+        fileType = request.POST.get('fileType', None)
+        fileCode = request.POST.get('fileCode', None)
+        fileVersion = request.POST.get('fileVersion', None)
+        fileName = request.FILES.get('fileName', None)
+
+        return self.ValidationError(token, fileType, fileName,
+                                     filefileCode=fileCode, fileVersion=fileVersion)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'gb2312'
+
+        token = request.GET.get('token', None)
+        fileType = request.GET.get('fileType', None)
+        fileCode = request.GET.get('fileCode', None)
+        fileVersion = request.GET.get('fileVersion', None)
+        fileName = request.FILES.get('fileName', None)
+        return self.ValidationError(token, fileType, fileName,filefileCode=fileCode, fileVersion=fileVersion)
+
+    def ValidationError(self, token, fileType, fileName, *args, **kwargs):
+        if fileName != None and fileType != None and token != None:
+            tM = JSONTokenManager()
+            error_code = tM.verify_AToken(token)
+            if error_code == 0:
+                userID = tM.accessDict.get('userID', None)
+                if userID:
+                    own_permission = ModelService.check_permission(userID=userID, permID=210)
+                    if own_permission is True:
+                        fileCode = kwargs.get('fileCode', None)
+                        fileVersion = kwargs.get('fileVersion', None)
+                        if fileVersion != None and fileCode != None:
+                            response = HttpResponse(self.getUploadFiletoDir(userID, fileType, fileName,
+                                                                            fileCode, fileVersion=fileVersion))
+                            return response
+                        else:
+                            response = HttpResponse(self.getUploadFiletoDir(userID, fileType, fileName))
+                            return response
+                    else:
+                        return ResponseJSON(404)
+                else:
+                    return ResponseJSON(310)
+            else:
+                response = HttpResponse(tM.errorCodeInfo(error_code))
+                return response
+        else:
+            return ResponseJSON(800)
+
+    def getUploadFiletoDir(self, userID, fileType, fileName, *args, **kwargs):
+        """
+        将上传的文件写入服务器对应目录下
+        :param Type: equipment type
+        :param fileName: File name of upgrade file.
+        :return: filePath
+        """
+        try:
+            User = Device_User.objects.filter(userID = userID)
+        except Exception as e:
+            errorInfo = traceback.format_exc()
+            print('查询数据库错误: %s' % errorInfo)
+            return ResponseFormal(500,{'details':repr(e)})
+        else:
+            if not User:
+                return ResponseFormal(113)
+            own_perm = ModelService.check_permission(userID,permID=210)
+            if own_perm is not True:
+                return ResponseFormal(605)
+            updataFile = fileName.name
+            updataFile = updataFile.replace(' ', '+')
+            versionIndex = updataFile.find('.', updataFile.find('.', updataFile.find('.') + 1) + 1)
+            codeIndex = versionIndex + 12
+
+            if codeIndex != -1 and versionIndex != -1:
+                fileVersion = len(updataFile[1: versionIndex]) > 0 and updataFile[1: versionIndex] or None
+                fileCode = len(updataFile[versionIndex + 1: codeIndex]) > 0 and \
+                           updataFile[versionIndex + 1: codeIndex] or None
+                if fileCode is not None and fileVersion is not None:
+                    return getDir(fileType, fileName, fileCode, fileVersion)
+                else:
+                    fileCode = kwargs.get('fileCode', None)
+                    fileVersion = kwargs.get('fileVersion', None)
+                    print(fileCode, fileVersion)
+                    if fileCode != None and fileVersion != None:
+                        return getDir(fileType, fileName, fileCode, fileVersion)
+                    else:
+                        return ResponseFormal(903)
+            else:
+                fileCode = kwargs.get('fileCode', None)
+                fileVersion = kwargs.get('fileVersion', None)
+                if fileCode != None and fileVersion != None:
+                    return getDir(fileType, fileName, fileCode, fileVersion)
+                else:
+                    return ResponseFormal(903)
+
+@csrf_exempt
+def addNewEquipmentVersionInterface(request, *callback_args,
+                                    **callback_kwargs):
+    if request.method == "POST":
+        request.encoding = 'utf-8'
+        deviceContent = request.POST.get('content', None).encode('utf-8')
+        token = request.POST.get('token', None)
+        deviceContent = str(deviceContent, encoding='utf-8')
+        deviceContent = deviceContent.replace(' ', ' ').replace('\'', '\"')
+        print(deviceContent, type(deviceContent))
+        if deviceContent is not None:
+            response = HttpResponse(addNewEquipmentVersion(deviceContent,token))
+            return response
+        else:
+            return ResponseJSON(800)
+
+    elif request.method == "GET":
+        request.encoding = 'gb2312'
+
+        deviceContent = request.GET.get('content', None).encode('gb2312')
+        deviceContent = str(deviceContent, encoding='gb2312')
+        token = request.GET.get('token', None)
+        deviceContent = deviceContent.replace(' ', ' ').replace('\'', '\"')
+        if deviceContent is not None:
+            response = HttpResponse(addNewEquipmentVersion(deviceContent,token))
+            return response
+
+        else:
+            return ResponseJSON(800)
+    else:
+        return ResponseJSON(801)
+
+@csrf_exempt
+def showAllEquipmentVersion(userID):
+    try:
+        userValid = Device_User.objects.filter(userID = userID).order_by('-data_joined')
+    except Exception as e:
+        errorInfo = traceback.format_exc()
+        print('查询数据库错误: %s' % errorInfo)
+        return ResponseFormal(500)
+    else:
+        if userValid:
+            own_permission = ModelService.check_permission(userID=userID, permID=240)
+            if own_permission:
+                sqlJSON = serializers.serialize('json', Equipment_Version.objects.all())  # .order_by('-data_joined'))
+                sqlList = json.loads(sqlJSON)
+                print(sqlList, sqlJSON)
+                sqlDict = dict(zip(["datas"], [sqlList]))
+                return ResponseFormal(0,sqlDict)
+            else:
+                return ResponseFormal(604)
+        else:
+            return ResponseFormal(113)
+
+@csrf_exempt
+def showAllEquipmentVersionInterface(request, *callback_args,
+                                 **callback_kwargs):
+    if request.method == 'POST':
+        token = request.POST.get('token', None)
+
+        if token != None:
+            tM = JSONTokenManager()
+            error_code = tM.verify_AToken(token)
+            if error_code == 0:
+                userID = tM.accessDict.get('userID', None)
+                if userID:
+                    response = HttpResponse(showAllEquipmentVersion(userID))
+                    return response
+                else:
+                    return ResponseJSON(310)
+            else:
+                response = HttpResponse(tM.errorCodeInfo(error_code))
+                return response
+
+        else:
+            return ResponseJSON(800)
+
+    elif request.method == 'GET':
+        token = request.GET.get('token', None)
+
+        if token != None:
+            tM = JSONTokenManager()
+            error_code = tM.verify_AToken(token)
+            if error_code == 0:
+                userID = tM.accessDict.get('userID', None)
+                if userID:
+                    response = HttpResponse(showAllEquipmentVersion(userID))
+                    return response
+                else:
+                    return ResponseJSON(310)
+
+            else:
+                response = HttpResponse(tM.errorCodeInfo(error_code))
+                return response
+        else:
+            return ResponseJSON(800)
+
+import zlib
+@csrf_exempt
+def getCRC32(filePath):
+    print(filePath)
+    block_size = 1024 * 1024
+    crc = 0
+
+    try:
+        fd = open(filePath, 'rb')
+        while True:
+            buffer = fd.read(block_size)
+            if len(buffer) == 0:  # EOF or file empty. return hashes
+                fd.close()
+                return crc  # 返回的是十进制的值
+
+            crc = zlib.crc32(buffer, crc)
+    except Exception as e:
+        return ResponseFormal(908,{'details':repr(e)})
+
+def getMD5orSHA265(fileName, encryptionType='MD5'):
+    """
+
+    :param filePath:
+    :param encryptionType:
+    :return:
+    """
+    if not os.path.isfile(fileName):
+        return ''
+    else:
+        if encryptionType == 'MD5':
+            encryption = hashlib.md5()
+        elif encryptionType == 'SHA265':
+            encryption = hashlib.sha256()
+        elif encryptionType == 'CRC32':
+            f = open(fileName, 'rb')
+            chunk = f.read()
+            return crc32(chunk)
+
+        f = open(fileName, 'rb')
+        block_size = 8192  # why is 8192 | 8192 is fast than 2048
+
+        while True:
+            chunk = f.read(block_size)
+            if not chunk:
+                break
+            encryption.update(chunk)
+
+        f.close()
+        return encryption.hexdigest()
+
+def CRC(fileName):
+    fd = open(fileName, 'rb')
+    dwSize = os.path.getsize(fileName)
+    lpBuffer = fd.read()
+
+    crc = -1
+    CRC32Table = [0] * 256
+    ulPolynomial = 0x04C11DB7
+    len = dwSize
+    buffer = lpBuffer
+    for index in range(0xFF):
+        value = 0
+        ref = index
+
+        for n in range(9):
+            if ref & 1:
+                value |= 1 << (8 - n)
+            ref >>= 1
+
+        CRC32Table[index] = value << 24
+        for j in range(8):
+            CRC32 = CRC32Table[index] & (1 << 31) and ulPolynomial or 0
+            CRC32Table[index] = (CRC32Table[index] << 1) ^ CRC32
+        value = 0
+        ref = CRC32Table[index]
+        for n in range(33):
+            if ref & 1:
+                value |= 1 << (32 - n)
+            ref >>= 1
+        CRC32Table[index] = value
+
+    index = 0
+    while len:
+        len -= 1
+        crc = (crc >> 8) ^ CRC32Table[(crc & 0xFF) ^ buffer[index]]
+        index += 1
+
+    print(crc ^ 0xffffffff)
+
+    return crc ^ 0xffffffff
+

Controller/PermissionManager.py

@@ -0,0 +1,1080 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+from itertools import chain
+from django.core import serializers
+from django.views.generic.base import View
+import django.dispatch, traceback
+from django.views.decorators.csrf import csrf_exempt
+from django.utils.decorators import method_decorator
+from Service.TokenManager import JSONTokenManager
+from Model.models import Permissions, Role, Device_User
+from Service.CommonService import CommonService
+from Service.ModelService import ModelService
+from Service.ResponseService import *
+
+# 创建信号
+roles_done = django.dispatch.Signal(providing_args=[])
+perms_done = django.dispatch.Signal(providing_args=[])
+rmanger_done = django.dispatch.Signal(providing_args=[])
+
+class Roles(object):
+    '''
+    role Manager Class
+    '''
+    try:
+        rid = []
+        rolename = []
+        roles = Role.objects.all()
+        for role in roles:
+            rolename.append(role.roleName)
+            rid.append(role.rid)
+    except Exception as e:
+        pass
+    def __init__(self):
+        '''
+        信号监听, 注册信号
+        Signal.connect(receiver, sender=None, weak=True, dispatch_uid=None)
+        receiver: 信号接受者，回调函数
+        sender: 信号发送者
+        '''
+        roles_done.connect(self.callback)
+
+        self.startSignal()
+
+    def callback(self, sender, **kwargs):
+        '''
+        开启监听之后，就要去实现回调函数了, 注册信号
+        :param sender:
+        :param kwargs:
+        :return:
+        '''
+        Roles.rid = []
+        Roles.rolename = []
+        Roles.roles = Role.objects.all()
+
+        for role in Roles.roles:
+            Roles.rolename.append(role.roleName)
+            Roles.rid.append(role.rid)
+
+    def startSignal(self):
+        '''
+        触发信号
+        指定信号发送者
+        :return:
+        '''
+        roles_done.send(sender=self.__class__)
+
+    def toJSON(self, QuerySets, fields=None, exclude=None):
+        listSets = []
+        for QuerySet in QuerySets:
+            data = {}
+            opts = QuerySet._meta
+            for f in chain(opts.concrete_fields, opts.private_fields, opts.many_to_many):
+                if not getattr(f, 'editable', False):
+                    continue
+                if fields and f.name not in fields:
+                    continue
+                if exclude and f.name in exclude:
+                    continue
+                data[f.name] = f.value_from_object(QuerySet)
+            listSets.append(data)
+        return listSets
+
+    def queryAllRoles(self, rolenames=None, exclude=None):
+        roles =[]
+        for role in chain(Roles.roles):
+            if rolenames and role.roleName not in rolenames:
+                continue
+            if exclude and role.roleName in exclude:
+                continue
+            roles.append(role)
+        if len(roles) > 0:
+            resultDict=CommonService.query_set_to_dict(roles)
+            for k, v in enumerate(resultDict["datas"]):
+                if len(v['fields']['permission']) > 0:
+                    resultDict["datas"][k]['fields']['permissionJson']={}
+                    for pid in v['fields']['permission']:
+                        permission_query_set= Permissions.objects.get(id=pid)
+                        resultDict["datas"][k]['fields']['permissionJson'][pid]=permission_query_set.permName
+            return ResponseFormal(0,resultDict)
+        
+        else:
+            return ResponseFormal(0, {})
+
+    def addRoles(self, content=None):
+        try:
+            roleContent = json.loads(content)
+        except Exception as e:
+            return ResponseFormal(803,repr(e))
+        else:
+            rid = roleContent.get('rid', None)
+            if rid == None:
+                return ResponseFormal(806)
+            try:
+                if rid in chain(Roles.rid):
+                    return ResponseFormal(807)
+
+                permission_list = roleContent['permission']
+                roleContent.pop('permission')
+                role = Role(**roleContent)
+                role.save()
+                if len(permission_list) > 0:
+                    role.permission.add(*permission_list)
+            except Exception as e:
+                return ResponseFormal(808,repr(e))
+            else:
+                self.startSignal()
+                return ResponseFormal(0)
+
+    def delRoles(self, rid=None, rolename=None):
+        if rid != None:
+            if rid not in Roles.rid:
+                return ResponseFormal(190)
+
+            try:
+                roletuple = Role.objects.filter(rid = rid).delete()
+            except Exception as e:
+                return ResponseFormal(192, repr(e))
+            else:
+                if roletuple[0] == 1:
+                    self.startSignal()
+                    return self.queryAllRoles()
+                else:
+                    return ResponseFormal(193,{'error_msg':roletuple})
+        elif rolename != None:
+            if rid not in Roles.rolename:
+                return ResponseFormal(191)
+            try:
+                roletuple = Role.objects.filter(roleName = rolename).delete()
+            except Exception as e:
+                return ResponseFormal(192)
+            else:
+                if roletuple[0] == 1:
+                    self.startSignal()
+                    return self.queryAllRoles()
+                else:
+                    return ResponseFormal(193)
+
+    def modifyRoles(self, rid=None, content=None):
+        if rid not in Roles.rid:
+            return ResponseFormal(190)
+        try:
+            roleContent = json.loads(content)
+        except Exception as e:
+            errorInfo = traceback.format_exc()
+            print('The content parameter format is wrong: %s' % errorInfo)
+            return ResponseFormal(803)
+        else:
+            try:
+                permission_list = roleContent['permission']
+                roleContent.pop('permission')
+                roleCount = Role.objects.filter(rid = rid).update(**roleContent)
+                if roleCount:
+                    if len(permission_list) > 0:
+                        Role.objects.get(rid=rid).permission.set(permission_list)
+                    else:
+                        Role.objects.get(rid=rid).permission.clear()
+            except Exception as e:
+                return ResponseFormal(194)
+
+            else:
+                if roleCount == 1:
+                    self.startSignal()
+                    return self.queryAllRoles()
+                else:
+                    return ResponseFormal(195)
+
+class Permission(object):
+    try:
+        id = []
+        permname = []
+        perms = Permissions.objects.all()
+        for perm in perms:
+            id.append(perm.id)
+            permname.append(perm.permName)
+    except Exception as e:
+        pass
+    def __init__(self):
+        perms_done.connect(self.callback)
+
+        self.startSignal()
+
+    def callback(self, sender, **kwargs):
+        Permission.id = []
+        Permission.permname = []
+        Permission.roles = Permissions.objects.all()
+
+        for perm in Permission.roles:
+            Permission.id.append(perm.id)
+            Permission.permname.append(perm.permName)
+
+    def startSignal(self):
+        perms_done.send(sender=self.__class__)
+
+    def queryAllPerms(self, perms=None, exclude=None):
+        opts =[]
+        for perm in chain(Permission.permname):
+            if perms and perm not in perms:
+                continue
+            if exclude and perm in exclude:
+                continue
+            opts.append(perm)
+        return ResponseFormal(0,{'perms':opts})
+
+    def queryAllPermsInfo(self, perms=None, exclude=None):
+        sqlJSON = serializers.serialize('json', Permissions.objects.all())
+        sqlList = json.loads(sqlJSON)
+        sqlDict = dict(zip(["datas"], [sqlList]))
+        return ResponseFormal(0,sqlDict)
+
+    def addPerms(self, content=None):
+        try:
+            permContent = json.loads(content)
+        except Exception as e:
+            return ResponseFormal(803, repr(e))
+        else:
+            permname = permContent.get('permName', None)
+            if permname == None:
+                return ResponseFormal(806)
+            if permname in chain(Permission.permname):
+                return ResponseFormal(815)
+            try:
+                perm = Permissions(**permContent)
+                perm.save()
+            except Exception as e:
+                return ResponseFormal(816, repr(e))
+            else:
+                self.startSignal()
+                sqlJSON = serializers.serialize('json', [perm])
+                sqlList = json.loads(sqlJSON)
+                sqlDict = dict(zip(["datas"], [sqlList]))
+                return ResponseFormal(0,sqlDict)
+
+    def delPerms(self, id=None, permName=None):
+        try:
+            if id != None:
+                perm = Permissions.objects.filter(id = id)
+            elif permName != None:
+                perm = Permissions.objects.filter(permName = permName)
+            else:
+                return ResponseFormal(800)
+        except Exception as e:
+            return ResponseFormal(500, repr(e))
+        else:
+            if not perm:
+                return ResponseFormal(817)
+            try:
+                perm.delete()
+            except Exception as e:
+                return ResponseFormal(818, repr(e))
+            else:
+                self.startSignal()
+                sqlJSON = serializers.serialize('json', Permissions.objects.all())
+                sqlList = json.loads(sqlJSON)
+                sqlDict = dict(zip(["datas"], [sqlList]))
+                return ResponseFormal(0,sqlDict)
+
+    def modifyPerm(self, id=None, content=None):
+        if id not in Permission.id:
+            return ResponseFormal(817)
+        try:
+            permContent = json.loads(content)
+        except Exception as e:
+            return ResponseFormal(803, repr(e))
+        else:
+            try:
+                perm = Permissions.objects.filter(id = id).update(**permContent)
+            except Exception as e:
+                return ResponseFormal(819, repr(e))
+            else:
+                self.startSignal()
+
+                sqlJSON = serializers.serialize('json', Permissions.objects.filter(id = id))
+                sqlList = json.loads(sqlJSON)
+                sqlDict = dict(zip(["datas"], [sqlList]))
+                return ResponseFormal(0,sqlDict)
+
+    @staticmethod
+    def getAllPermission():
+        send_dict=CommonService.query_set_to_dict(Permissions.objects.all())
+        return ResponseFormal(0, send_dict)
+
+
+class rolesManager(object):
+
+    def assign(self, userID=None, rid=None):
+        dUser = Device_User.objects.filter(userID = userID)
+        if not dUser:
+            return ResponseFormal(113)
+
+        role = Role.objects.filter(rid = rid)
+        if not role:
+            return ResponseFormal(190)
+        rids = dUser[0].get_role_id()
+        if rid in rids:
+            return ResponseFormal(196)
+        try:
+            dUser[0].role.add(role[0])
+        except Exception as e:
+            return ResponseFormal(196, repr(e))
+        else:
+            rids = dUser[0].get_role_id()
+            return ResponseFormal(0,{'rid':rids})
+
+    def remove(self, userID=None, rid=None):
+        dUser = Device_User.objects.filter(userID = userID)
+        if not dUser:
+            return ResponseFormal(113)
+        rids = dUser[0].get_role_id()
+        if rid not in rids:
+            return ResponseFormal(198)
+        try:
+            dUser[0].role.remove(rid)
+        except Exception as e:
+            return ResponseFormal(199, repr(e))
+        else:
+            rids = dUser[0].get_role_id()
+            if len(rids) == 0:
+                urole = Role.objects.filter(roleName = 'Users')
+                dUser[0].role.add(urole[0])
+                rids = dUser[0].get_role_id()
+            return ResponseFormal(0,{'rid':rids})
+    def query(self, userID=None):
+        dUser = Device_User.objects.filter(userID = userID)
+        if not dUser:
+            return ResponseFormal(113)
+        sqlJSON = serializers.serialize('json', Role.objects.filter(device_user = userID))
+        sqlList = json.loads(sqlJSON)
+        sqlDict = dict(zip(["datas"], [sqlList]))
+        return ResponseFormal(0, sqlDict)
+
+    def queryAll(self):
+        sqlJSON = serializers.serialize('json', Role.objects.all())
+        sqlList = json.loads(sqlJSON)
+        sqlDict = dict(zip(["datas"], [sqlList]))
+        return ResponseFormal(0, sqlDict)
+
+class permManager(object):
+
+    def queryUser(self, userID=None):
+        dUser = Device_User.objects.filter(userID = userID)
+        if not dUser:
+            return ResponseFormal(190)
+        sqlDict = dict(zip(['datas'], [dUser[0].get_all_permission()]))
+        return ResponseFormal(0, sqlDict)
+
+    def queryAllUser(self):
+        sqlJSON = serializers.serialize('json', Device_User.objects.all())
+        sqlList = json.loads(sqlJSON)
+        sqlDict = dict(zip(['datas'], [sqlList]))
+        return ResponseFormal(0, sqlDict)
+
+    def queryRole(self, rid=None):
+        role = Role.objects.filter(rid = rid)
+        if not role:
+            return ResponseFormal(190)
+        sqlDict = dict(zip(["datas"], [role[0].get_all_permission()]))
+        return ResponseFormal(0, sqlDict)
+
+    def queryMoreRole(self, rid=None):
+        role = Role.objects.filter(rid = rid)
+        if not role:
+            roleDict = {'rid': role[0].rid, 'error_msg': u'The rid does not exist!'}
+            return roleDict
+        roleDict = {'rid' : role[0].rid, 'perms': role[0].get_all_permission()}
+        return roleDict
+
+    def queryAllRole(self):
+        sqlJSON = serializers.serialize('json', Role.objects.all())
+        sqlList = json.loads(sqlJSON)
+        sqlDict = dict(zip(["datas"], [sqlList]))
+        return ResponseFormal(0, sqlDict)
+
+    def assignUser(self, userID=None, perms=None):
+        pids = []
+        error_perms = []
+        existence_perms = []
+        dUser = Device_User.objects.filter(userID=userID)
+        if not dUser:
+            return ResponseFormal(113)
+        for perm in perms:
+            if perm in Permission.id:
+                print('in', perm)
+                continue
+            else:
+                print('not in', perm)
+                error_perms.append(perm)
+                perms.remove(perm)
+                continue
+        permsID = dUser[0].get_all_perms_id()
+        for perm in perms:
+            if perm not in permsID:
+                pids.append(perm)
+            else:
+                existence_perms.append(perm)
+
+        if len(pids) == 0:
+            if len(error_perms) > 0:
+                return ResponseFormal(201,{'error_perms': error_perms})
+            elif len(existence_perms) > 0:
+                return ResponseFormal(206,{'existence_perms': existence_perms})
+        try:
+            for pid in pids:
+                dUser[0].permission.add(pid)
+        except Exception as e:
+            return ResponseFormal(200, repr(e))
+        else:
+            if len(error_perms) > 0:
+                if len(existence_perms) > 0:
+                    return ResponseFormal(0,{'error_msg': 'Some of the permissions you provide have already existed,and some of the permissions do not exist!','error_perms': error_perms,'existence_perms': existence_perms,'perms': dUser[0].get_all_permission()})
+                else:
+                    return ResponseFormal(0, {'error_msg': 'Some of the permissions you have provided do not exist!','error_perms':error_perms,'perms':dUser[0].get_all_permission()})
+            else:
+                if len(existence_perms) > 0:
+                    return ResponseFormal(0, {'error_msg': 'Some of the permissions you have provided do not exist!','error_perms':error_perms,'perms':dUser[0].get_all_permission()})
+                else:
+                    return ResponseFormal(0, {'perms': dUser[0].get_all_permission()})
+
+    def assignRole(self, rid=None, perms=None):
+        pids = []
+        error_perms = []
+        existence_perms = []
+        role = Role.objects.filter(rid = rid)
+        if not role:
+            return ResponseFormal(190)
+        for perm in perms:
+            if perm in Permission.id:
+                continue
+            else:
+                error_perms.append(perm)
+                perms.remove(perm)
+                continue
+
+        permsID = role[0].get_all_perms_id()
+        for perm in perms:
+            if perm not in permsID:
+                pids.append(perm)
+            else:
+                existence_perms.append(perm)
+
+        if len(pids) == 0:
+            if len(error_perms) > 0:
+                return ResponseFormal(201,{'error_perms': error_perms})
+            elif len(existence_perms) > 0:
+                return ResponseFormal(206,{'error_perms': existence_perms})
+        try:
+            for pid in pids:
+                role[0].permission.add(pid)
+        except Exception as e:
+            return ResponseFormal(200, repr(e))
+        else:
+            if len(error_perms) > 0:
+                return ResponseFormal(0, {'error_msg': 'Some of the permissions you have provided do not exist!','error_perms': error_perms,'perms': role[0].get_all_permission(),})
+            else:
+                if len(existence_perms) > 0:
+                    return ResponseFormal(206, {
+                        'error_msg': 'Some of the permissions you have provided do not exist!',
+                        'error_perms': existence_perms, 'perms': role[0].get_all_permission(), })
+                else:
+                    return ResponseFormal(0, {'perms': role[0].get_all_permission()})
+
+    def removeUser(self, userID=None, perms=None):
+        '''
+        删除用户权限
+        :param userID: 要删除的用户的用户ID
+        :param perms:  []，权限列表
+        :return: 成功或者错误
+        '''
+        dUser = Device_User.objects.filter(userID=userID)
+        if not dUser:
+            return ResponseFormal(113)
+        error_perms = []
+        for perm in perms:
+            if perm in Permission.id:
+                continue
+            else:
+                error_perms.append(perm)
+                perms.remove(perm)
+                continue
+
+        try:
+            # user.user_permissions.remove(permission, permission, ...)  删除权限
+            for perm in perms:
+                dUser[0].permission.remove(perm)
+        except Exception as e:
+            return ResponseFormal(202,repr(e))
+        else:
+            if len(error_perms) > 0:
+                return ResponseFormal(201, {
+                            'error_msg': 'Some of the permissions you have provided do not exist!',
+                            'error_perms': error_perms,
+                            'perms': dUser[0].get_all_permission(),
+                        })
+            else:
+                return ResponseFormal(201, {'perms': dUser[0].get_all_permission()})
+
+    def removeRole(self, rid=None, perms=None):
+        role = Role.objects.filter(rid = rid)
+        if not role:
+            return ResponseFormal(190)
+        error_perms = []
+        for perm in perms:
+            if perm in Permission.id:
+                continue
+            else:
+                error_perms.append(perm)
+                perms.remove(perm)
+                continue
+
+        try:
+            # group.permissions.remove(permission, permission, ...)
+            for perm in perms:
+                role[0].permission.remove(perm)
+        except Exception as e:
+            return ResponseFormal(203,repr(e))
+        else:
+            if len(error_perms) > 0:
+                return ResponseFormal(201, {
+                            'error_msg': 'Some of the permissions you have provided do not exist!',
+                            'error_perms': error_perms,
+                            'perms': role[0].get_all_permission(),
+                        })
+            else:
+                return ResponseFormal(201, {'perms': role[0].get_all_permission()})
+
+    def clearUser(self, userID=None):
+        dUser = Device_User.objects.filter(userID=userID)
+        if not dUser:
+            return ResponseFormal(113)
+        try:
+            # user.user_permissions.clear()  清空权限
+            dUser[0].permission.clear()
+        except Exception as e:
+            return ResponseFormal(204,repr(e))
+        else:
+            return ResponseFormal(0,{'perms': dUser[0].get_all_permission()})
+
+    def clearRole(self, rid=None):
+        role = Role.objects.filter(rid = rid)
+        if not role:
+            return ResponseFormal(190)
+        try:
+            role[0].permission.clear()
+        except Exception as e:
+            return ResponseFormal(205,repr(e))
+        else:
+            return ResponseFormal(0,{'perms': role[0].get_all_permission()})
+
+# 角色View
+class queryRoleView(View):
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(queryRoleView, self).dispatch(*args, **kwargs)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'gb2312'
+        token = request.GET.get('token', None)
+        return self.ValidationError(token)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        token = request.POST.get('token', None)
+        return self.ValidationError(token)
+
+    def ValidationError(self, token):
+        if token is not None:
+            tM = JSONTokenManager()
+            error_code = tM.verify_AToken(token)
+            if error_code == 0:
+                userID = tM.accessDict.get('userID', None)
+                if userID:
+                    response = HttpResponse(self.queryUserRole(userID))
+                    return response
+                else:
+                    return ResponseJSON(310)
+            else:
+                response = HttpResponse(tM.errorCodeInfo(error_code))
+                return response
+        else:
+            return ResponseJSON(800)
+
+    def queryUserRole(self, userID):
+        eUser = Device_User.objects.filter(userID = userID)
+        if not eUser:
+            return ResponseFormal(102)
+
+        if 100 in eUser[0].get_role_id():
+            role = Roles()
+            return role.queryAllRoles()
+        own_permission = ModelService.check_permission(userID=userID, permID=30)
+        if own_permission is True:
+            role = Roles()
+            return role.queryAllRoles()
+        else:
+            return ResponseFormal(603)
+
+class addNewRoleView(View):
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(addNewRoleView, self).dispatch(*args, **kwargs)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'gb2312'
+        token = request.GET.get('token', None)
+        content = request.GET.get('content', None)
+
+        return self.ValidationError(token, content)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        token = request.POST.get('token', None)
+        content = request.POST.get('content', None)
+
+        return self.ValidationError(token, content)
+
+    def ValidationError(self, token, content):
+        if token != None and content != None:
+            tM = JSONTokenManager()
+            error_code = tM.verify_AToken(token)
+            if error_code == 0:
+                userID = tM.accessDict.get('userID', None)
+                if userID:
+                    response = HttpResponse(self.AddNewUserRole(userID, content))
+                    return response
+                else:
+                    return ResponseJSON(310)
+            else:
+                response = HttpResponse(tM.errorCodeInfo(error_code))
+                return response
+
+        else:
+            return ResponseJSON(800)
+
+    def AddNewUserRole(self, userID, content):
+        try:
+            User = Device_User.objects.filter(userID = userID)
+        except Exception as e:
+            return ResponseFormal(500,repr(e))
+        else:
+            rids = User[0].get_role_id()
+            if rids == None:
+                return ResponseFormal(606)
+            Aperms = False
+            for rid in rids:
+                if rid < 10:
+                    continue
+                else:
+                    Aperms = True
+
+            if Aperms:
+                role = Roles()
+                return role.addRoles(content)
+            else:
+                return ResponseFormal(607)
+
+
+class delRoleView(View):
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(delRoleView, self).dispatch(*args, **kwargs)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'gb2312'
+        token = request.GET.get('token', None)
+        rid = request.GET.get('rid', None)
+
+        return self.ValidationError(token, rid)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        token = request.POST.get('token', None)
+        rid = request.POST.get('rid', None)
+
+        return self.ValidationError(token, rid)
+
+    def ValidationError(self, token, rid):
+        if token != None and rid != None:
+            tM = JSONTokenManager()
+            error_code = tM.verify_AToken(token)
+            if error_code == 0:
+                userID = tM.accessDict.get('userID', None)
+                if userID:
+                    response = HttpResponse(self.delRole(userID, int(rid)))
+                    return response
+                else:
+                    return ResponseJSON(310)
+            else:
+                response = HttpResponse(tM.errorCodeInfo(error_code))
+                return response
+
+    def delRole(self, userID, rid):
+        own_permission = ModelService.check_permission(userID=userID, permID=10)
+        if own_permission is True:
+            role = Roles()
+            return role.delRoles(rid)
+        else:
+            return ResponseJSON(404)
+
+class modifyRoleView(View):
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(modifyRoleView, self).dispatch(*args, **kwargs)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'gb2312'
+        token = request.GET.get('token', None)
+        rid =  request.GET.get('rid', None)
+        content = request.GET.get('content', None)
+        return self.ValidationError(token, rid, content)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        token = request.POST.get('token', None)
+        rid = request.POST.get('rid', None)
+        content = request.POST.get('content', None)
+        return self.ValidationError(token, rid, content)
+
+    def ValidationError(self, token, rid, content):
+        if token != None and content != None and rid != None:
+            tM = JSONTokenManager()
+            error_code = tM.verify_AToken(token)
+            if error_code == 0:
+                userID = tM.accessDict.get('userID', None)
+                if userID:
+                    response = HttpResponse(self.modifyRole(userID, int(rid), content))
+                    return response
+                else:
+                    return ResponseJSON(310)
+            else:
+                response = HttpResponse(tM.errorCodeInfo(error_code))
+                return response
+
+        else:
+            return ResponseJSON(800)
+
+    def modifyRole(self, userID, rid, content):
+        try:
+            User = Device_User.objects.filter(userID = userID)
+        except Exception as e:
+            return ResponseFormal(500, repr(e))
+        else:
+            rids = User[0].get_role_id()
+            if rids == None:
+                return ResponseFormal(606)
+            Aperms = False
+            for rrid in rids:
+                if rrid < 10:
+                    continue
+                else:
+                    Aperms = True
+            if Aperms:
+                role = Roles()
+                return role.modifyRoles(rid, content)
+            else:
+                return ResponseFormal(607)
+
+
+# 权限View
+class addNewPermsView(View):
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(addNewPermsView, self).dispatch(*args, **kwargs)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        request_dict = request.GET
+        return self.ValidationError(request_dict)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        request_dict = request.POST
+        return self.ValidationError(request_dict)
+
+    def ValidationError(self, request_dict):
+        token = request_dict.get('token', None)
+        type = request_dict.get('type', None)
+        if token != None:
+            tM = JSONTokenManager()
+            error_code = tM.verify_AToken(token)
+            if error_code == 0:
+                userID = tM.accessDict.get('userID', None)
+                if userID:
+                    if type == 'PC':
+                        return HttpResponse(self.addNewPermission(userID=userID, request_dict=request_dict))
+                else:
+                    return ResponseJSON(310)
+            else:
+                return HttpResponse(tM.errorCodeInfo(error_code))
+        else:
+            return ResponseJSON(800)
+
+    def addNewPermission(self, userID, request_dict):
+        user_valid = Device_User.objects.filter(userID=userID).order_by('-data_joined')
+        if user_valid:# 判断是否为超级管理员
+            ModelService.check_permission(userID,40)
+            if user_valid[0].is_superuser == 100 and user_valid[0].is_superuser != 1 and user_valid[0].is_superuser != 10:
+                return ResponseFormal(600)
+            else:
+                add_dict = {'id':int(request_dict['id']),'permName':request_dict['permName'],'description':request_dict['description']}
+                try:
+                    perm = Permissions(**add_dict)
+                    perm.save()
+                except Exception as e:
+                    return ResponseFormal(816,repr(e))
+                else:
+                    return Permission.getAllPermission()
+        else:
+            return ResponseFormal(113)
+
+class delPermsView(View):
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(delPermsView, self).dispatch(*args, **kwargs)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        request_dict = request.GET
+        return self.ValidationError(request_dict)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        request_dict = request.POST
+        return self.ValidationError(request_dict)
+
+    def ValidationError(self, request_dict):
+        token = request_dict.get('token', None)
+        id = request_dict.get('id', None)
+        if token != None and id != None:
+            tM = JSONTokenManager()
+            error_code = tM.verify_AToken(token)
+            if error_code == 0:
+                userID = tM.accessDict.get('userID', None)
+                if userID:
+                    response = HttpResponse(self.delPerms(userID, id))
+                    return response
+                else:
+                    return ResponseJSON(310)
+            else:
+                response = HttpResponse(tM.errorCodeInfo(error_code))
+                return response
+
+        else:
+            return ResponseJSON(800)
+
+    def delPerms(self, userID, id):
+        try:
+            User = Device_User.objects.filter(userID = userID)
+        except Exception as e:
+            return ResponseFormal(500, repr(e))
+
+        else:
+            rids = User[0].get_role_id()
+            if len(rids) == 0:
+                return ResponseFormal(606)
+            Aperms = False
+            for rid in rids:
+                if rid < 10:
+                    continue
+                else:
+                    Aperms = True
+            if Aperms:
+                perms = Permission()
+                return perms.delPerms(id)
+            else:
+                return ResponseFormal(611)
+
+class queryPermsView(View):
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(queryPermsView, self).dispatch(*args, **kwargs)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'gb2312'
+        token = request.GET.get('token', None)
+        request_data = request.GET
+        return self.ValidationError(token,request_data)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        token = request.POST.get('token', None)
+        request_data = request.POST
+        return self.ValidationError(token,request_data)
+
+    def ValidationError(self, token, request_data):
+        if token != None:
+            tM = JSONTokenManager()
+            error_code = tM.verify_AToken(token)
+            if error_code == 0:
+                userID = tM.accessDict.get('userID', None)
+                # userID = '151547867345163613800138001'
+                if userID:
+                    type = request_data.get('type',None)
+                    if type == 'PC':
+                        response = HttpResponse(self.querAllPermission(userID))
+                    else:
+                        response = HttpResponse(self.delPerms(userID))
+                    return response
+                else:
+                    return ResponseJSON(310)
+            else:
+                response = HttpResponse(tM.errorCodeInfo(error_code))
+                return response
+
+        else:
+            return ResponseJSON(800)
+
+    def querAllPermission(self, userID):
+        permission_query_set=Permissions.objects.all()
+        result_dict = CommonService.query_set_to_dict(permission_query_set)
+        return ResponseJSON(0,result_dict)
+
+    def delPerms(self, userID):
+        try:
+            User = Device_User.objects.filter(userID = userID)
+        except Exception as e:
+            return ResponseFormal(500, repr(e))
+        else:
+            rids = User[0].get_role_id()
+            if len(rids) == 0:
+                return ResponseFormal(606)
+
+            Aperms = False
+            for rid in rids:
+                if rid < 10:
+                    continue
+                else:
+                    Aperms = True
+
+            if Aperms:
+                perms = Permission()
+                return perms.queryAllPerms()
+            else:
+                return ResponseFormal(611)
+
+class modifyPermsView(View):
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(modifyPermsView, self).dispatch(*args, **kwargs)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'gb2312'
+        request_dict = request.GET
+        return self.ValidationError(request_dict)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        # token = request.POST.get('token', None)
+        request_dict = request.POST
+        return self.ValidationError(request_dict)
+
+    def ValidationError(self, request_dict):
+        token = request_dict.get('token', None)
+        if token != None:
+            tM = JSONTokenManager()
+            error_code = tM.verify_AToken(token)
+            if error_code == 0:
+                userID = tM.accessDict.get('userID', None)
+                if userID:
+                    update_dict = {'permName':request_dict['permName'],'description':request_dict['description']}
+                    response = HttpResponse(self.modifyPerms(userID=userID,id=request_dict['id'], update_dict=update_dict))
+                    return response
+                else:
+                    return ResponseJSON(310)
+            else:
+                response = HttpResponse(tM.errorCodeInfo(error_code))
+                return response
+        else:
+            return ResponseJSON(800)
+
+    def modifyPerms(self, userID, id, update_dict):
+        try:
+            User = Device_User.objects.filter(userID = userID)
+        except Exception as e:
+            return ResponseFormal(500, repr(e))
+        else:
+            rids = User[0].get_role_id()
+            if len(rids) == 0:
+                return ResponseFormal(606)
+            Aperms = False
+            for rid in rids:
+                if rid < 10:
+                    continue
+                else:
+                    Aperms = True
+
+            if Aperms:
+                try:
+                    Permissions.objects.filter(id = int(id)).update(**update_dict)
+                except Exception as e:
+                    return ResponseFormal(500,repr(e))
+                else:
+                    return Permission.getAllPermission()
+            else:
+                return ResponseFormal(611)
+
+class queryRolePermsView(View):
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(queryRolePermsView, self).dispatch(*args, **kwargs)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'gb2312'
+
+        token = request.GET.get('token', None)
+        allUser = request.GET.get('allUser', False)
+
+        return self.ValidationError(token, allUser)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+
+        token = request.POST.get('token', None)
+        allUser = request.POST.get('allUser', False)
+
+        return self.ValidationError(token, allUser)
+
+    def ValidationError(self, token, allUser):
+        if token != None:
+            tM = JSONTokenManager()
+            error_code = tM.verify_AToken(token)
+            if error_code == 0:
+                userID = tM.accessDict.get('userID', None)
+                if userID:
+                    response = HttpResponse(self.queryRolePerms(userID, allUser))
+                    return response
+                else:
+                    return ResponseJSON(310)
+            else:
+                response = HttpResponse(tM.errorCodeInfo(error_code))
+                return response
+        else:
+            return ResponseJSON(800)
+
+    def queryRolePerms(self, userID, allUser):
+        try:
+            dUser = Device_User.objects.filter(userID=userID).order_by('-data_joined')
+        except Exception as e:
+            return ResponseFormal(500, repr(e))
+        else:
+            if not dUser:
+                return ResponseFormal(113)
+            if allUser == '0' or allUser == 'False' or allUser == 'false':
+                allUser = False
+            elif allUser == '1' or allUser == 'True' or allUser == 'true':
+                allUser = True
+            else:
+                allUser = False
+            pM = permManager()
+            if not allUser:
+                ridslist =[]
+                rids = dUser[0].get_role_id()
+
+                for rid in rids:
+                    ridslist.append(pM.queryMoreRole(rid))
+                sqlDict = dict(zip(["datas"], [ridslist]))
+                return ResponseFormal(0,sqlDict)
+            else:
+                if 100 in dUser[0].get_role_id():
+                    return pM.queryAllRole()
+                else:
+                    return ResponseFormal(612)

Controller/StreamMedia.py

@@ -0,0 +1,627 @@
+from django.views.generic.base import View
+from django.utils.decorators import method_decorator
+from django.views.decorators.csrf import csrf_exempt
+from Service.TokenManager import JSONTokenManager
+from Service.ModelService import ModelService
+from Model.models import Equipment_Stream
+from Service.CommonService import CommonService
+from Object.AWS.S3ClassObject import S3ClassObject
+from Object.AWS.ElasticTranscoder import ElasticTranscoder
+import traceback, xmltodict, requests, re, subprocess
+from ffmpy import FFmpeg
+import time
+from Object.AWS.CloudfrontSignCookie import BetterThanBoto
+from Ansjer.config import *
+from Service.ResponseService import *
+
+'''
+移动端=>
+增:
+http://192.168.136.40:8077/media/stream?token=test&channel=1&status=1&uid=1&operation=add
+删：
+http://192.168.136.40:8077/media/stream?token=test&id=11&id=12&operation=delete
+改：
+http://192.168.136.40:8077/media/stream?token=test&id=13&operation=update&status=0
+查：
+http://192.168.136.40:8077/media/stream?token=test&operation=query
+获取视频播放地址
+http://13.56.215.252:82/media/stream?token=test&channel=99&uid=2N1K3LE78TYJ38CE111A&filename=1526882855.flv&operation=getVodHls
+http://192.168.136.40:8077/media/stream?token=test&channel=1&uid=1&operation=getVodUrl&filename=1_1-1523247439.mp4
+获取所有保存s3的视频
+http://192.168.136.40:8077/media/stream?token=test&channel=1&uid=1&operation=getAllVideo
+删除设备视频多个,key值传多个即可
+http://192.168.136.40:8077/media/stream?token=test&key=UKPAH63V23U4ZHEB111A_1/UKPAH63V23U4ZHEB111A_1-1524039164.mp4&uid=UKPAH63V23U4ZHEB111A&channel=1&operation=getDelVideo
+----------------------------------------------------------------------------------------------------
+后台=>
+验证推流权限
+http://192.168.136.40:8077/media/auth_stream?userID=151547867345163613800138001&uid=1&channel=1&access_token=test
+验证播放权限(直播)
+http://192.168.136.40:8077/media/auth_live?userID=151547867345163613800138001&uid=1&channel=1&token=test
+rtmp://192.168.136.45:1935/hls/UKPAH63V23U4ZHEB111A_88?userID=151547867
+获取所有推流的设备信息
+http://192.168.136.40:8077/media/stream?token=test&page=1&line=10&operation=getAdminAllStream
+删除流
+http://192.168.136.40:8077/media/stream?token=test&id=1&id=2&id=3&operation=getAdminDelStream
+删除指定设备视频
+http://192.168.136.40:8077/media/stream?token=test&key=1&key=2&key=3&operation=getAdminDelVideo
+更新
+http://192.168.136.40:8077/media/stream?token=test&id=13&operation=getAdminUpdateStream&status=0
+获取指定设备存储的视频播放地址
+http://192.168.136.40:8077/media/stream?token=test&channel=1&uid=1&filename=1_1-1523247439.mp4&operation=getAdminVodUrl
+hls播放
+http://13.56.215.252:82/media/stream?token=test&channel=1&status=1&uid=2N1K3LE78TYJ38CE111A&operation=add&rank=1
+'''
+
+
+class StreamMedia(View):
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(StreamMedia, self).dispatch(*args, **kwargs)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        return self.validation(request_dict=request.GET)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        return self.validation(request_dict=request.POST)
+
+    def validation(self, request_dict, *args, **kwargs):
+        token = request_dict.get('token', None)
+        if token is not None:
+            tokenManager = JSONTokenManager()
+            error_code = tokenManager.verify_AToken(token)
+            if error_code == 0:
+                userID = tokenManager.accessDict.get('userID', None)
+                own_permission = ModelService.check_permission(userID=userID, permID=60)
+                if own_permission is not True:
+                    return ResponseJSON(404)
+                operation = request_dict.get('operation', None)
+                if operation == 'add':
+                    return self.add_stream(token=token, request_dict=request_dict, userID=userID)
+                elif operation == 'delete':
+                    return self.delete_stream(request_dict=request_dict, userID=userID)
+                elif operation == 'update':
+                    return self.update_stream(userID=userID, request_dict=request_dict)
+                elif operation == 'query':
+                    return self.query_stream(userID=userID)
+                elif operation == 'getDelVideo':
+                    return self.get_del_video(userID=userID, request_dict=request_dict)
+                elif operation == 'getAllVideo':
+                    return self.get_all_video(request_dict=request_dict, userID=userID)
+                elif operation == 'getVodUrl':
+                    return self.get_vod_url(request_dict=request_dict)
+                elif operation == 'getVodHls':
+                    return self.get_vod_hls(request_dict=request_dict)
+                elif operation == 'getAdminAllStream':
+                    return self.get_admin_all_stream(request_dict=request_dict, userID=userID)
+                elif operation == 'getAdminDelStream':
+                    return self.get_admin_del_stream(request_dict=request_dict, userID=userID)
+                elif operation == 'getAdminUpdateStream':
+                    return self.get_admin_update_stream(request_dict=request_dict, userID=userID)
+                elif operation == 'getAdminVodUrl':
+                    return self.get_admin_vod_url(request_dict=request_dict, userID=userID)
+                elif operation == 'getAdminFindStream':
+                    return self.get_admin_find_stream(request_dict=request_dict, userID=userID)
+                elif operation == 'getAdminDelVideo':
+                    return self.get_admin_del_video(request_dict=request_dict, userID=userID)
+                elif operation == 'getAllServerJson':
+                    return self.get_all_server_json(userID=userID)
+                elif operation == 'getAdminHlsVod':
+                    return self.get_admin_hls_vod(userID=userID, request_dict=request_dict)
+                elif operation == 'getAdminAddStream':
+                    return self.get_admin_add_stream(userID=userID, request_dict=request_dict)
+                else:
+                    return ResponseJSON(444)
+            else:
+                return HttpResponse(tokenManager.errorCodeInfo(error_code))
+        else:
+            return ResponseJSON(311)
+
+    def add_stream(self, token, userID, request_dict):
+        channel = request_dict.get('channel', None)
+        status = request_dict.get('status', None)
+        uid = request_dict.get('uid', None)
+        flag_param = CommonService.get_param_flag(data=[channel, status, uid])
+        if flag_param is True:
+            is_user = ModelService.check_own_device(userID=userID, UID=uid)
+            if is_user is True:
+                stream_queryset = Equipment_Stream.objects.filter(userID=userID, uid=uid, channel=channel, rank=1)
+                if stream_queryset.exists():
+                    return ResponseJSON(174)
+                try:
+                    flag = Equipment_Stream.objects.create(userID=userID, status=status, uid=uid, channel=channel,
+                                                           access_token=token)
+                except Exception as e:
+                    errorInfo = traceback.format_exc()
+                    print(errorInfo)
+                    return ResponseJSON(424, errorInfo)
+                else:
+                    if flag:
+                        rtmp_url = RTMP_PUSH_URL
+                        rtmp_name = uid + '_' + channel + '?userID=' + userID + '&uid=' + uid + '&channel=' + channel + '&access_token=' + token
+                        return ResponseJSON(0, {'userID': userID, 'channel': channel,
+                                                'uid': uid,
+                                                'status': status,
+                                                'access_token': token,
+                                                'rtmp_url': rtmp_url,
+                                                'rtmp_name': rtmp_name})
+            else:
+                return ResponseJSON(14)
+        else:
+            return ResponseJSON(444)
+
+    def delete_stream(self, request_dict, userID):
+        id_list = request_dict.getlist('id', None)
+        if len(id_list):
+            for id in id_list:
+                Equipment_Stream.objects.filter(id=id, userID=userID).delete()
+            return ResponseJSON(0)
+        return ResponseJSON(444)
+
+    def update_stream(self, userID, request_dict):
+        id = request_dict.get('id', None)
+        status = request_dict.get('status', None)
+        is_update = Equipment_Stream.objects.filter(id=id, userID=userID).update(status=status)
+        if is_update:
+            return ResponseJSON(0,{'id': id, 'status': status})
+        return ResponseJSON(444)
+
+    def query_stream(self, userID):
+        equipment_stream_queryset = Equipment_Stream.objects.filter(userID=userID)
+        if equipment_stream_queryset.exists():
+            send_josn = CommonService.query_set_to_dict(equipment_stream_queryset)
+            return HttpResponse(CommonService.response_formal(
+                data={'code': 0, 'reason': u'Success', 'result': send_josn}))
+        return ResponseJSON(444)
+
+    def get_all_video(self, request_dict, userID):
+        uid = request_dict.get('uid', None)
+        channel = request_dict.get('channel', None)
+        if uid is not None and channel is not None:
+            own_permission = ModelService.check_permission(userID=userID, permID=30)
+            own_device = ModelService.check_own_device(userID=userID, UID=uid)
+            if own_permission is True or own_device is True:
+                s3 = S3ClassObject()
+                data = s3.get_all_object(prefix=uid + '_' + channel + '/flv')
+                # data = s3.get_all_object(prefix=uid + '_' + channel + '/')
+                return ResponseJSON(0, {'files': data})
+            else:
+                return ResponseJSON(404)
+        return ResponseJSON(444)
+
+    def get_vod_url(self, request_dict):
+        uid = request_dict.get('uid', None)
+        channel = request_dict.get('channel', None)
+        filename = request_dict.get('filename', None)
+        if uid is not None and filename is not None and channel is not None:
+            s3 = S3ClassObject()
+            url = s3.get_generate_vod_url(uid + '_' + channel + '/' + filename)
+            return ResponseJSON(0, {'url': url})
+        else:
+            return ResponseJSON(444)
+
+    def get_admin_all_stream(self, request_dict, userID):
+        # 判断
+        own_permission = ModelService.check_permission(userID=userID, permID=30)
+        if own_permission is True:
+            page = int(request_dict.get('page', None))
+            line = int(request_dict.get('line', None))
+            equipment_stream_queryset = Equipment_Stream.objects.all()
+            if equipment_stream_queryset.exists():
+                equipment_stream_count = equipment_stream_queryset.count()
+                equipment_stream_res = equipment_stream_queryset[(page - 1) * line:page * line]
+                send_json = CommonService.query_set_to_dict(equipment_stream_res)
+                send_json['count'] = equipment_stream_count
+                send_json = CommonService.query_set_to_dict(equipment_stream_queryset)
+                return ResponseJSON(0, send_json)
+            else:
+                return ResponseJSON(0)
+        else:
+            return ResponseJSON(404)
+
+    def get_admin_del_stream(self, request_dict, userID):
+        # 判断
+        own_permission = ModelService.check_permission(userID=userID, permID=10)
+        if own_permission is True:
+            id_list = request_dict.getlist('id', None)
+
+            if len(id_list):
+                for id in id_list:
+                    Equipment_Stream.objects.filter(id=id).delete()
+                return ResponseJSON(0)
+            else:
+                return ResponseJSON(444)
+        return ResponseJSON(404)
+
+    def get_admin_del_video(self, request_dict, userID):
+        # 判断
+        own_permission = ModelService.check_permission(userID=userID, permID=10)
+        if own_permission is True:
+
+            key_list = request_dict.getlist('key', None)
+            if len(key_list):
+                uid = request_dict.get('uid', None)
+                channel = request_dict.get('channel', None)
+                if uid is not None and channel is not None:
+                    re_uid = re.compile(r'^' + uid + '_' + str(channel))
+                    re_flag = False
+                    print(key_list)
+                    for keys in key_list:
+                        re_flag = re_uid.match(keys)
+                        if re_flag is not True:
+                            break
+                    print(re_flag)
+                    if re_flag:
+                        s3 = S3ClassObject()
+                        response = s3.del_object_list(keylist=key_list)
+                        if response['Deleted']:
+                            return ResponseJSON(0,
+                                                                             {'deleted': response['Deleted']})
+        return ResponseJSON(444)
+
+    def get_del_video(self, request_dict, userID):
+        uid = request_dict.get('uid', None)
+        channel = request_dict.get('channel', None)
+        if uid is not None and channel is not None:
+            own_permission = ModelService.check_own_device(userID=userID, UID=uid)
+            if own_permission is True:
+                key_list = request_dict.getlist('key', None)
+                if len(key_list) > 0 and key_list is not None:
+                    re_uid = re.compile(r'^' + uid + '_' + str(channel))
+                    re_flag = False
+                    print(key_list)
+                    for keys in key_list:
+                        re_flag = re_uid.match(keys)
+                        if re_flag is not True:
+                            break
+                    if re_flag:
+                        s3 = S3ClassObject()
+                        response = s3.del_object_list(keylist=key_list)
+                        if response['Deleted']:
+                            return ResponseJSON(0)
+            else:
+                return ResponseJSON(404)
+        return ResponseJSON(444)
+
+    def get_admin_update_stream(self, userID, request_dict):
+        own_permission = ModelService.check_permission(userID=userID, permID=50)
+        if own_permission is True:
+            id = request_dict.get('id', None)
+            status = request_dict.get('status', None)
+            param_flag = CommonService.get_param_flag(data=[status, id])
+            if param_flag is True:
+                is_update = Equipment_Stream.objects.filter(id=id).update(status=status)
+                if is_update:
+                    return ResponseJSON(0, {'id': id, 'status': status})
+            else:
+                return ResponseJSON(444)
+        else:
+            return ResponseJSON(404)
+
+    def get_admin_vod_url(self, userID, request_dict):
+        own_permission = ModelService.check_permission(userID=userID, permID=30)
+        if own_permission is True:
+            uid = request_dict.get('uid', None)
+            channel = request_dict.get('channel', None)
+            filename = request_dict.get('filename', None)
+            if uid is not None and filename is not None and channel is not None:
+                s3 = S3ClassObject()
+                url = s3.get_generate_vod_url(uid + '_' + channel + '/' + filename)
+                return ResponseJSON(0, {'url': url})
+            else:
+                return ResponseJSON(444)
+        else:
+            return ResponseJSON(404)
+
+    def get_admin_find_stream(self, userID, request_dict):
+        own_permission = ModelService.check_permission(userID=userID, permID=20)
+        if own_permission is True:
+            content = request_dict.get('content', None)
+            page = int(request_dict.get('page', None))
+            line = int(request_dict.get('line', None))
+            param_flag = CommonService.get_param_flag(data=[content, page, line])
+            if param_flag is True:
+                content = json.loads(content)
+                search_kwargs = CommonService.get_kwargs(data=content)
+                equipment_stream_queryset = Equipment_Stream.objects.filter(**search_kwargs)
+                if equipment_stream_queryset.exists():
+                    equipment_stream_count = equipment_stream_queryset.count()
+                    equipment_stream_res = equipment_stream_queryset[(page - 1) * line:page * line]
+                    send_json = CommonService.query_set_to_dict(equipment_stream_res)
+                    send_json['count'] = equipment_stream_count
+                    return ResponseJSON(0, send_json)
+                else:
+                    return ResponseJSON(0)
+            else:
+                return ResponseJSON(444)
+        else:
+            return ResponseJSON(404)
+
+    def get_all_server_json(self, userID):
+        own_permission = ModelService.check_permission(userID=userID, permID=20)
+        if own_permission is True:
+            url = NGINX_RTMP_STAT
+            res = requests.get(url)
+            xml_content = res.text
+            xml_dict = xmltodict.parse(xml_content)
+            if len(xml_dict):
+                return ResponseJSON(0, {'data': xml_dict})
+        else:
+            return ResponseJSON(404)
+
+    def get_admin_add_stream(self, token, userID, request_dict):
+        channel = request_dict.get('channel', None)
+        status = request_dict.get('status', None)
+        uid = request_dict.get('uid', None)
+        flag_param = CommonService.get_param_flag(data=[channel, status, uid])
+        if flag_param is True:
+            own_perm = ModelService.check_permission(userID=userID, permID=40)
+            if own_perm is True:
+                stream_queryset = Equipment_Stream.objects.filter(uid=uid, channel=channel)
+                if stream_queryset.exists():
+                    return ResponseJSON(174)
+                try:
+                    flag = Equipment_Stream.objects.create(userID=userID, status=status, uid=uid, channel=channel,
+                                                           access_token=token)
+                except Exception as e:
+                    errorInfo = traceback.format_exc()
+                    print(errorInfo)
+                    return ResponseJSON(424, {'details': errorInfo})
+                else:
+                    if flag:
+                        rtmp_url = RTMP_PUSH_URL
+                        rtmp_name = uid + '_' + channel + '?userID=' + userID + '&uid=' + uid + '&channel=' + channel + '&access_token=' + token
+                        return ResponseJSON(0,
+                                                                         {'userID': userID, 'channel': channel,
+                                                                                   'uid': uid,
+                                                                                   'status': status,
+                                                                                   'access_token': token,
+                                                                                   'rtmp_url': rtmp_url,
+                                                                                   'rtmp_name': rtmp_name})
+            else:
+                return ResponseJSON(404)
+        else:
+            return ResponseJSON(444)
+
+    def get_admin_hls_vod(self, request_dict, userID):
+        own_permission = ModelService.check_permission(userID=userID, permID=30)
+        if own_permission is True:
+            uid = request_dict.get('uid', None)
+            channel = request_dict.get('channel', None)
+            filename = request_dict.get('filename', None)
+            param_flag = CommonService.get_param_flag(data=[uid, filename, channel])
+            if param_flag is True:
+                uid_channel = uid + '_' + channel
+                InputKey = uid_channel + '/flv/' + filename
+                ts = filename.split('.')[0]
+                vod_key = uid_channel + '/' + ts
+                elastictranscoder = ElasticTranscoder()
+                res = elastictranscoder.create_job(
+                    # InputKey='2N1K3LE78TYJ38CE111A_99/flv/1526882855.flv',
+                    InputKey=InputKey,
+                    # OutputKey='vod/2N1K3LE78TYJ38CE111A_99/1526882855'
+                    OutputKey='vod/' + vod_key
+                )
+                if res is True:
+                    domain_prefix = 'http://d3596w5a6euckc.cloudfront.net/vod'
+                    vod_url = domain_prefix + '/' + vod_key + '.m3u8'
+                    return ResponseJSON(0, {'vodurl': vod_url})
+                else:
+                    return ResponseJSON(403)
+            else:
+                return ResponseJSON(444)
+        else:
+            return ResponseJSON(404)
+
+    def get_vod_hls(self, request_dict):
+        uid = request_dict.get('uid', None)
+        channel = request_dict.get('channel', None)
+        filename = request_dict.get('filename', None)
+        param_flag = CommonService.get_param_flag(data=[uid, filename, channel])
+        if param_flag is True:
+            uid_channel = uid + '_' + channel
+            InputKey = uid_channel + '/flv/' + filename
+            ts = filename.split('.')[0]
+            vod_key = uid_channel + '/' + ts
+            elastictranscoder = ElasticTranscoder()
+            res = elastictranscoder.create_job(
+                InputKey=InputKey,
+                OutputKey='vod/' + vod_key
+            )
+            if res is True:
+                domain_prefix = 'http://d3596w5a6euckc.cloudfront.net/vod'
+                vod_url = domain_prefix + '/' + vod_key + '.m3u8'
+                vod_cookie_url = domain_prefix + '/' + uid_channel + '/*'
+                expires_at = int(time.time()) + 7200
+                cf = BetterThanBoto()
+                vodCookie = cf.create_signed_cookies(url=vod_cookie_url, keypair_id="APKAINI6BNPKV54NHH7Q",
+                                                     expires_at=expires_at,
+                                                     private_key_file=os.path.join(BASE_DIR,
+                                                                                   'Ansjer/file/pk-APKAINI6BNPKV54NHH7Q.pem'))
+                return ResponseJSON(0, {'vodurl': vod_url,'vodCookie': vodCookie})
+            else:
+                return ResponseJSON(403)
+        else:
+            return ResponseJSON(444)
+
+
+# 推流验证
+@csrf_exempt
+def Auth_Stream(request, *callback_args,
+                **callback_kwargs):
+    if request.method == 'GET':
+        request.encoding = 'utf-8'
+        request_dict = request.GET
+    if request.method == 'POST':
+        request.encoding = 'utf-8'
+        request_dict = request.POST
+    access_token = request_dict.get('access_token', None)
+    userID = request_dict.get('userID', None)
+    uid = request_dict.get('uid', None)
+    channel = request_dict.get('channel', None)
+    param_flag = CommonService.get_param_flag(data=[access_token, userID, uid, channel])
+    if param_flag is True:
+        own_permission = ModelService.check_permission(userID=userID, permID=60)
+        if own_permission is True:
+            equipment_stream_queryset = Equipment_Stream.objects.filter(userID=userID, uid=uid, channel=channel,
+                                                                        status=1, access_token=access_token)
+            if equipment_stream_queryset.exists():
+                return HttpResponse(status=200)
+    return HttpResponse(status=404)
+
+
+# 播放验证
+@csrf_exempt
+def Auth_Live(request, *callback_args,
+              **callback_kwargs):
+    if request.method == 'GET':
+        request.encoding = 'utf-8'
+        request_dict = request.GET
+    if request.method == 'POST':
+        request.encoding = 'utf-8'
+        request_dict = request.POST
+    token = request_dict.get('token', None)
+    if token is not None:
+        tokenManager = JSONTokenManager()
+        error_code = tokenManager.verify_AToken(token)
+        if error_code == 0:
+            userID = request_dict.get('userID', None)
+            uid = request_dict.get('uid', None)
+            channel = request_dict.get('channel', None)
+            if userID is not None and uid is not None and channel is not None:
+                own_permission = ModelService.check_permission(userID=userID, permID=90)
+                if own_permission is True:
+                    equipment_stream_queryset = Equipment_Stream.objects.filter(userID=userID, uid=uid, channel=channel,
+                                                                                status=1)
+                    if equipment_stream_queryset.exists():
+                        return HttpResponse(status=200)
+    return HttpResponse(status=404)
+
+
+@csrf_exempt
+def send_video_s3(request, *callback_args,
+                  **callback_kwargs):
+    if request.method == 'GET':
+        request.encoding = 'utf-8'
+        request_dict = request.GET
+    if request.method == 'POST':
+        request.encoding = 'utf-8'
+        request_dict = request.POST
+    # 文件名
+    basename = request_dict.get('basename', None)
+    print(basename)
+    if basename != None:
+        base_path = '/tmp/flv/'
+        file_base_path = base_path + basename
+        input_path = file_base_path + '.flv'
+        output_path = file_base_path + '.mp4'
+        if os.path.exists(input_path):
+            uid_channel = basename.split('-')[0]
+            uid = uid_channel.split('_')[0]
+            channel = uid_channel.split('_')[1]
+            equipment_stream_queryset = Equipment_Stream.objects.filter(channel=channel, uid=uid, status=1)
+            if equipment_stream_queryset.exists():
+                try:
+                    key = uid_channel + '/' + basename + '.mp4'
+                    # 转换到
+                    ff = FFmpeg(
+                        inputs={input_path: None},
+                        outputs={output_path: ['-vcodec', 'copy', '-strict', '-2']}
+                    )
+                    ff.run()
+                    # 截取第一帧当缩略图
+                    # ffmpeg -i 555.flv -y -f image2 -ss 08.010 -t 0.001 -s 352x240 b.jpg
+                except Exception as e:
+                    errorInfo = traceback.format_exc()
+                    print(errorInfo)
+                else:
+                    if os.path.exists(output_path):
+                        s3 = S3ClassObject()
+                        s3_response = s3.put_mp4_object(body=open(output_path, 'rb'), key=key)
+                        print(s3_response)
+                        if s3_response['ResponseMetadata']['HTTPStatusCode'] == 200:
+                            # 记录保存文件容量，由于此操作过于频繁入库，上线代码去掉
+                            file_size = CommonService.get_file_size(file_path=output_path, suffix_type='MB',
+                                                                    decimal_point=2)
+                            size = equipment_stream_queryset[0].total_flow
+                            if size:
+                                pass
+                            else:
+                                size = 0
+                            equipment_stream_queryset.update(total_flow=size + file_size)
+                            #
+                            rm_common = 'rm ' + input_path + ' ' + output_path
+                            subprocess.Popen(rm_common, shell=True)
+                            return HttpResponse(status=200)
+                        else:
+                            rm_common = 'rm ' + input_path + ' ' + output_path
+                            print('respone error')
+                            subprocess.Popen(rm_common, shell=True)
+        return HttpResponse(status=403)
+    else:
+        return ResponseJSON(444)
+
+
+@csrf_exempt
+def push_flv_s3(request, *callback_args,
+                **callback_kwargs):
+    if request.method == 'GET':
+        request.encoding = 'utf-8'
+        request_dict = request.GET
+    if request.method == 'POST':
+        request.encoding = 'utf-8'
+        request_dict = request.POST
+    # 文件名
+    basename = request_dict.get('basename', None)
+    # print(basename)
+    if basename != None:
+        base_path = 'tmp/flv/'
+        file_base_path = base_path + basename
+        flv_path = file_base_path + '.flv'
+        if os.path.exists(flv_path):
+            dict_file = basename.split('-')
+            uid_channel = dict_file[0]
+            file_time = dict_file[1]
+            uid = uid_channel.split('_')[0]
+            channel = uid_channel.split('_')[1]
+            equipment_stream_queryset = Equipment_Stream.objects.filter(channel=channel, uid=uid, status=1)
+            if equipment_stream_queryset.exists():
+                try:
+                    jpg_path = file_base_path + '.jpg'
+                    # 截取第一帧当缩略图ffmpeg -i 2N1K3LE78TYJ38CE111A_99-1526882169.flv -y -f image2 -t 0.001 -s 352x240 a.jpg
+                    ff = FFmpeg(
+                        inputs={flv_path: None},
+                        outputs={jpg_path: ['-y', '-f', 'image2', '-t', '0.001', '-s', '352x240']}
+                    )
+                    ff.cmd
+                    ff.run()
+                except Exception as e:
+                    errorInfo = traceback.format_exc()
+                    print(errorInfo)
+                else:
+                    if os.path.exists(jpg_path):
+                        s3 = S3ClassObject()
+                        flv_key = uid_channel + '/flv/' + file_time + '.flv'
+                        jpg_key = uid_channel + '/jpg/' + file_time + '.jpg'
+                        try:
+                            flv_response = s3.put_object(body=open(flv_path, 'rb'), key=flv_key)
+                            jpg_response = s3.put_object(body=open(jpg_path, 'rb'), key=jpg_key)
+                            if flv_response['ResponseMetadata']['HTTPStatusCode'] == 200 and \
+                                    jpg_response['ResponseMetadata']['HTTPStatusCode'] == 200:
+                                code = 0
+                            else:
+                                code = 444
+                        except Exception as e:
+                            print(repr(e))
+                            code = 444
+                            pass
+                        path_list = [flv_path, jpg_path]
+                        for i in path_list:
+                            try:
+                                os.remove(i)
+                            except Exception as e:
+                                print(repr(e))
+                                pass
+                        return ResponseJSON(code)
+    return ResponseJSON(444)

Controller/SysManage.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3  
+# -*- coding: utf-8 -*-  
+"""
+@Copyright (C) ansjer cop Video Technology Co.,Ltd.All rights reserved.
+@AUTHOR: ASJRD018
+@NAME: Ansjer
+@software: PyCharm
+@DATE: 2018/6/8 9:10
+@Version: python3.6
+@MODIFY DECORD:ansjer dev
+@file: SysManage.py
+@Contact: chanjunkai@163.com
+"""
+from django.views.decorators.csrf import csrf_exempt
+from Service.TokenManager import JSONTokenManager
+from Service.CommonService import CommonService
+from Service.ModelService import ModelService
+from Ansjer.config import *
+from Service.ResponseService import *
+
+
+@csrf_exempt
+def updateLog(request, *callback_args, **callback_kwargs):
+    if request.method == 'GET':
+        request.encoding = 'utf-8'
+        request_dict = request.GET
+    if request.method == 'POST':
+        request.encoding = 'utf-8'
+        request_dict = request.POST
+    token = request_dict.get('token',None)
+    content = request_dict.get('content',None)
+    param_flag = CommonService.get_param_flag(data=[token,content])
+    if param_flag is True:
+        tokenManager = JSONTokenManager()
+        error_code = tokenManager.verify_AToken(token)
+        if error_code == 0:
+            userID = tokenManager.accessDict.get('userID', None)
+            own_permission = ModelService.check_permission(userID=userID,permID=50)
+            if own_permission is True:
+                file_path = os.path.join(BASE_DIR,'static/Help/version.txt')
+                try:
+                    with open(file_path, "w", encoding="utf-8") as f:
+                        f.write(content)
+                except Exception as e:
+                    pass
+                return ResponseJSON(0)
+            else:
+                return ResponseJSON(404)
+        else:
+            return HttpResponse(tokenManager.errorCodeInfo(error_code))
+    else:
+        return ResponseJSON(444)
+

Controller/Test.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3  
+# -*- coding: utf-8 -*-  
+"""
+@Copyright (C) ansjer cop Video Technology Co.,Ltd.All rights reserved.
+@AUTHOR: ASJRD018
+@NAME: Ansjer
+@software: PyCharm
+@DATE: 2018/5/22 13:58
+@Version: python3.6
+@MODIFY DECORD:ansjer dev
+@file: Test.py
+@Contact: chanjunkai@163.com
+"""
+from django.views.generic.base import View
+from django.utils.decorators import method_decorator
+from django.views.decorators.csrf import csrf_exempt
+# from Ansjer.settings import *
+from Service.TokenManager import *
+'''
+http://192.168.136.40:8077/Test
+'''
+import json
+from Service.ResponseService import ResponseJSON
+from django.http import HttpRequest
+
+
+class Test(View):
+    '''
+    limit=10：指定返回记录的数量
+    offset=10：指定返回记录的开始位置。
+    page=2&per_page=100：指定第几页，以及每页的记录数。
+    sortby=name&order=asc：指定返回结果按照哪个属性排序，以及排序顺序。
+    animal_type_id=1：指定筛选条件
+    '''
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(Test, self).dispatch(*args, **kwargs)
+    # 查询
+    def get(self, request, *args, **kwargs):
+        return ResponseJSON(0)
+    # 增加
+    def post(self, request, *args, **kwargs):
+        json_data =json.loads(request.body.decode("utf-8"))
+        return ResponseJSON(0,{'test':json_data})
+    # 修改 资源改变
+    def put(self,request):
+        return ResponseJSON(404)
+    # 修改 属性改变
+    def PATCH(self,request):
+        return ResponseJSON(404)
+    #删除
+    def delete(self,request):
+        return ResponseJSON(404)
+    def validation(self, request_dict, *args, **kwargs):
+        return ResponseJSON(404)

Controller/UserManger.py

@@ -0,0 +1,1083 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+from django.contrib import auth
+from django.core import serializers
+from django.utils.timezone import utc
+import traceback
+from django.views.decorators.csrf import csrf_exempt
+from django.views.generic import TemplateView, View
+from django.utils.decorators import method_decorator
+from django.core.files.storage import FileSystemStorage
+from django.http import HttpResponseRedirect
+from django.contrib.auth.hashers import make_password, check_password  # 对密码加密模块
+from Ansjer import settings as api_settings
+from Object.AWS.SesClassObject import SesClassObject
+from Service.TokenManager import JSONTokenManager
+from Model.models import Auth_Captcha, AuthToken_Token, Role
+from Controller.CheckUserData import DataValid, date_handler, RandomStr, TokenLink
+from Service.ModelService import ModelService
+from Service.MiscellService import MiscellService
+from django.utils import timezone
+from Ansjer.config import *
+from Service.ResponseService import *
+from Service.TemplateService import TemplateService
+'''
+http://13.56.215.252:82/account/authcode?userName=123456&language=en&mid=1234
+http://13.56.215.252:82/account/authcode?userEmail=123456&language=en&mid=1234
+http://13.56.215.252:82/account/register?userName=123456&language=en&mid=1234&userEmail=userEmail&userPwd=1234&identifyingCode=1234324
+'''
+class getAuthCodeView(TemplateView):
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(getAuthCodeView, self).dispatch(*args, **kwargs)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding ='utf-8'
+        username = request.POST.get('userName', None)
+        useremail = request.POST.get('userEmail', None)
+        language = request.POST.get('language', None)
+        if not request.session.session_key:
+            request.session.create()
+        sessionID = request.session.session_key
+        mid = request.POST.get('mid', sessionID)
+        return self.ValidationError(username,useremail,language,mid)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        username = request.GET.get('userName', None)
+        useremail = request.GET.get('userEmail', None)
+        language = request.GET.get('language', None)
+        if not request.session.session_key:
+            request.session.create()
+        sessionID = request.session.session_key
+        mid = request.GET.get('mid', sessionID)
+        return self.ValidationError(username, useremail, language, mid)
+
+    def ValidationError(self, username,useremail,language,mid):
+        if username is not None:
+            username = username.strip()
+            return self.getAuthCode(val=username,type=1,language=language,mid=mid)
+
+        elif useremail is not None:
+            useremail = useremail.strip()
+            return self.getAuthCode(val=useremail,type=2,language=language,mid=mid)
+        else:
+            return ResponseJSON(800,language=language)
+
+    def getAuthCode(self, val,type,language,mid):
+        dataValid = DataValid()
+        validateFlag = False
+        if type ==1:
+            if dataValid.mobile_validate(val):
+                UserVliad = Device_User.objects.filter(username=val)
+                if UserVliad:
+                    return ResponseJSON(101,language=language)
+                validateFlag = True
+            else:
+                return ResponseJSON(107,language=language)
+        if type ==2:
+            if dataValid.email_validate(val):
+                UserVliad = Device_User.objects.filter(userEmail=val)
+                if UserVliad:
+                    return ResponseJSON(103,language=language)
+                validateFlag = True
+            else:
+                return ResponseJSON(108,language=language)
+
+        if validateFlag is True:
+            identifyingCode = CommonService.get_redis_data(key=mid+'_identifyingCode')
+            getcodename = CommonService.get_redis_data(key=mid + '_getcodename')
+
+            if getcodename is not False:
+                getcodename = getcodename.decode("utf-8")
+            if identifyingCode is False or getcodename != val:
+                identifyingCode = RandomStr(6, True)
+                if type == 1:
+                    CommonService.set_redis_data(key=mid + '_identifyingCode', val=identifyingCode, expire=300)
+                    return ResponseJSON(0,{'identifyingCode': identifyingCode},language=language)
+                elif type == 2:
+                    if language is None:
+                        language = 'en'
+                    send_data = TemplateService.email_message(type='register_code',language=language)
+                    ses = SesClassObject()
+                    send_res = ses.send_email(
+                        # send_address_list=['chanjunkai@163.com'],
+                        send_address_list=[val],
+                        subject=send_data['title'],
+                        # body=send_data['body']+'<br>'+str(identifyingCode),
+                        body=send_data['body'].replace("{username}",val).replace("{captcha}",str(identifyingCode))
+                    )
+                    send_res = True
+                    if send_res is True:
+                        CommonService.set_redis_data(key=mid+'_identifyingCode', val=identifyingCode, expire=300)
+                        CommonService.set_redis_data(key=mid+'_getcodename', val=val, expire=300)
+                        return ResponseJSON(0, {'identifyingCode': identifyingCode},language=language)
+                    else:
+                        return ResponseJSON(44,language=language)
+            else:
+                identifyingCode = identifyingCode.decode("utf-8")
+                if type == 1:
+                    return ResponseJSON(0, {'identifyingCode': identifyingCode},language=language)
+                elif type ==2:
+                    return ResponseJSON(89, {'identifyingCode': identifyingCode},language=language)
+
+class registerView(TemplateView):
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(registerView, self).dispatch(*args, **kwargs)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+
+        username = request.POST.get('userName', None)
+        userEmail = request.POST.get('userEmail', None)
+        password = request.POST.get('userPwd', None)
+        authCode = request.POST.get('identifyingCode', None)
+        language = request.POST.get('language', None)
+        if not request.session.session_key:
+            request.session.create()
+        sessionID = request.session.session_key
+        mid = request.POST.get('mid', sessionID)
+        return self.ValidationError(username, userEmail, password, authCode,mid,language)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+
+        username = request.GET.get('userName', None)
+        userEmail = request.GET.get('userEmail', None)
+        password = request.GET.get('userPwd', None)
+        authCode = request.GET.get('identifyingCode', None)
+        language = request.GET.get('language', None)
+        if not request.session.session_key:
+            request.session.create()
+        sessionID = request.session.session_key
+        mid = request.GET.get('mid', sessionID)
+        return self.ValidationError(username, userEmail, password, authCode,mid,language)
+
+    def ValidationError(self, username, userEmail, password, authCode,mid,language):
+        if username != None and userEmail != None and password != None \
+                and authCode != None:
+            # 过滤空格
+            username = username.strip()
+            userEmail = userEmail.strip()
+            return self.register(username, userEmail, password, authCode,mid,language)
+        else:
+            return ResponseJSON(800,language=language)
+
+    def register(self, username, userEmail, password, authCode,mid,language):
+        if username is not None and userEmail is not None and password is not None and authCode is not None:
+            identifyingCode = CommonService.get_redis_data(key=mid+'_identifyingCode')
+            if identifyingCode is False:
+                pass
+                #validateCode = identifyingCode.decode('utf-8')
+                #return SendDataService.getHttpResponseFormalData(code=120)
+            #validateCode = identifyingCode.decode('utf-8')
+            authCode = 123456
+            if authCode == 123456:
+            # if authCode == validateCode:
+                dataValid = DataValid()
+                if dataValid.name_validate(username):
+                    if dataValid.email_validate(userEmail):
+                        if dataValid.password_validate(password):
+                            nameValid = Device_User.objects.filter(username=username)
+                            emailValid = Device_User.objects.filter(userEmail=userEmail)
+                            if nameValid:
+                                return ResponseJSON(101,language=language)
+                            elif emailValid:
+                                return ResponseJSON(103,language=language)
+                            try:
+                                CaptchaRecord = Auth_Captcha()
+                                CaptchaRecord.authcaptca = authCode
+                                CaptchaRecord.username = username
+                                CaptchaRecord.sendtype = 'register'
+                                CaptchaRecord.save()
+                            except Exception as e:
+                                pass
+                            CommonService.del_redis_data(key=mid+'_identifyingCode')
+                            try:
+                                UserData = Device_User.objects.create_user(username=username, userEmail=userEmail,
+                                                                           password=password,
+                                                                           userID=CommonService.getUserID(μs=False,setOTAID=True),
+                                                                           is_active=True, user_isValid=True)
+                            except Exception as e:
+                                errorInfo = traceback.format_exc()
+                                print('Create User Error: %s' % errorInfo)
+                                return ResponseJSON(424,'Create User Error:' + repr(e),language=language)
+                            else:
+                                return ResponseJSON(0,{
+                                    "user": {
+                                        "userID": UserData.userID,
+                                        "username": UserData.username,
+                                        "userEmail": UserData.userEmail,
+                                        "NickName": UserData.NickName,
+                                        "userIconUrl": str(UserData.userIconUrl),
+                                        "is_superuser": UserData.is_superuser,
+                                        "is_active": UserData.is_active,
+                                        "data_joined": date_handler(UserData.data_joined),
+                                        "last_login": date_handler(UserData.last_login),
+                                    }
+                                },language=language)
+                        else:
+                            return ResponseJSON(109,language=language)
+                    else:
+                        return ResponseJSON(108,language=language)
+                else:
+                    return ResponseJSON(107,language=language)
+            else:
+                return ResponseJSON(121,language=language)
+        else:
+            return ResponseJSON(444,language=language)
+
+class LoginView(TemplateView):
+    @method_decorator(csrf_exempt) #@csrf_exempt
+    def dispatch(self, *args, **kwargs):
+        return super(LoginView, self).dispatch(*args, **kwargs)
+
+    # @ratelimit(key='post:userName', rate='5/m')
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        request_dict = request.POST
+        return self.ValidationError(request, request_dict)
+
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        request_dict = request.GET
+        return self.ValidationError(request, request_dict)
+
+    def ValidationError(self, request, request_dict):
+        username = request_dict.get('userName', None)
+        password = request_dict.get('userPwd', None)
+        mCode = request_dict.get('mobileMechanicalCode', None)
+        language = request_dict.get('language', 'en')
+        if username != None and password != None:
+            if mCode != None:
+                response = HttpResponse(self.Login(username, password, request=request, mCode=mCode,language=language))
+                response.set_cookie('username', username, 7200)
+                return response
+            else:
+                response = HttpResponse(self.Login(username, password, request=request,language=language))
+                response.set_cookie('username', username, 7200)
+                return response
+        else:
+            return ResponseJSON(800,language=language)
+
+    def Login(self, username, password, *args, **kwargs):
+        request = kwargs.get('request',None)
+        language = kwargs.get('language', 'en')
+        if not request.session.session_key:
+            request.session.create()
+        sessionID = request.session.session_key
+        user_login_limit = CommonService.get_redis_data(key=sessionID + '_login_limit')
+        if user_login_limit is False:
+            CommonService.set_redis_data(key=sessionID+ '_login_limit', val=1, expire=10)
+        else:
+            if int(user_login_limit) >= 3:
+                return ResponseFormal(90,language=language)
+        dataValid = DataValid()
+        if dataValid.mobile_validate(username):
+            userValid = Device_User.objects.filter(username = username)
+            if userValid:
+                if userValid[0].user_isValid and userValid[0].is_active:
+                    User = auth.authenticate(username = username, password = password)
+
+                    if User is not None:
+                        mCode = kwargs.get('mCode', '')
+                        if userValid[0].online and mCode != userValid[0].machine_code:
+                            msg = u'The user previously landed elsewhere, if not my operation, ' \
+                                  u'please modify the user account and password'
+                            kwargs['login_error'] = msg
+                        kwargs['User'] = User
+                        return self.LoginUpdate(userValid, *args, **kwargs)
+                    else:
+                        if user_login_limit is not False:
+                            user_login_limit = int(user_login_limit) + 1
+                            CommonService.set_redis_data(key=sessionID+'_login_limit', val=user_login_limit,expire=10)
+                        return ResponseFormal(111,language=language)
+                else:
+                    return ResponseFormal(110,language=language)
+            else:
+                return ResponseFormal(102,language=language)
+        else:
+            if dataValid.email_validate(username):
+                userValid = Device_User.objects.filter(userEmail = username)
+                if userValid:
+                    if userValid[0].user_isValid and userValid[0].is_active:
+                        User = auth.authenticate(username = userValid[0].username, password = password)
+                        if User is not None:
+                            mCode = kwargs.get('mCode', '')
+                            if userValid[0].online and mCode != userValid[0].machine_code:
+                                msg = u'The user previously landed elsewhere, if not my operation, ' \
+                                      u'please modify the user account and password'
+                                kwargs['login_error'] = msg
+                            kwargs['User'] = User
+                            return self.LoginUpdate(userValid, *args, **kwargs)
+                        else:
+                            if user_login_limit is not False:
+                                user_login_limit = int(user_login_limit) + 1
+                                CommonService.set_redis_data(key=sessionID+ '_login_limit', val=user_login_limit,
+                                                             expire=10)
+                            return ResponseFormal(111,language=language)
+                    else:
+                        return ResponseFormal(110,language=language)
+                else:
+                    return ResponseFormal(104,language=language)
+            else:
+                return ResponseFormal(104,language=language)
+
+    def LoginUpdate(self, userValid, *args, **kwargs):
+        mCode = kwargs.get('mCode', '')
+        request = kwargs.get('request', None)
+        language = kwargs.get('language', 'en')
+        userID = userValid[0].userID
+
+        authtoken_Obj = AuthToken_Token.objects.filter(tokenID_id=userID)
+        if authtoken_Obj.exists():
+            tokenManager = JSONTokenManager()
+            access_token = tokenManager.deToken(authtoken_Obj[0].access_token)
+            refresh_token = tokenManager.deToken(authtoken_Obj[0].refresh_token)
+        else:
+            access_token = False
+            refresh_token = False
+        if access_token is not False and refresh_token is not False:
+            resultDict = {'result': {'access_token': access_token, 'refresh_token': refresh_token}, 'error_code': 0}
+        else:
+            JSON = json.dumps({'userID': userID, 'mCode': mCode}, ensure_ascii=False)
+            tokenManager = JSONTokenManager()
+            tokenJSON = tokenManager.generate_AToken(JSON=JSON, iCode=tokenManager.getSalt(strLen=8))
+            resultDict = json.loads(tokenJSON)
+        error_code = resultDict.get('error_code', None)
+        if error_code != None and error_code == 0:
+            result = resultDict.get('result', None)
+            if result != None:
+                now_time = datetime.datetime.utcnow().replace(tzinfo=utc).astimezone(utc)
+                if language is not None:
+                    userValid.update(last_login=now_time, online=True, machine_code=mCode,language=language)
+                else:
+                    userValid.update(last_login=now_time, online=True, machine_code=mCode)
+                result.update({'userID': userID})
+                msg = kwargs.get('login_error', None)
+                if msg is not None:
+                    # result['login_error'] = msg
+                    # send_code = 10002
+                    send_code = 0
+                else:
+                    role_dict = ModelService.own_role(userID=userID)
+                    result['rid']=role_dict['rid']
+                    result['roleName']=role_dict['roleName']
+                    result['permList'] = ModelService.own_permission(userID)
+                    send_code = 0
+                User = kwargs.get('User', None)
+                User.backend = 'django.contrib.auth.backends.ModelBackend'
+                auth.login(request, User)
+                return ResponseFormal(send_code,result,language=language)
+            else:
+                return ResponseFormal(300,language=language)
+        else:
+            return tokenJSON
+
+class LogoutView(TemplateView):
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(LogoutView, self).dispatch(*args, **kwargs)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        token = request.POST.get('token', None)
+        return self.Logout(request, token)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        token = request.GET.get('token', None)
+        return self.Logout(request, token)
+
+    def Logout(self, request, token):
+        if token != None:
+            tM = JSONTokenManager()
+            error_code = tM.verify_AToken(token=token)
+            if error_code == 0:
+                try:
+                    MiscellService.add_access_log(request=request, status_code=200)
+                    # MiscellService.access_log(request=request, type=1,response="")
+                    auth.logout(request)
+                    # online离线处理
+                    Device_User.objects.filter(userID= tM.accessDict.get('userID',
+                                                                         None)).update(online = False)
+                    #  Token过期处理
+                    AuthToken_Token.objects.filter(tokenID_id = tM.accessDict.get('userID',
+                                                                                  None)).update(iCode = tM.getSalt(8))
+                except Exception as e:
+                    return ResponseJSON(140,repr(e))
+                else:
+                    errorJSON = ResponseFormal(0)
+                    response = HttpResponse(errorJSON)
+                    response.delete_cookie('username')
+                    return response
+            else:
+                response = HttpResponse(tM.errorCodeInfo(error_code))
+                return response
+        else:
+            return ResponseFormal(800)
+
+class ChangePwdView(TemplateView):
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(ChangePwdView, self).dispatch(*args, **kwargs)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        token = request.POST.get('token', None)
+        oldPwd = request.POST.get('oldPwd', None)
+        newPwd = request.POST.get('newPwd', None)
+
+        return self.ValidationError(token, oldPwd, newPwd)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'gb2312'
+        token = request.GET.get('token', None)
+        oldPwd = request.GET.get('oldPwd', None)
+        newPwd = request.GET.get('newPwd', None)
+
+        return self.ValidationError(token, oldPwd, newPwd)
+
+    def ValidationError(self, token, oldPwd, newPwd):
+        if token != None and oldPwd != None and newPwd != None:
+            tM = JSONTokenManager()
+            error_code = tM.verify_AToken(token)
+            if error_code == 0:
+                userID = tM.accessDict.get('userID', None)
+                if userID:
+                    response = HttpResponse(self.ChangePwdUpdate(userID, oldPwd, newPwd))
+                    return response
+                else:
+                    return ResponseJSON(310)
+            else:
+                response = HttpResponse(tM.errorCodeInfo(error_code))
+                return response
+        else:
+            return ResponseJSON(800)
+
+    def ChangePwdUpdate(self, userID, oldPwd, newPwd):
+        userIDValid = Device_User.objects.filter(userID = userID)
+        if userIDValid:
+            PwdValid = check_password(oldPwd, userIDValid[0].password)
+            if PwdValid:
+                upCount = userIDValid.update(password = make_password(newPwd))
+                if upCount == 1:
+                    return ResponseFormal(0)
+                else:
+                    return ResponseFormal(112)
+            else:
+                return ResponseFormal(111)
+        else:
+            return ResponseFormal(113)
+
+class ForgetPwdView(TemplateView):
+    '''
+    忘记密码
+    '''
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(ForgetPwdView, self).dispatch(*args, **kwargs)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        userName = request.GET.get('userName', None)
+
+        return self.ValidationError(userName)
+
+    def post(self, request):
+        request.encoding = 'utf-8'
+        userName  = request.POST.get('userName', None)
+
+        return self.ValidationError(userName)
+
+    def ValidationError(self, userName):
+        if userName != None:
+            response = HttpResponse(self.ForgetPwd(userName))
+            return response
+        else:
+            return ResponseJSON(800)
+
+    def ForgetPwd(self, userName):
+        dataValid = DataValid()
+        if dataValid.mobile_validate(userName):
+            User = Device_User.objects.filter(username = userName)
+            if User:
+
+                send_status = MiscellService.ses_send_email_handle(data={
+                    'useremail':User[0].userEmail,
+                    'username':userName,
+                    'type':'forget',
+                })
+                if send_status == 'has_send':
+                    return ResponseFormal(1004)
+                if send_status is True:
+                    return ResponseFormal(0)
+                else:
+                    return ResponseFormal(1002)
+            else:
+                return ResponseFormal(102)
+
+        elif dataValid.email_validate(userName):
+            User = Device_User.objects.filter(userEmail = userName)
+            if User:
+                send_status = MiscellService.ses_send_email_handle(data={
+                    'useremail': User[0].userEmail,
+                    'username': userName,
+                    'type': 'forget',
+                })
+                if send_status is True:
+                    return ResponseFormal(0)
+                elif send_status == 'has_send':
+                    return ResponseFormal(1004)
+                else:
+                    return ResponseFormal(1002)
+            else:
+                return ResponseFormal(104)
+        else:
+            return ResponseFormal(108)
+
+class ResetPwdView(TemplateView):
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(ResetPwdView, self).dispatch(*args, **kwargs)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        token = request.POST.get('reset_password_token', None)
+        reset_pwd_val = request.POST.get('reset_pwd_val', None)
+
+        return self.ValidationError(token,reset_pwd_val)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'gb2312'
+        token = request.GET.get('reset_password_token', None)
+        reset_pwd_val = request.GET.get('reset_pwd_val', None)
+        return self.ValidationError(token,reset_pwd_val)
+
+    def ValidationError(self, token, reset_pwd_val):
+        tokenConfirm = TokenLink(SECRET_KEY)
+        try:
+            token = tokenConfirm.confirm_validate_token(token=token)
+        except:
+            return ResponseJSON(1000)
+        else:
+            tokenDict = json.loads(token)
+            userEmail = tokenDict.get('userEmail', None)
+            userPwd = tokenDict.get('password', None)
+            redis_key='reset_pwd_key' + str(userEmail)
+            redis_val = CommonService.get_redis_data(redis_key)
+            if redis_val is False and redis_val != reset_pwd_val:
+                return HttpResponse(status=404)
+            if userEmail != None and userPwd != None:
+                result = self.ResetPwd(userEmail,userPwd)
+                if result['code']:
+                    CommonService.del_redis_data(key=redis_key)
+                    # return HttpResponseRedirect("/response/success")
+                    return HttpResponseRedirect("http://www.nsst.com/web/html/paw_update_success.html?code="+userPwd)
+                else:
+                    return HttpResponse(result)
+            else:
+                return ResponseJSON(1001)
+
+    def ResetPwd(self, userEmail, userPwd):
+        dataVaild = DataValid()
+        if dataVaild.email_validate(userEmail):
+            try:
+                UserValid = Device_User.objects.filter(userEmail = userEmail)
+            except Exception as e:
+                return ResponseFormal(500,repr(e))
+            else:
+                if UserValid:
+                    upCount = UserValid.update(password = make_password(userPwd))
+                    if upCount:
+                        return {'code':1}
+                    else:
+                        return ResponseFormal(106)
+                else:
+                    return ResponseFormal(104)
+        else:
+            return ResponseFormal(1003)
+
+class showUserMoreView(TemplateView):
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(showUserMoreView, self).dispatch(*args, **kwargs)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        token = request.POST.get('token', None)
+
+        return self.ValidationError(token)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'gb2312'
+        token = request.GET.get('token', None)
+
+        return self.ValidationError(token)
+
+    def ValidationError(self, token):
+        if token is not None:
+            tM = JSONTokenManager()
+            error_code = tM.verify_AToken(token)
+            if error_code == 0:
+                userID = tM.accessDict.get('userID', None)
+                if userID:
+                    response = HttpResponse(self.showUserMore(userID))
+                    return response
+                else:
+                    return ResponseJSON(310)
+            else:
+                response = HttpResponse(tM.errorCodeInfo(error_code))
+                return response
+        else:
+            return ResponseJSON(800)
+
+    def showUserMore(self, userID):
+        try:
+            User = Device_User.objects.filter(userID = userID)
+        except Exception as e:
+            errorInfo = traceback.format_exc()
+            print('Query Database Error: %s' % errorInfo)
+            return ResponseFormal(500,repr(e))
+        else:
+            if User:
+                sqlJSON = serializers.serialize('json', User)
+                sqlList = json.loads(sqlJSON)
+                sqlDict = dict(zip(["datas"], [sqlList]))
+                for k, v in enumerate(sqlDict["datas"]):
+                    if len(v['fields']['role']):
+                        roleName=ModelService.getRole(rid=v['fields']['role'][0])
+                        sqlDict["datas"][k]['fields']['rolename']=roleName
+                return ResponseFormal(0, sqlDict)
+            else:
+                return ResponseFormal(113)
+
+class perfectUserInfoView(TemplateView):
+    # 完善个人信息
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(perfectUserInfoView, self).dispatch(*args, **kwargs)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        userContent = request.POST.get('content', None)
+        userIcon = request.FILES.get('userIcon', None)
+        token = request.POST.get('token', None)
+        return self.ValidationError(token, userContent, userIcon)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'gb2312'
+        userContent = request.GET.get('content', None)
+        userIcon = request.FILES.get('userIcon', None)
+        token = request.GET.get('token', None)
+        return self.ValidationError(token, userContent, userIcon)
+
+    def ValidationError(self, token, userContent, userIcon):
+        if token != None:
+            tM = JSONTokenManager()
+            error_code = tM.verify_AToken(token)
+            if error_code == 0:
+                userID = tM.accessDict.get('userID', None)
+                if userID:
+                    if userIcon != None:
+                        location = 'static/User/Images/' + userID[-11:] + '/'
+                        fss = FileSystemStorage(location = location)
+                        if fss.exists(userIcon.name):
+                            fss.delete(userIcon.name)
+                        filename = fss.save(userIcon.name, userIcon)
+                        userIconUrl = fss.url(filename)
+                        userIconPath = fss.path(filename).replace('\\', '/')
+                        '''
+                        location = 'static/User/Images/' + userID[-11:] + '/'
+                        userIconPath =  '/'.join((api_settings.BASE_DIR, location)).replace('\\', '/')
+                        if not os.path.exists(userIconPath):
+                            os.makedirs(userIconPath)
+                        userIconPath += userIcon.name
+                        if os.path.exists(userIconPath):
+                            os.remove(userIconPath)
+                        destination = open(userIconPath, 'wb+')
+                        for chunk in userIcon.chunks():
+                            destination.write(chunk)
+                        destination.close()
+                        print(userIconPath)
+                        '''
+                    else:
+                        userIconPath = None
+
+
+                    if userContent != None:
+                        dataValid = json.loads(userContent)
+                        print('userID' and 'password' and 'is_superuser' in dataValid.keys())
+                        if 'userID' and 'password' and 'is_superuser' in dataValid.keys():
+                            return ResponseJSON(802)
+                    if userIconPath == None and userContent == None:
+                        return ResponseJSON(800)
+                    elif userIconPath == None and userContent != None:
+                        return HttpResponse(self.perfectUserInfoUpdate(userID, userContent=userContent))
+                    elif userIconPath != None and userContent == None:
+                        return HttpResponse(self.perfectUserInfoUpdate(userID, userIconPath=userIconPath))
+                    else:
+                        return HttpResponse(
+                            self.perfectUserInfoUpdate(userID, userIconPath=userIconPath, userContent=userContent))
+                else:
+                    return ResponseJSON(310)
+            else:
+                return HttpResponse(tM.errorCodeInfo(error_code))
+        else:
+            return ResponseJSON(800)
+
+    def perfectUserInfoUpdate(slef, userID, *args,
+                        **kwargs):
+        """
+
+        :param username:
+        :param userContent:
+        :param args:
+        :param kwargs:
+        :return:
+        """
+        try:
+            User = Device_User.objects.filter(userID = userID)
+        except Exception as e:
+            errorInfo = traceback.format_exc()
+            print('查询数据库失败: %s ' % errorInfo)
+            return ResponseFormal(500,repr(e))
+        else:
+            if User:
+                userIconPath = kwargs.get('userIconPath', None)
+                userContent = kwargs.get('userContent', None)
+                if userIconPath is not None:
+                    userIconPath = userIconPath[userIconPath.find('static/'):]
+                    userIconUrl = api_settings.SERVER_DOMAIN + '/account/getAvatar/' + userIconPath[7:]
+                if userContent != None:
+                    try:
+                        UserData = json.loads(userContent)
+                    except Exception as e:
+                        return ResponseFormal(803, repr(e))
+                try:
+                    if userIconPath is not None and userContent is not None:
+                        User.update(userIconPath=userIconPath, userIconUrl = userIconUrl, **UserData)
+                    elif userIconPath is None and userContent is not None:
+                        User.update(**UserData)
+                    elif userIconPath is not None and userContent is None:
+                        User.update(userIconPath=userIconPath, userIconUrl = userIconUrl)
+
+                except Exception as e:
+                    errorInfo = traceback.format_exc()
+                    print('修改设备信息错误: %s ' % errorInfo)
+                    return ResponseFormal(116, repr(e))
+                else:
+                    sqlJSON = serializers.serialize('json', User)
+                    sqlList = json.loads(sqlJSON)
+                    print(sqlList, sqlJSON)
+                    sqlDict = dict(zip(["datas"], [sqlList]))
+                    return ResponseFormal(0, sqlDict)
+            else:
+                return ResponseFormal(113)
+
+class getAvatarView(TemplateView):
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(getAvatarView, self).dispatch(*args, **kwargs)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        filePath = kwargs.get('filePath', '')
+        filePath.encode(encoding='utf-8', errors='strict')
+        return self.getAvatar(filePath)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'gb2312'
+        filePath = kwargs.get('filePath', '')
+        filePath.encode(encoding='gb2312', errors='strict')
+        return self.getAvatar(filePath)
+
+    def getAvatar(self, filePath):
+        if filePath == '' or filePath == None:
+            return ResponseJSON(800)
+        fullPath = os.path.join(api_settings.BASE_DIR, "static", filePath).replace('\\', '/')
+        if os.path.isfile(fullPath):
+            try:
+                Imagedata = open(fullPath, 'rb').read()
+                response = HttpResponse(Imagedata, content_type="image/jpeg")
+                return response
+            except Exception as e:
+                return ResponseJSON(906,repr(e))
+        else:
+            return ResponseJSON(907)
+
+def delUser(delUserID, userID):
+    try:
+        userValid = Device_User.objects.filter(userID = userID)
+    except Exception as e:
+        errorInfo = traceback.format_exc()
+        print('Query Database Error: %s' % errorInfo)
+        return ResponseFormal(500,repr(e))
+    else:
+        if userValid:
+            own_perm = ModelService.check_permission(userID=userID,permID=10)
+            if userValid[0].is_superuser == 100 or own_perm is True:
+                try:
+                    delUser = Device_User.objects.filter(userID=delUserID)
+                except Exception as e:
+                    errorInfo = traceback.format_exc()
+                    print('Query database error: %s' % errorInfo)
+                    return ResponseFormal(500,repr(e))
+                else:
+                    if delUser:
+                        try:
+                            delUser.delete()
+                        except Exception as e:
+                            errorInfo = traceback.format_exc()
+                            print('Query database error: %s' % errorInfo)
+                            return ResponseFormal(114,repr(e))
+                        else:
+                            return ResponseFormal(0)
+                    else:
+                        return ResponseFormal(115)
+            else:
+                return ResponseFormal(601)
+        else:
+            return ResponseFormal(113)
+
+@csrf_exempt
+def delUserInterface(request, *callback_args,
+                         **callback_kwargs):
+    if request.method == 'POST':
+        delUserID = request.POST.get('delUserID', None)
+        token = request.POST.get('token', None)
+    elif request.method == 'GET':
+        delUserID = request.GET.get('delUserID', None)
+        token = request.GET.get('token', None)
+    if token is not None and delUserID is not None:
+        tM = JSONTokenManager()
+        error_code = tM.verify_AToken(token)
+        if error_code == 0:
+            userID = tM.accessDict.get('userID', None)
+            if userID:
+                response = HttpResponse(delUser(delUserID, userID))
+                return response
+            else:
+                return ResponseJSON(310)
+        else:
+            response = HttpResponse(tM.errorCodeInfo(error_code))
+            return response
+    else:
+        return ResponseJSON(800)
+
+def showAllUserPC(userID,line,page):
+    try:
+        userValid = Device_User.objects.filter(userID = userID).order_by('-data_joined')
+    except Exception as e:
+        errorInfo = traceback.format_exc()
+        print('Query Database Error:%s' % errorInfo)
+        return ResponseFormal(500,repr(e))
+    else:
+        if userValid:
+            # 管理员查询
+            own_permission = ModelService.check_permission(userID=userID,permID=30)
+            if own_permission is True:
+                device_user_queryset = Device_User.objects.all()
+                device_user_count = device_user_queryset.count()
+                device_user_res = device_user_queryset.order_by('-data_joined')[(page - 1) * line:page * line]
+                sqlDict = CommonService.query_set_to_dict(device_user_res)
+                for k, v in enumerate(sqlDict["datas"]):
+                    if len(v['fields']['role']) > 0:
+                        role_query_set = Role.objects.get(rid=v['fields']['role'][0])
+                        sqlDict["datas"][k]['fields']['role'].append(role_query_set.roleName)
+                    for val in device_user_res:
+                        if v['pk'] == val.userID:
+                            if sqlDict["datas"][k]['fields']['online'] is True:
+                                dl_time = val.last_login + datetime.timedelta(minutes=30)
+                                now_time = timezone.localtime(timezone.now())
+                                if now_time > dl_time:
+                                    sqlDict["datas"][k]['fields']['online'] = False
+                sqlDict['count'] = device_user_count
+                return ResponseFormal(0,sqlDict)
+            else:
+                return ResponseFormal(600)
+        else:
+            return ResponseFormal(113)
+
+def showAllUser(userID):
+    try:
+        userValid = Device_User.objects.filter(userID = userID).order_by('-data_joined')
+    except Exception as e:
+        errorInfo = traceback.format_exc()
+        print('Query Database Error:%s' % errorInfo)
+        return ResponseFormal(500, repr(e))
+    else:
+        if userValid:
+            own_permission = ModelService.check_permission(userID=userID,permID=30)
+            if own_permission is True:
+                sqlJSON = serializers.serialize('json', Device_User.objects.all().order_by('-data_joined'))
+                sqlList = json.loads(sqlJSON)
+                print(sqlList, sqlJSON)
+                sqlDict = dict(zip(["datas"], [sqlList]))
+                return ResponseFormal(0, sqlDict)
+            else:
+                return ResponseFormal(600)
+        else:
+            return ResponseFormal(113)
+
+@csrf_exempt
+def showAllUserInterface(request, *callback_args,
+                         **callback_kwargs):
+    if request.method == 'POST':
+        token = request.POST.get('token', None)
+        type = request.POST.get('type', None)
+    elif request.method == 'GET':
+        token = request.GET.get('token', None)
+        type = request.GET.get('type', None)
+    if token != None:
+        tM = JSONTokenManager()
+        error_code = tM.verify_AToken(token)
+        if error_code == 0:
+            userID = tM.accessDict.get('userID', None)
+            if userID:
+                if type == 'PC':
+                    line = int(request.POST.get('line', None))
+                    page = int(request.POST.get('page', None))
+                    response = HttpResponse(showAllUserPC(userID, line, page))
+                else:
+                    response = HttpResponse(showAllUser(userID))
+                return response
+            else:
+                return ResponseJSON(310)
+        else:
+            response = HttpResponse(tM.errorCodeInfo(error_code))
+            return response
+    else:
+        return ResponseJSON(800)
+
+
+
+class setUserValidView(View):
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(setUserValidView, self).dispatch(*args, **kwargs)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+
+        token = request.POST.get('token', None)
+        eUserID = request.POST.get('userID', None)
+        isValid = request.POST.get('isValid', None)
+        rid = request.POST.get('rid', None)
+        return self.setUserValid(token, eUserID, isValid, rid)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'gb2312'
+
+        token = request.GET.get('token', None)
+        eUserID = request.GET.get('userID', None)
+        isValid = request.GET.get('isValid', None)
+        rid = request.GET.get('rid',None)
+
+        return self.setUserValid(token, eUserID, isValid, rid)
+
+    def setUserValid(self, token, eUserID, isValid, rid, *args, **kwargs):
+        if token != None and eUserID != None and isValid != None:
+            tM = JSONTokenManager()
+            error_code = tM.verify_AToken(token=token)
+            if error_code == 0:
+                superID = tM.accessDict.get('userID', None)
+                if superID != None and superID != eUserID:
+                    if rid == None:
+                        return HttpResponse(self.UserValidUpdate(superID, eUserID, isValid))
+                    else:
+                        return HttpResponse(self.UserValidUpdatePC(superID, eUserID, isValid, rid))
+                else:
+                    return ResponseJSON(150)
+            else:
+                response = HttpResponse(tM.errorCodeInfo(error_code))
+                return response
+        else:
+            return ResponseJSON(800)
+
+    def UserValidUpdatePC(self, superID, eUserID, isValid, rid):
+        try:
+            super = Device_User.objects.filter(userID=superID)
+            eUser = Device_User.objects.filter(userID=eUserID)
+        except Exception as e:
+            errorInfo = traceback.format_exc()
+            print('查询数据库错误: %s' % errorInfo)
+            return ResponseFormal(500,repr(e))
+        else:
+            if not super:
+                return ResponseFormal(615)
+            if not eUser:
+                return ResponseFormal(616)
+            own_permission = ModelService.check_permission(userID=superID,permID=50)
+            if own_permission is True:
+                try:
+                    eUser.update(user_isValid = isValid)
+                    device_user_query_set = Device_User.objects.get(userID=eUserID)
+                    if device_user_query_set.role.all():
+                        device_user_query_set.role.set([rid])
+                    else:
+                        role_user_query_set = Role.objects.get(rid=rid)
+                        device_user_query_set.role.add(role_user_query_set)
+                except Exception as e:
+                    errorInfo = traceback.format_exc()
+                    print('更新数据库错误:%s'%errorInfo)
+                    return ResponseFormal(501,repr(e))
+                else:
+                    return ResponseFormal(0)
+            else:
+                return ResponseFormal(602)
+
+    def UserValidUpdate(self, superID, eUserID, isValid):
+        try:
+            super = Device_User.objects.filter(userID = superID)
+            eUser = Device_User.objects.filter(userID = eUserID)
+        except Exception as e:
+            errorInfo = traceback.format_exc()
+            print('查询数据库错误: %s' % errorInfo)
+            return ResponseFormal(500,repr(e))
+        if not super:
+            return ResponseFormal(113)
+        if not eUser:
+            return ResponseFormal(113)
+        if super[0].is_superuser != 100 or super[0].is_superuser == eUser[0].is_superuser:
+            return ResponseFormal(602)
+        try:
+            updateCount = eUser.update(user_isValid = isValid)
+        except Exception as e:
+            errorInfo = traceback.format_exc()
+            print('更新数据库错误: %s' % errorInfo)
+            return ResponseFormal(501,repr(e))
+        return ResponseFormal(0)
+
+@csrf_exempt
+def success(request):
+    return ResponseJSON(0)
+
+class refreshTokenView(View):
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(refreshTokenView, self).dispatch(*args, **kwargs)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        request_dict = request.POST
+        return self.validation(request_dict=request_dict)
+
+    @csrf_exempt
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        request_dict = request.GET
+        return self.validation(request_dict=request_dict)
+
+    def validation(self, request_dict, *args, **kwargs):
+
+        refresh_token = request_dict.get('refresh_token', None)
+        if refresh_token != None:
+            tM = JSONTokenManager()
+            result = tM.refresh_AToken(refresh_token)
+            response = HttpResponse(result)
+            return response
+        else:
+            return ResponseJSON(800)

Controller/shareUserPermission.py

@@ -0,0 +1,410 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+from django.core import serializers
+import traceback, simplejson as json
+from django.shortcuts import HttpResponse
+from django.views.generic.base import View
+from django.core.exceptions import FieldError
+from django.views.decorators.csrf import csrf_exempt
+from django.utils.decorators import method_decorator
+from Service.TokenManager import JSONTokenManager
+from Model.models import Device_User, Device_Info, Role
+from Service.CommonService import CommonService
+from Service.ResponseService import *
+
+
+
+class searchUserView(View):
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(searchUserView, self).dispatch(*args, **kwargs)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        fieldDict = request.POST
+        return self.searchUser(fieldDict, args, kwargs)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'gb2312'
+        fieldDict = request.GET
+        return self.searchUser(fieldDict, args, kwargs)
+
+    def searchUserSQL(self, fieldDict, *args, **kwargs):
+        exact = fieldDict.get('exact', True)
+        if exact == '0' or exact == 'False':
+            exact = False
+        else:
+            exact = True
+
+        if 'exact' in fieldDict.keys():
+            fieldDict.pop('exact')
+
+        try:
+            if  exact == 'True' or exact == 1:
+                User = Device_User.objects.filter(**fieldDict).order_by('-data_joined')
+            elif exact == 'False' or exact == 0:
+                if 'username' in fieldDict.keys():
+                    User = Device_User.objects.filter(username = fieldDict.get('username',
+                                                                                           None)).order_by('-data_joined')
+                elif 'userEmail' in fieldDict.keys():
+                    User = Device_User.objects.filter(userEmail = fieldDict.get('userEmail',
+                                                                                           None)).order_by('-data_joined')
+                elif 'userID' in fieldDict.keys():
+                    User = Device_User.objects.filter(userID = fieldDict.get('userID',
+                                                                                           None)).order_by('-data_joined')
+                else:
+                    User = Device_User.objects.filter(**fieldDict).order_by('-data_joined')
+            else:
+                User = Device_User.objects.filter(**fieldDict).order_by('-data_joined')
+
+        except FieldError:
+            return ResponseFormal(502)
+        except Exception as e:
+            errorInfo = traceback.format_exc()
+            print('查询数据库错误: %s' % errorInfo)
+            return ResponseFormal(500,{'details':repr(e)})
+        else:
+            if User:
+                ddUser = User[0].device_info_set.all()
+                sqlJSON = serializers.serialize('json', User)
+                sqlList = json.loads(sqlJSON)
+                if ddUser:
+                    sqlJSON1 = serializers.serialize('json', ddUser)
+                    sqlList1 = json.loads(sqlJSON1)
+                    device_Info_dict={}
+                    device_Info_list=[]
+                    for eachJson1 in sqlList1:
+                        device_Info_dict['primaryUserID']=eachJson1['fields']['primaryUserID']
+                        device_Info_dict['Type']=eachJson1['fields']['Type']
+                        device_Info_dict['UID']=eachJson1['fields']['UID']
+                        device_Info_dict['pk']=eachJson1['pk']
+                        device_Info_dict['NickName']=eachJson1['fields']['NickName']
+                        device_Info_dict['View_Password']=eachJson1['fields']['View_Password']
+                        device_Info_dict['View_Account']=eachJson1['fields']['View_Account']
+                        device_Info_dict['Online']=eachJson1['fields']['Online']
+                        device_Info_dict['EventNotification']=eachJson1['fields']['EventNotification']
+                        device_Info_dict['ChannelIndex']=eachJson1['fields']['ChannelIndex']
+                        device_Info_dict['EventNotification']=eachJson1['fields']['EventNotification']
+                        device_Info_dict['NotificationMode']=eachJson1['fields']['NotificationMode']
+
+                        device_Info_list.append(device_Info_dict)
+                        device_Info_dict={}
+                    sqlList[0]['device_info'] = device_Info_list
+                sqlDict = dict(zip(["datas"], [sqlList]))
+                return ResponseFormal(0, sqlDict)
+            else:
+                # 发送邮件
+                # sms()
+                return ResponseFormal(102)
+    def searchUserPCSQL(self, fieldDict):
+        try:
+            page = int(fieldDict['page'])
+            line = int(fieldDict['line'])
+            fieldDict.pop('page')
+            fieldDict.pop('line')
+            fieldDict.pop('type')
+            if len(fieldDict) > 0:
+                searchCondition=CommonService.get_kwargs(data=fieldDict)
+                device_user_queryset = Device_User.objects.filter(**searchCondition).order_by('-data_joined')
+            else:
+                device_user_queryset = Device_User.objects.all().order_by('-data_joined')
+        except FieldError:
+            return ResponseFormal(502)
+        except Exception as e:
+            errorInfo = traceback.format_exc()
+            print('查询数据库错误: %s' % errorInfo)
+            return ResponseFormal(500, {"details": repr(e)})
+        else:
+            if device_user_queryset:
+                device_user_count = device_user_queryset.count()
+                device_user_res=device_user_queryset[(page-1)*line:page*line]
+                sqlDict = CommonService.query_set_to_dict(device_user_res)
+                for k, v in enumerate(sqlDict["datas"]):
+                    for val in device_user_res:
+                        if v['pk']==val.userID:
+                            device_info_query_set=val.device_info_set.all()
+                            device_info_list = CommonService.query_set_to_dict(device_info_query_set)
+                            # device_user关联到device_info
+                            sqlDict["datas"][k]['device_info']=device_info_list
+                    if len(v['fields']['role'])>0:
+                        role_query_set=Role.objects.get(rid=v['fields']['role'][0])
+                        sqlDict["datas"][k]['fields']['role'].append(role_query_set.roleName)
+                sqlDict['count'] = device_user_count
+                return ResponseFormal(0,sqlDict)
+            else:
+                return ResponseFormal(0,{"datas":""})
+    def searchUser(self, fieldDict, *args, **kwargs):
+        if fieldDict != None:
+            token = fieldDict.get('token', None)
+            if token != None:
+                tokenManager = JSONTokenManager()
+                error_code = tokenManager.verify_AToken(token)
+                if error_code == 0:
+                    fieldDict = fieldDict.dict()
+                    fieldDict.pop('token')
+                    type = fieldDict.get('type',None)
+                    if type == 'PC':
+                        response = HttpResponse(self.searchUserPCSQL(fieldDict))
+                    else:
+                        response = HttpResponse(self.searchUserSQL(fieldDict, args, kwargs))
+                    return response
+                else:
+                    response = HttpResponse(tokenManager.errorCodeInfo(error_code))
+                    return response
+            else:
+                return ResponseJSON(444)
+        else:
+            return ResponseJSON(444)
+
+class shareUserEquipmentView(View):
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(shareUserEquipmentView, self).dispatch(*args, **kwargs)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+
+        queryDict = request.POST
+        return self.shareUser(queryDict, args, kwargs)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'gb2312'
+
+        queryDict = request.GET
+        return self.shareUser(queryDict, args, kwargs)
+
+    def shareUser(self, queryDict, *args, **kwargs):
+        token = queryDict.get('token', None)
+        GuestID = queryDict.get('guestID', None)
+        content = queryDict.get('content', None)
+        sharedAll = queryDict.get('sharedAll', False)
+
+        if sharedAll in ('1', '0'):
+            sharedAll = bool(int(sharedAll))
+        elif sharedAll in ('true', 'false'):
+            if sharedAll == 'true':
+                sharedAll = 1
+            else:
+                sharedAll = 0
+
+        if token != None and GuestID != None:
+            tokenManager = JSONTokenManager()
+            error_code = tokenManager.verify_AToken(token)
+            if error_code == 0:
+                MasterID = tokenManager.accessDict.get('userID', None)
+                if sharedAll and MasterID != None:
+                    response = HttpResponse(self.shareUserSQL(MasterID, GuestID, True, args, kwargs))
+                    return response
+                if content != None and MasterID != None:
+                    response = HttpResponse(self.shareUserSQL(MasterID, GuestID, False, args, content=content))
+                    return response
+                else:
+                    return ResponseJSON(804)
+            else:
+                response = HttpResponse(tokenManager.errorCodeInfo(error_code))
+                return response
+        else:
+            return ResponseJSON(800)
+
+    def shareUserSQL(self, MasterID, GuestID, sharedAll, *args, **kwargs):
+        try:
+            Guest = Device_User.objects.filter(userID = GuestID).order_by('-data_joined')
+            Master = Device_Info.objects.filter(userID_id = MasterID).order_by('-data_joined')
+        except Exception as e:
+            errorInfo = traceback.format_exc()
+            print('查询数据库错误: %s' % errorInfo)
+            return ResponseFormal(500, {"details": repr(e)})
+        else:
+            if Master:
+                if Guest:
+                    querysetList = []
+                    dictLen = 0
+
+                    if sharedAll:
+                        for equipment in Master:
+                            eqDict = equipment.model_to_dict(exclude=['id', 'data_joined', 'primaryUserID'])
+
+                            shareEquipment = Device_Info.objects.filter(userID_id=GuestID, primaryUserID= \
+                                MasterID, UID=eqDict.get('UID', None)).order_by('-data_joined')
+
+                            if shareEquipment:
+                                dictLen += 1
+                                continue
+                            else:
+                                eqDict['primaryUserID'] = eqDict.pop('userID')
+                                eqDict['isShare'] = True
+                                eqDict['userID_id'] = GuestID
+                                eqDict['id'] = CommonService.getUserID(getUser=False)
+                                querysetList.append(Device_Info(**eqDict))
+                    else:
+                        content = kwargs.get('content', None)
+                        if content != None:
+                            contentDict = json.loads(content)
+                            uidlist = UID = contentDict.get('UID', None)
+                            print(uidlist)
+                            for equipment in Master:
+                                eqDict = equipment.model_to_dict(exclude=['id', 'data_joined', 'primaryUserID'])
+
+                                if eqDict['UID'] in uidlist:
+                                    UID.remove(eqDict['UID'])
+                                    shareEquipment = Device_Info.objects.filter(userID_id=GuestID, primaryUserID= \
+                                        MasterID, UID=eqDict.get('UID', None)).order_by('-data_joined')
+                                    if shareEquipment:
+                                        dictLen += 1
+                                    else:
+                                        eqDict['primaryUserID'] = eqDict.pop('userID')
+                                        eqDict['isShare'] = True
+                                        eqDict['userID_id'] = GuestID
+                                        eqDict['id'] = CommonService.getUserID(getUser=False)
+                                        querysetList.append(Device_Info(**eqDict))
+                                else:
+                                    continue
+
+                    if len(querysetList) == 0:
+                        if sharedAll:
+                            return ResponseFormal(160)
+                        else:
+                            if len(UID) > 0:
+                                return ResponseFormal(160,{'error_UID': UID})
+                            else:
+                                return ResponseFormal(160)
+                    else:
+                        try:
+                            equipmentCount = Device_Info.objects.bulk_create(querysetList)
+                        except Exception as e:
+                            errorInfo = traceback.format_exc()
+                            print('添加数据库记录错误: %s' % errorInfo)
+                            return ResponseFormal(500, {"details": repr(e)})
+                        else:
+                            if dictLen > 0:
+                                return ResponseFormal(0, {
+                                            'Shared': dictLen,
+                                            'Sharing': len(querysetList),
+                                            'errormsg': u'A part of the equipment has been shared!',
+                                        })
+                            else:
+                                if sharedAll:
+                                    return ResponseFormal(0, {
+                                        'Sharing': len(querysetList)
+                                    })
+                                else:
+                                    if len(UID) > 0:
+                                        return ResponseFormal(0, {
+                                            'error_UID': UID,
+                                            'Sharing': len(querysetList),
+                                        })
+                                    else:
+                                        return ResponseFormal(0, {
+                                            'Sharing': len(querysetList),
+                                        })
+                else:
+                    return ResponseFormal(113)
+
+            else:
+                return ResponseFormal(172)
+
+class unsharedUserEquipmentView(View):
+    @method_decorator(csrf_exempt)
+    def dispatch(self, *args, **kwargs):
+        return super(unsharedUserEquipmentView, self).dispatch(*args, **kwargs)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+
+        queryset = request.POST
+        return self.unsharedUserEquipment(queryset, args, kwargs)
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'gb2312'
+
+        queryset = request.GET
+        return self.unsharedUserEquipment(queryset, args, kwargs)
+
+    def unsharedUserEquipment(self, queryset, *args, **kwargs):
+        token = queryset.get('token', None)
+        GuestID = queryset.get('guestID', None)
+        content = queryset.get('content', None)
+        unsharedAll = queryset.get('unsharedAll', False)
+
+        if unsharedAll in ('1', '0'):
+            unsharedAll = bool(int(unsharedAll))
+        elif unsharedAll in ('true', 'false'):
+            if unsharedAll == 'true':
+                unsharedAll = 1
+            else:
+                unsharedAll = 0
+
+        if token != None and GuestID != None and len(GuestID) > 0:
+            tokenManager = JSONTokenManager()
+            error_code = tokenManager.verify_AToken(token)
+            if error_code == 0:
+                MasterID = tokenManager.accessDict.get('userID', None)
+                if unsharedAll and MasterID != None:
+                    response = HttpResponse(self.unsharedUserEquipmentSQL(MasterID, GuestID, True, args, kwargs))
+                    return response
+                else:
+                    if content != None and MasterID != None:
+                        response = HttpResponse(self.unsharedUserEquipmentSQL(MasterID, GuestID, False, args, content=content))
+                        return response
+                    else:
+                        return ResponseJSON(805)
+
+            else:
+                response = HttpResponse(tokenManager.errorCodeInfo(error_code))
+                return response
+        else:
+            return ResponseJSON(800)
+
+    def unsharedUserEquipmentSQL(self, MasterID, GuestID, unsharedAll, *args, **kwargs):
+        if unsharedAll:
+            try:
+                equipmentCount = Device_Info.objects.filter(userID_id=GuestID, primaryUserID=MasterID).delete()
+            except Exception as e:
+                errorInfo = traceback.format_exc()
+                print('删除设备更新数据库错误: %s' % errorInfo)
+                return ResponseFormal(171, {"details": repr(e)})
+            else:
+                return ResponseFormal(0, {'removeCount': equipmentCount[0]})
+        else:
+            content = kwargs.get('content', None)
+            if content != None:
+                removeCount = 0
+                errorRemove = []
+                errorUID = []
+
+                contentDict = json.loads(content)
+                uidlist = contentDict.get('UID', None)
+
+                for index in range(len(uidlist)):
+                    uid = uidlist[index]
+                    try:
+                        equipment = Device_Info.objects.filter(userID_id=GuestID, primaryUserID=MasterID, UID=uid)
+                        if equipment:
+                            equipmentCount = equipment.delete()
+                        else:
+                            errorUID.append(uid)
+                            continue
+                    except Exception as e:
+                        errorInfo = traceback.format_exc()
+                        print('查询数据库错误: %s' % errorInfo)
+
+                        errorRemove.append(uid)
+                        continue
+                    else:
+                        removeCount += equipmentCount[0]
+
+                if len(errorRemove) > 0:
+                    return ResponseFormal(171, {
+                                'removeCount': removeCount,
+                                'error_UID': errorRemove,
+                            })
+                else:
+                    if len(errorUID) >0:
+                        return ResponseFormal(173, {
+                            'removeCount': removeCount,
+                            'error_UID': errorUID,
+                        })
+                    else:
+                        return ResponseFormal(0, {
+                                     'removeCount': removeCount
+                        })

DB/data.json

@@ -0,0 +1,17 @@
+{
+  "token": "",
+  "content": {
+    "View_Account": "admin",
+    "UID": "9M23R17PHD8TJDT8111A",
+    "NotificationMode": 1,
+    "EventNotification": 0,
+    "DebugMode": 0,
+    "NickName": "\ud83c\udf3a",
+    "qvgaLevel": 0,
+    "mMonitorIndex": 0,
+    "View_Password": "541034aaa",
+    "Online": 0,
+    "Type": 10,
+    "ChannelIndex": 0
+  }
+}

DB/data.sql

@@ -0,0 +1,2 @@
+alter table device_user add language varchar(16) NULL;
+ALTER TABLE device_info MODIFY COLUMN NickName varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci

Model/admin.py

@@ -0,0 +1,5 @@
+from django.contrib import admin
+from Model.models import Device_User,Device_Info
+# Register your models here.
+
+admin.site.register([Device_User, Device_Info])

Model/apps.py

@@ -0,0 +1,4 @@
+from django.apps import AppConfig
+
+class UsermanagerConfig(AppConfig):
+    name = 'Model'

Model/models.py

@@ -0,0 +1,609 @@
+from django.db import models
+from django.utils import six
+from imagekit.processors import ResizeToFill
+from imagekit.models import ProcessedImageField
+import Ansjer.settings as api_settings
+from django.utils.encoding import python_2_unicode_compatible
+from django.contrib.auth.models import BaseUserManager, AbstractBaseUser
+from Service.CommonService import CommonService
+
+class PermissionsManager(models.Manager):
+    use_in_migrations = True
+
+    def get_by_natural_key(self, permName):
+        return self.get(
+            permName = permName
+        )
+
+class RoleManager(models.Manager):
+    """
+    The manager for the auth's Role model.
+    """
+    use_in_migrations = True
+
+    def get_by_natural_key(self, roleName):
+        return self.get(roleName = roleName)
+
+class UserManager(BaseUserManager):
+
+    def create_user(self, username, password, userID, is_active,
+                    user_isValid, **extra_fields):
+
+        user = self.model(
+            username = username,
+            userID = userID,
+            is_active = is_active,
+            user_isValid = user_isValid,
+            **extra_fields
+        )
+        user.set_password(password)
+        user.save(using=self._db)
+
+        role = Role.objects.get(rid = 1)
+        user.role.add(role)
+        return user
+
+    def create_superuser(self, username, password, userID, is_active,
+                         user_isValid , **extra_fields):
+        #extra_fields.setdefault('is_superuser', is_superuser)
+        is_superuser = extra_fields.get('is_superuser', None)
+        if is_superuser != 100 and is_superuser != 1:
+            raise ValueError('Superuser must have is_superuser=1 or 100.')
+
+        return self.create_user(username, password, userID, is_active,
+                                user_isValid, **extra_fields)
+
+@python_2_unicode_compatible
+class Permissions(models.Model):
+    permName = models.CharField(blank=True, null=True, max_length=32, unique=True, verbose_name=u'权限名称')
+    description = models.CharField(blank=True, null=True, max_length=128, verbose_name=u'描述信息', default='')
+    objects = PermissionsManager()
+    def __str__(self):
+        return "%s" % (
+            six.text_type(self.description))
+    class Meta:
+        ordering = ['permName']
+        db_table = 'permissions'
+        verbose_name = u'role permission'
+        verbose_name_plural = verbose_name
+        unique_together = (('permName'),)
+
+    def natural_key(self):
+        return (self.permName)
+
+class Role(models.Model):
+    ROLE_TYPES = (
+        ('Guests', u'Guests'),
+        ('Users', u'Users'),
+        ('Admins', u'Admins'),
+        ('SysAdmins', u'SysAdmins'),
+        ('LOGAdmins', u'LOGAdmins'),
+        ('OTAAdmins', u'OTAAdmins'),
+        ('DBAAdmins', u'DBAAdmins'),
+        ('SuperAdmins', u'SuperAdmins'),
+    )
+    rid = models.SmallIntegerField(primary_key=True, unique=True, verbose_name=u'用户角色组ID')
+    roleName = models.CharField(max_length=32, choices=ROLE_TYPES, unique=True,
+                                default='User', verbose_name=u'角色名称')
+    permission = models.ManyToManyField(to='Permissions', blank=True, verbose_name=u'权限', db_table='role_permissions')
+    Description = models.TextField(blank=True, default='', verbose_name=u'描述信息')
+
+    objects = RoleManager()
+
+    class Meta:
+        ordering = ['roleName']
+        db_table = 'role'
+        verbose_name = u'用户角色'
+        verbose_name_plural = verbose_name
+
+    def __str__(self):
+        return self.roleName
+
+    def natural_key(self):
+        return (self.roleName,)
+
+    def has_perm(self, permission, obj=None):
+        if self.rid == 100:
+            return True
+
+        permlist = self.permission.all()
+        for perm in permlist:
+            if perm.permName == permission:
+                return True
+
+        return False
+
+    def get_all_perms_id(self):
+        perms = self.permission.all()
+        permslist = []
+        if self.rid == 100:
+            perms = Permissions.objects.all()
+            for perm in perms:
+                permslist.append(perm.id)
+            return permslist
+        else:
+            permlist_tmp = []
+            for perm in perms:
+                permlist_tmp.append(perm.id)
+            permSet = set(permlist_tmp)
+            permslist = list(permSet)
+            permslist.sort()
+            return permslist
+
+    def get_all_permission(self):
+        perms = self.permission.all()
+
+        permslist = []
+        if self.rid == 100:
+            perms = Permissions.objects.all()
+            for perm in perms:
+                permslist.append(perm.permName)
+            return permslist
+        else:
+            permlist_tmp = []
+            for perm in perms:
+                permlist_tmp.append(perm.permName)
+            permSet = set(permlist_tmp)
+            permslist = list(permSet)
+            permslist.sort()
+            return permslist
+
+class Device_User(AbstractBaseUser):
+    userID = models.CharField(blank=True, max_length=32, primary_key=True,
+                              verbose_name=u'用户ID', unique=True, default=CommonService.getUserID(getUser=True))
+    role = models.ManyToManyField(to='Role', blank=True, verbose_name=u'用户角色', db_table='user_role')
+
+    username = models.CharField(max_length=40, verbose_name=u'用户名', unique = True)
+    password = models.CharField(max_length=128, verbose_name=u'密码')
+    userEmail = models.EmailField(max_length = 64, verbose_name=u'邮箱', unique = True, default='AnonymousUser@qq.com')
+    # 实际的路径就是 MEDIA_ROOT/Image/filename,所以可用upload_to来指定文件存放的前缀路径
+    userIconPath = ProcessedImageField(blank=True, upload_to='User/Images/', default='static/User/default.png',
+                        verbose_name=u'头像',
+                        # 图片将处理成85x85的尺寸
+                        processors=[ResizeToFill(85, 85)],)
+    userIconUrl = models.URLField(blank = True, max_length = 128, default=api_settings.SERVER_DOMAIN
+                                                                          + '/account/getAvatar/User/defaultUser.png')
+    NickName = models.CharField(blank=True, max_length=32, default='', verbose_name=u'用户昵称')
+    is_superuser = models.IntegerField(blank=True, default=0, verbose_name=u'用户类型')
+    is_active = models.BooleanField(blank=True, default=False, verbose_name=u'用户活动状态')
+    data_joined = models.DateTimeField(blank=True, verbose_name=u'加入时间', auto_now_add=True)
+    last_login = models.DateTimeField(blank=True, verbose_name='u最后登录时间', auto_now=True)
+    user_isValid = models.BooleanField(blank=True, default=False, verbose_name=u'用户有效性', help_text=u'是否是认证通过的用户')
+    online = models.BooleanField(blank=True, default=False, verbose_name=u'用户登录状态')
+    machine_code = models.CharField(blank=True, max_length=128, default='', verbose_name=u'机械码')
+
+    language = models.CharField(blank=True, null=True, max_length=16, default='', verbose_name=u'语言地区')
+
+    objects = UserManager()
+
+    USERNAME_FIELD = 'username' # 必须有一个唯一标识
+    REQUIRED_FIELDS = ['userID', 'is_superuser'] # 创建superuser时的必须字段
+
+    class Meta:
+        ordering = ('-data_joined', )
+        verbose_name = u'用户信息'
+        db_table = 'device_user'
+        get_latest_by = 'last_login'
+
+    def __str__(self):
+        return self.username
+
+    def get_full_name(self):
+        return self.userEmail
+
+    def get_short_name(self):
+        return self.username
+
+    def get_role_id(self):
+        rids = []
+        roles = self.role.all()
+        for role in roles:
+            rids.append(role.rid)
+        return rids
+
+    def has_perm(self, permission, obj=None):
+        roles = self.role.all()
+        for role in roles:
+            if role.rid == 100:
+                return True
+
+        permlist = self.permission.all()
+        for perm in permlist:
+            if perm.permName == permission:
+                return True
+
+        for role in roles:
+            permlist = role.permission.all()
+            for perm in permlist:
+                if perm.permName == permission:
+                    return True
+
+        return False
+
+    def get_all_perms_id(self):
+        roles = self.role.all()
+        perms = self.permission.all()
+
+        permslist = []
+        for role in roles:
+            if role.rid == 100:
+                perms = Permissions.objects.all()
+                for perm in perms:
+                    permslist.append(perm.id)
+                return permslist
+
+        for perm in perms:
+            permslist.append(perm.id)
+
+        permSet = set(permslist)
+        for role in roles:
+            permlist_tmp = []
+            for perm in role.permission.all():
+                permlist_tmp.append(perm.id)
+
+            permSet_tmp = set(permlist_tmp)
+            permSet = permSet.union(permSet_tmp)
+            permslist = list(permSet)
+            permslist.sort()
+            return permslist
+
+    def get_all_permission(self):
+        roles = self.role.all()
+        perms = self.permission.all()
+
+        permslist = []
+        for role in roles:
+            if role.rid == 100:
+                perms = Permissions.objects.all()
+                for perm in perms:
+                    permslist.append(perm.permName)
+                return permslist
+
+        for perm in perms:
+            permslist.append(perm.permName)
+
+        permSet = set(permslist)
+        for role in roles:
+            permlist_tmp = []
+            for perm in role.permission.all():
+                permlist_tmp.append(perm.permName)
+
+            permSet_tmp = set(permlist_tmp)
+            permSet = permSet.union(permSet_tmp)
+            permslist = list(permSet)
+            permslist.sort()
+            return permslist
+    '''
+    def has_module_perms(self, app_label):
+        return True
+    def toJSON(self, fields=None, exclude=None):
+        Fields = []
+        for field in self._meta.fields:
+            Fields.append(field.name)
+
+        data = {}
+        for attr in Fields:
+            if fields and attr not in fields:
+                continue
+            if exclude and attr in exclude:
+                continue
+
+            if isinstance(getattr(self, attr), datetime.datetime):
+                data[attr] = getattr(self, attr).strftime('%Y-%m-%d %H:%M:%S')
+            elif isinstance(getattr(self, attr), datetime.date):
+                data[attr] = getattr(self, attr).strftime('%Y-%m-%d')
+            elif isinstance(getattr(self, attr), ProcessedImageFieldFile):
+                data[attr] = str(getattr(self, attr))
+            else:
+                data[attr] = getattr(self, attr)
+
+        import simplejson as json
+        return json.dumps(data, ensure_ascii=False)
+    '''
+    @property
+    def is_staff(self):
+        return self.is_superuser
+
+class Device_Info(models.Model):
+    id = models.CharField(blank=True, max_length=32, primary_key=True)
+    # to_field 指定当前关系与被关联对象中的哪个字段关联。默认情况下，to_field 指向被关联对象的主键
+    userID = models.ForeignKey(Device_User, blank=True, to_field='userID',
+                                   on_delete=models.CASCADE)
+
+    NickName = models.CharField(blank=True, max_length=32, verbose_name=u'设备名称')
+    UID = models.CharField(blank=True, max_length=32, verbose_name=u'设备UID')
+    SID = models.CharField(blank=True, max_length=32, verbose_name=u'服务器ID')
+    View_Account = models.CharField(blank=True, max_length=32, verbose_name=u'设备用户名称')
+    View_Password = models.CharField(blank=True, max_length=32, verbose_name=u'设备密码')
+    AudioFormat = models.IntegerField(blank=True, default=1, verbose_name=u'初始化影像')
+    EventNotification = models.IntegerField(blank=True, verbose_name=u'报警类型')
+    ChannelIndex = models.IntegerField(blank=True, verbose_name=u'通道号')
+    Online = models.BooleanField(blank=True, default=False, verbose_name=u'设备是否在线')
+    mMonitorIndex = models.IntegerField(blank=True, default=-1)
+    Type = models.IntegerField(blank=True)
+    DebugMode = models.IntegerField(blank=True, verbose_name=u'调试模式')
+    NotificationMode = models.IntegerField(blank=True, verbose_name=u'是否报警')
+    qvgaLevel = models.BooleanField(blank=True, verbose_name=u'SD与HD画面', default=0,
+                                    help_text=u'0代表：SD、1代表：HD')
+    isShare = models.BooleanField(blank=True, verbose_name=u'共享设备',
+                                  help_text=u'是否为共享获取的设备', default=False)
+    primaryUserID = models.CharField(blank=True, verbose_name='主用户',
+                                     help_text=u'该设备的主用户', max_length=32, default='')
+    data_joined = models.DateTimeField(blank=True, verbose_name=u'设备添加时间', auto_now_add=True)
+    update_time = models.DateTimeField(blank=True, verbose_name=u'更新时间', auto_now=True,null=True)
+
+    ip = models.CharField(blank=True, max_length=100, null=True, verbose_name=u'设备区域ip')
+    area = models.CharField(blank=True, max_length=100, null=True, verbose_name=u'设备区域area')
+
+    REQUIRED_FIELDS = []
+
+    def __str__(self):
+        return self.NickName
+    '''
+    def toJSON(self, fields=None, exclude=None):
+        Fields = []
+        for field in self._meta.fields:
+            Fields.append(field.name)
+
+        data = {}
+        for attr in Fields:
+            if fields and attr not in fields:
+                continue
+            if exclude and attr in exclude:
+                continue
+
+            if isinstance(getattr(self, attr), datetime.datetime):
+                data[attr] = getattr(self, attr).strftime('%Y-%m-%d %H:%M:%S')
+            elif isinstance(getattr(self, attr), datetime.date):
+                data[attr] = getattr(self, attr).strftime('%Y-%m-%d')
+            elif isinstance(getattr(self, attr), Device_User):
+                data[attr] = getattr(self, attr).userID
+            else:
+                data[attr] = getattr(self, attr)
+
+        import simplejson as json
+        return json.dumps(data,ensure_ascii=False)
+    def model_to_dict(self, fields=None, exclude=None):
+        opts = self._meta
+        data = {}
+        for f in chain(opts.concrete_fields, opts.private_fields, opts.many_to_many):
+            if not getattr(f, 'editable', False):
+                continue
+            if fields and f.name not in fields:
+                continue
+            if exclude and f.name in exclude:
+                continue
+            data[f.name] = f.value_from_object(self)
+        return data
+    '''
+    class Meta:
+        db_table = 'device_info'
+        ordering = ('-data_joined',)
+        verbose_name = u'用户设备信息表'
+        verbose_name_plural=verbose_name
+
+class AuthToken_Token(models.Model):
+    tokenID = models.OneToOneField(Device_User, blank=True,on_delete=models.CASCADE,
+                                   primary_key=True) #定义一对一关系
+    access_token = models.CharField(blank=True, max_length=256)
+    refresh_token = models.CharField(blank=True, max_length=256)
+    last_update = models.DateTimeField(blank=True, auto_now=True)
+    iCode = models.CharField(blank=True, max_length=12, verbose_name=u'干扰码')
+    mCode = models.CharField(blank=True, max_length=64, verbose_name=u'设备码')
+    class Meta:
+        verbose_name = u'用户Token'
+        db_table = 'authtoken_token'
+        ordering = ('-last_update', )
+
+class AuthToken_JWT(models.Model):
+    jwtID = models.OneToOneField(Device_User, blank=True, on_delete=models.CASCADE,
+                                 primary_key=True, verbose_name=u'token userID')
+    access_token = models.CharField(blank=True, max_length=384, verbose_name=u'Access Token')
+    refresh_token = models.CharField(blank=True, max_length=384, verbose_name=u'Refresh Token')
+    secret = models.CharField(blank=True, max_length=32, verbose_name=u'Secret')
+    last_update = models.DateTimeField(blank=True, auto_now=True, verbose_name=u'Last Update')
+
+    class Meta:
+        verbose_name = u'用户JWT'
+        verbose_name_plural = verbose_name
+        db_table = 'authtoken_jwt'
+        ordering = ('-last_update', )
+
+class Email_Captcha(models.Model):
+    userCaptcha = models.CharField(max_length=10, verbose_name=u'验证码')
+    userEmail = models.EmailField(max_length=50, verbose_name=u'邮箱')
+    sendType = models.CharField(choices=(("register",u"注册"),("forget",u"找回密码")), max_length=15)
+    sendTime = models.DateField(auto_now_add=True)
+
+    class Meta:
+        db_table = 'email_captcha'
+        ordering = ('-sendTime',)
+
+        verbose_name = u'邮箱验证码'
+        verbose_name_plural=verbose_name
+
+class Auth_Captcha(models.Model):
+    username = models.CharField(max_length=50, help_text=u'用户名(邮箱或电话号码)')
+    authcaptca = models.CharField(max_length=6, help_text=u'验证码')
+    sendtype = models.CharField(max_length=15, choices=(("register",u"注册"),("forget",u"找回密码")))
+    sendtime = models.DateTimeField(auto_now_add=True)
+
+    class Meta:
+        db_table = 'auth_captcha'
+        ordering = ('-sendtime',)
+
+        verbose_name = u'邮箱验证码'
+        verbose_name_plural=verbose_name
+
+class Access_Log(models.Model):
+    id = models.AutoField(primary_key=True,verbose_name=u'自增标记ID')
+    user = models.CharField(max_length=100,null=True,blank=True,verbose_name=u'用户')
+    operation = models.CharField(max_length=100,null=True,blank=True,verbose_name=u'操作')
+    ip = models.CharField(max_length=100,null=True,blank=True,verbose_name=u'访问ip地址')
+    url = models.CharField(max_length=150,null=True,blank=True,verbose_name=u'访问路径')
+    status = models.IntegerField(null=True,blank=True,verbose_name=u'状态')
+    time = models.DateTimeField(null=True,blank=True, db_index=True,verbose_name=u'访问时间')
+    content = models.TextField(blank=True,null=True, verbose_name=u'参数内容')
+    class Meta:
+        db_table = 'access_log'
+        verbose_name = u'访问日志表'
+        verbose_name_plural=verbose_name
+
+class Equipment_Stream(models.Model):
+    id = models.AutoField(primary_key=True,verbose_name=u'自增标记ID')
+    userID = models.CharField(blank=True, max_length=32,verbose_name=u'用户ID')
+    status = models.IntegerField(null=True, blank=True, verbose_name=u'状态')
+    uid = models.CharField(null=True, blank=True,max_length=32, verbose_name=u'设备ID')
+    channel = models.IntegerField(null=True, blank=True, verbose_name=u'设备通道')
+    access_token = models.CharField(blank=True, max_length=128,verbose_name=u'设备推流验证令牌')
+    total_flow = models.FloatField(null=True, blank=True, verbose_name=u'传输总容量')
+    add_time = models.DateTimeField(blank=True, null=True,verbose_name=u'加入时间', auto_now_add=True)
+    update_time = models.DateTimeField(blank=True, verbose_name=u'更新时间', auto_now=True)
+    rank = models.IntegerField(null=True, blank=True, verbose_name=u'推流套餐类型')
+
+    class Meta:
+        db_table = 'equipment_stream'
+        verbose_name = u'用户设备推流表'
+        verbose_name_plural=verbose_name
+
+class Equipment_Sensor(models.Model):
+    id = models.AutoField(primary_key=True,verbose_name=u'自增标记ID')
+    status = models.IntegerField(null=True, blank=True, verbose_name=u'状态')
+    type = models.IntegerField(null=True, blank=True, verbose_name=u'类型')
+    name = models.CharField(null=True, blank=True,max_length=128, verbose_name=u'传感器名称')
+    add_time = models.DateTimeField(blank=True,null=True, verbose_name=u'加入时间', auto_now_add=True)
+    update_time = models.DateTimeField(blank=True, verbose_name=u'更新时间', auto_now=True)
+    uid = models.CharField(null=True, blank=True,max_length=32, verbose_name=u'设备ID')
+
+    def __str__(self):
+        return self.id
+
+    class Meta:
+        db_table = 'equipment_sensor'
+        verbose_name = u'设备传感器表'
+        verbose_name_plural=verbose_name
+        ordering = ('id',)
+
+class Equipment_Info(models.Model):
+    id = models.AutoField(primary_key=True,verbose_name=u'自增标记ID')
+    devUid = models.CharField(null=True, blank=True,max_length=32, verbose_name=u'设备ID')
+    devNickName = models.CharField(blank=True, max_length=32, default='', verbose_name=u'设备昵称')
+    Channel = models.IntegerField(null=True, blank=True, verbose_name=u'设备通道')
+    eventType = models.IntegerField(null=True, blank=True, verbose_name=u'事件类型')
+    viewAccont = models.CharField(blank=True,null=True, max_length=32, verbose_name=u'设备账户')
+    viewPwd = models.CharField(blank=True, null=True,max_length=32, verbose_name=u'设备密码')
+    status = models.BooleanField(blank=True, default=False, verbose_name=u'事件状态')
+    alarm = models.CharField(blank=True, max_length=256, verbose_name=u'报警信息')
+    eventTime = models.CharField(blank=True,null=True, max_length=16, verbose_name=u'设备报警时间')
+    receiveTime = models.CharField(blank=True,null=True, max_length=16, verbose_name=u'接收到报警时间')
+
+    def __str__(self):
+        return self.id
+
+    class Meta:
+        db_table = 'equipment_info'
+        verbose_name = u'设备信息推送表'
+        verbose_name_plural=verbose_name
+        ordering = ('id',)
+
+class Feedback_Info(models.Model):
+    id = models.AutoField(primary_key=True,verbose_name=u'自增标记ID')
+    userID = models.CharField(blank=True, max_length=32, verbose_name=u'用户ID')
+    status = models.BooleanField(blank=True, default=False, verbose_name=u'状态:0未解决/解决')
+    content = models.TextField(blank=True,null=True, verbose_name=u'反馈描述')
+    add_time = models.DateTimeField(blank=True, null=True, verbose_name=u'加入时间/反馈时间', auto_now_add=True)
+    update_time = models.DateTimeField(blank=True, verbose_name=u'更新时间', auto_now=True)
+
+    def __str__(self):
+        return self.id
+
+    class Meta:
+        db_table = 'feedback_info'
+        verbose_name = u'用户反馈信息表'
+        verbose_name_plural=verbose_name
+        ordering = ('id',)
+
+
+class Store_Meal(models.Model):
+    id = models.AutoField(primary_key=True,verbose_name=u'自增ID')
+    title = models.CharField(blank=True, max_length=32, verbose_name=u'标题')
+    price = models.CharField(blank=True, max_length=32, verbose_name=u'价格')
+    day = models.IntegerField(null=True, blank=True, verbose_name=u'存储时间')
+    content = models.TextField(blank=True,null=True, verbose_name=u'描述')
+    add_time = models.DateTimeField(blank=True,null=True, verbose_name=u'加入时间', auto_now_add=True)
+    update_time = models.DateTimeField(blank=True, verbose_name=u'更新时间', auto_now=True)
+
+    def __str__(self):
+        return self.id
+
+    class Meta:
+        db_table = 'store_meal'
+        verbose_name = u'存储套餐'
+        verbose_name_plural=verbose_name
+        ordering = ('id',)
+
+
+class Device_Meal(models.Model):
+    id = models.AutoField(primary_key=True,verbose_name=u'自增标记ID')
+    status = models.IntegerField(null=True, blank=True, verbose_name=u'状态')
+    uid = models.CharField(null=True, blank=True,max_length=32,verbose_name=u'设备ID')
+    channel = models.IntegerField(null=True, blank=True, verbose_name=u'设备通道')
+    add_time = models.DateTimeField(blank=True, null=True,verbose_name=u'加入时间', auto_now_add=True)
+    update_time = models.DateTimeField(blank=True, verbose_name=u'更新时间', auto_now=True)
+    end_time = models.DateTimeField(blank=True, verbose_name=u'最后时间')
+    rank = models.ForeignKey(Store_Meal, blank=True, to_field='id',
+                               on_delete=models.CASCADE,verbose_name='套餐类型')
+
+    class Meta:
+        db_table = 'device_meal'
+        verbose_name = u'设备关联套餐表'
+        verbose_name_plural=verbose_name
+        ordering = ('id',)
+
+    def __str__(self):
+        return self.id
+
+class Equipment_Version(models.Model):
+    eid = models.CharField(blank=True, max_length=32, primary_key=True)
+    ESN = models.CharField(blank=True, max_length=32, verbose_name=u'设备规格名称')
+    code = models.CharField(blank=True, max_length=32, verbose_name=u'设备规格代码')
+    version = models.CharField(blank=True, max_length=32, verbose_name=u'设备版本')
+    softwareVersion = models.CharField(blank=True, max_length=32, verbose_name=u'软件本版本')
+    chipModelList2Code = models.CharField(max_length=32,blank=True, verbose_name=u'主芯片码')
+    channel = models.IntegerField(blank=True, verbose_name=u'通道数')
+    resolutionRatio = models.IntegerField(blank=True, verbose_name=u'分辨率')
+    type = models.CharField(blank=True, max_length=16, verbose_name=u'设备机型')
+    companyCode = models.CharField(blank=True, max_length=128, verbose_name=u'用户公司名称')
+    data_joined = models.DateTimeField(blank=True, verbose_name=u'加入时间', auto_now_add=True)
+    fileSize = models.IntegerField(blank=True, verbose_name=u'文件总大小')
+    filePath = models.CharField(blank=True, max_length=256, verbose_name=u'升级文件路径')
+    Description = models.TextField(blank=True, default='', verbose_name=u'描述信息')
+    fileMd5 = models.CharField(blank=True,max_length=32,null=True,verbose_name=u'上传文件MD5加密')
+    status = models.BooleanField(blank=True, default=True, verbose_name=u'是否开启更新状态')
+    update_time = models.DateTimeField(blank=True, verbose_name=u'更新时间', auto_now=True)
+    class Meta:
+        verbose_name = '设备版本信息'
+        ordering = ('-data_joined',)
+        db_table = 'equipment_version'
+
+
+class App_Info(models.Model):
+    id = models.AutoField(primary_key=True,verbose_name=u'自增标记ID')
+    appBundleId = models.CharField(blank=True, max_length=32, verbose_name=u'appID')
+    appName = models.CharField(blank=True, max_length=32, verbose_name=u'app名称')
+    systemLanguage = models.CharField(blank=True, max_length=32, verbose_name=u'系统语言')
+    newAppversion = models.CharField(blank=True, max_length=12, verbose_name=u'系统版本')
+    bundleVersion = models.CharField(blank=True, max_length=12, verbose_name=u'项目版本')
+    content = models.TextField(blank=True,null=True, verbose_name=u'更新内容')
+    app_type = models.IntegerField(null=True, blank=True, verbose_name=u'app类型')
+    add_time = models.DateTimeField(blank=True,null=True, verbose_name=u'加入时间', auto_now_add=True)
+    update_time = models.DateTimeField(blank=True, verbose_name=u'更新时间', auto_now=True)
+
+    def __str__(self):
+        return self.id
+
+    class Meta:
+        db_table = 'app_info'
+        verbose_name = u'app信息表'
+        verbose_name_plural=verbose_name
+        ordering = ('id',)

Object/AWS/CloudfrontSignCookie.py

@@ -0,0 +1,105 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-  
+"""
+@Copyright (C) ansjer cop Video Technology Co.,Ltd.All rights reserved.
+@AUTHOR: ASJRD018
+@NAME: Ansjer
+@software: PyCharm
+@DATE: 2018/5/23 16:03
+@Version: python3.6
+@MODIFY DECORD:ansjer dev
+@file: CloudfrontSignCookie.py
+@Contact: chanjunkai@163.com
+"""
+from boto.cloudfront.distribution import Distribution
+from cryptography.hazmat.primitives.asymmetric import padding
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.backends import default_backend
+from cryptography.hazmat.primitives import hashes
+import base64
+import datetime
+from var_dump import var_dump
+import time
+
+
+class BetterThanBoto(Distribution):
+
+    def sign_rsa(self, message):
+        private_key = serialization.load_pem_private_key(self.keyfile, password=None,
+                                                         backend=default_backend())
+        signer = private_key.signer(padding.PKCS1v15(), hashes.SHA1())
+        message = message.encode('utf-8')
+        signer.update(message)
+        return signer.finalize()
+
+    def _sign_string(self, message, private_key_file=None, private_key_string=None):
+        if private_key_file:
+            self.keyfile = open(private_key_file, 'rb').read()
+        elif private_key_string:
+            self.keyfile = private_key_string.encode('utf-8')
+        return self.sign_rsa(message)
+
+    @staticmethod
+    def _url_base64_encode(msg):
+        """
+        Base64 encodes a string using the URL-safe characters specified by
+        Amazon.
+        """
+        msg_base64 = base64.b64encode(msg).decode('utf-8')
+        msg_base64 = msg_base64.replace('+', '-')
+        msg_base64 = msg_base64.replace('=', '_')
+        msg_base64 = msg_base64.replace('/', '~')
+        return msg_base64
+
+    def generate_signature(self, policy, private_key_file=None):
+        """
+        :param policy: no-whitespace json str (NOT encoded yet)
+        :param private_key_file: your .pem file with which to sign the policy
+        :return: encoded signature for use in cookie
+        """
+        # Distribution._create_signing_params()
+        signature = self._sign_string(policy, private_key_file)
+
+        # now base64 encode the signature & make URL safe
+        encoded_signature = self._url_base64_encode(signature)
+
+        return encoded_signature
+
+    def create_signed_cookies(self, url, private_key_file=None, keypair_id=None,
+                              expires_at=20, secure=True):
+        policy = self._custom_policy(
+            url,
+            expires_at
+        )
+
+        encoded_policy = self._url_base64_encode(policy.encode('utf-8'))
+        signature = self.generate_signature(
+            policy, private_key_file=private_key_file
+        )
+        cookies = {
+            "CloudFront-Policy": encoded_policy,
+            "CloudFront-Signature": signature,
+            "CloudFront-Key-Pair-Id": keypair_id
+        }
+        return cookies
+
+
+def sign_to_cloudfront(object_url, expires_at):
+    """ Sign URL to distribute file"""
+    cf = BetterThanBoto()
+    url = cf.create_signed_url(url=object_url,
+                               keypair_id="APKAINI6BNPKV54NHH7Q",
+                               expire_time=expires_at,
+                               private_key_file="D:/project_svn/Ansjer/test/pk-APKAINI6BNPKV54NHH7Q.pem")
+
+    return url
+
+
+def create_signed_cookies(object_url, expires_at):
+    """
+    Create a signed cookie
+    """
+    cf = BetterThanBoto()
+
+    cookies = cf.create_signed_cookies(url=object_url,keypair_id = "APKAINI6BNPKV54NHH7Q",expires_at = expires_at,private_key_file = "D:/project_svn/Ansjer/test/pk-APKAINI6BNPKV54NHH7Q.pem")
+    return cookies

Object/AWS/CloudfrontSignUrl.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3  
+# -*- coding: utf-8 -*-  
+"""
+@Copyright (C) ansjer cop Video Technology Co.,Ltd.All rights reserved.
+@AUTHOR: ASJRD018
+@NAME: Ansjer
+@software: PyCharm
+@DATE: 2018/5/31 11:19
+@Version: python3.6
+@MODIFY DECORD:ansjer dev
+@file: CloudfrontSignUrl.py
+@Contact: chanjunkai@163.com
+"""
+from Ansjer.config import *
+import datetime
+from cryptography.hazmat.backends import default_backend
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import padding
+from botocore.signers import CloudFrontSigner
+
+
+def rsa_signer(message):
+    with open(os.path.join(BASE_DIR,'Ansjer/file/pk-APKAINI6BNPKV54NHH7Q.pem'), 'rb') as key_file:
+        private_key = serialization.load_pem_private_key(
+            key_file.read(),
+            password=None,
+            backend=default_backend()
+        )
+    signer = private_key.signer(padding.PKCS1v15(), hashes.SHA1())
+    signer.update(message)
+    return signer.finalize()
+
+
+def CloudfrontSignUrl(url):
+    key_id = 'APKAINI6BNPKV54NHH7Q'
+    # url = 'http://d3om3d8c0l14oc.cloudfront.net/vod/2N1K3LE78TYJ38CE111A_99/1234.ts'
+    expire_date = datetime.datetime.now() + datetime.timedelta(days=10)
+    print(expire_date)
+    cloudfront_signer = CloudFrontSigner(key_id, rsa_signer)
+    signed_url = cloudfront_signer.generate_presigned_url(
+        url, date_less_than=expire_date)
+    return signed_url

Object/AWS/ElasticTranscoder.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python3  
+# -*- coding: utf-8 -*-  
+"""
+@Copyright (C) ansjer cop Video Technology Co.,Ltd.All rights reserved.
+@AUTHOR: ASJRD018
+@NAME: Ansjer
+@software: PyCharm
+@DATE: 2018/5/17 10:09
+@Version: python3.6
+@MODIFY DECORD:ansjer dev
+@file: ElasticTranscoderClassObject.py
+@Contact: chanjunkai@163.com
+"""
+from boto3.session import Session
+from Ansjer.config import *
+
+class ElasticTranscoder:
+    def __init__(self, *args, **kwargs):
+        self.access_id = AWS_ACCESS_ID,
+        self.access_secret = AWS_ACCESS_SECRET,
+        session = Session(
+            aws_access_key_id=AWS_ACCESS_ID,
+            aws_secret_access_key=AWS_ACCESS_SECRET,
+            region_name=AWS_ACCESS_REGION,
+        )
+        self.conn = session.client('elastictranscoder')
+
+    def create_job(self, InputKey='', OutputKey=''):
+        response = self.conn.create_job(
+            PipelineId='1526962004445-bmasp8',
+            Input={
+                'Key': InputKey
+            },
+            Outputs=[
+                {
+                    'Key': OutputKey,
+                    'PresetId': '1351620000001-200010',
+                    'SegmentDuration': '2',
+                }
+            ]
+        )
+        print(response)
+        if response['ResponseMetadata']['HTTPStatusCode'] == 201:
+            return True
+        else:
+            return False

Object/AWS/S3ClassObject.py

@@ -0,0 +1,185 @@
+from Ansjer.config import *
+from boto3.session import Session
+import simplejson as json
+import boto3
+from botocore.client import Config
+
+
+class S3ClassObject:
+    def __init__(self, *args, **kwargs):
+        self.bucket = AWS_BUCKET
+        self.access_id = AWS_ACCESS_ID
+        self.access_secret = AWS_ACCESS_SECRET
+        self.region_name = AWS_ACCESS_REGION
+        session = Session(
+            aws_access_key_id=AWS_ACCESS_ID,
+            aws_secret_access_key=AWS_ACCESS_SECRET,
+            region_name=AWS_ACCESS_REGION
+        )
+        self.conn = session.client('s3')
+
+    def put_object(self, body, key, bucket=''):
+        if bucket == '':
+            bucket = self.bucket
+        s3_client = self.conn
+        response = s3_client.put_object(
+            Body=body,
+            Key=key,
+            Bucket=bucket,
+            # Expires=datetime()
+        )
+        return response
+
+    def download_file(self, file_name):
+        s3_client = self.conn
+        try:
+            s3_client.download_file(
+                self.bucket,
+                file_name,
+            )
+            return file_name
+        except:
+            print('Cannot download file', file_name)
+            return
+
+    def get_all_object(self, prefix):
+        paginator = self.conn.get_paginator('list_objects')
+        s3_results = paginator.paginate(
+            Bucket=self.bucket,
+            Prefix=prefix,
+            PaginationConfig={'PageSize': 1000}
+        )
+        bucket_object_list = []
+        for page in s3_results:
+            if "Contents" in page:
+                for key in page["Contents"]:
+                    s3_file_name = key['Key'].split('/')[-1]
+                    bucket_object_list.append(s3_file_name)
+        return bucket_object_list
+
+    def get_prefix_obj(self, prefix,bucket):
+        paginator = self.conn.get_paginator('list_objects')
+        s3_results = paginator.paginate(
+            Bucket=bucket,
+            Prefix=prefix,
+            # PaginationConfig={'PageSize': 1000}
+        )
+        bucket_object_list = []
+        for page in s3_results:
+            if "Contents" in page:
+                for key in page["Contents"]:
+                    s3_file_name = key['Key'].split('/')[-1]
+                    bucket_object_list.append(s3_file_name)
+        return bucket_object_list
+
+    def delete_object(self, key):
+        response = self.conn.delete_object(
+            Bucket=self.bucket,
+            Key=key,
+        )
+        return response
+
+    def get_object(self, key):
+        response = self.conn.get_object(
+            Bucket=self.bucket,
+            Key=key,
+        )
+        return response
+
+    def del_list_object(self, keydict):
+        keylist = json.loads(keydict)['keylist']
+        del_list = []
+        for i in keylist:
+            del_list.append({'Key': i})
+        response = self.conn.delete_objects(
+            Bucket=self.bucket,
+            Delete={'Objects': del_list}
+        )
+        print(response)
+        return response
+
+    def del_object_list(self, keylist):
+        del_list = []
+        for i in keylist:
+            del_list.append({'Key': i})
+        response = self.conn.delete_objects(
+            Bucket=self.bucket,
+            Delete={'Objects': del_list}
+        )
+        print(response)
+        return response
+
+    def get_download_url(self, key):
+        self.conn.generate_presigned_url(
+            'get_object',
+            Params={
+                'Bucket': 'www.mybucket.com',
+                'Key': key
+            },
+            ExpiresIn=100)
+        return
+
+    # 推mp4到s3，且设置为html5播放
+    def put_mp4_object(self, body, key):
+        s3_client = self.conn
+        response = s3_client.put_object(
+            Body=body,
+            Key=key,
+            Bucket=self.bucket,
+            ContentType='video/mp4'
+        )
+        return response
+
+    def get_generate_vod_url(self, key):
+
+        response_url = self.conn.generate_presigned_url(
+            'get_object',
+            Params={
+                'Bucket': self.bucket,
+                'Key': key
+            },
+            ExpiresIn=3600
+        )
+        return response_url
+
+    def sign_put_object(self, key,bucket_meal):
+        s3_con = boto3.client('s3',
+            aws_access_key_id=AWS_ACCESS_ID,
+            aws_secret_access_key=AWS_ACCESS_SECRET,
+            config=Config(signature_version='s3v4'),
+            region_name=AWS_ACCESS_ID,
+        )
+        try:
+            url = s3_con.generate_presigned_url(
+                'put_object',
+                Params={
+                    'Bucket':bucket_meal,
+                    'Key': key,
+                },
+                ExpiresIn=60,
+                HttpMethod='PUT'
+            )
+        except Exception as e:
+            print(repr(e))
+            return False
+        else:
+            return url
+
+    def sign_post_object(self, key,bucket_meal):
+        s3_con = boto3.client('s3',
+            aws_access_key_id=AWS_ACCESS_ID,
+            aws_secret_access_key=AWS_ACCESS_SECRET,
+            config=Config(signature_version='s3v4'),
+            region_name=AWS_ACCESS_REGION,
+        )
+        try:
+            data = s3_con.generate_presigned_post(
+                Key=key,
+                ExpiresIn=60,
+                Bucket=bucket_meal
+            )
+        except Exception as e:
+            print(repr(e))
+            return False
+        else:
+            return data

Object/AWS/SesClassObject.py

@@ -0,0 +1,53 @@
+from Ansjer.config import *
+from boto3.session import Session
+import traceback
+
+class SesClassObject:
+    def __init__(self, *args, **kwargs):
+        self.access_id = AWS_ACCESS_ID
+        self.access_secret = AWS_ACCESS_SECRET
+        self.region_name = AWS_ACCESS_REGION
+        self.company_email = COMPANY_EMAIL
+        session = Session(
+            aws_access_key_id=AWS_ACCESS_ID,
+            aws_secret_access_key=AWS_ACCESS_SECRET,
+            region_name=AWS_ACCESS_REGION,
+        )
+        self.conn = session.client('ses')
+
+    def send_email(self, send_address_list=[], subject='', body=''):
+        try:
+            response = self.conn.send_email(
+                # 发送人
+                Source=self.company_email,
+                Destination={
+                    # 收件人
+                    'ToAddresses': send_address_list
+                    # 'ToAddresses': [
+                    #     '1758730877@qq.com',
+                    # ],
+                },
+                Message={
+                    # 标题
+                    'Subject': {
+                        'Data': subject,
+                        'Charset': 'utf-8'
+                    },
+                    'Body': {
+                        'Html': {
+                            'Data': body,
+                            'Charset': 'utf-8'
+                        }
+                    }
+                },
+            )
+        except Exception as e:
+            errorInfo = traceback.format_exc()
+            print(errorInfo)
+            self.send_email(send_address_list=[self.company_email], subject='邮件发送错误信息提醒', body='<br>请向开发人员反馈并修改</br>' +'\n错误信息位'+str(errorInfo))
+        if response['MessageId']:
+            return True
+        else:
+            print(response)
+            self.send_email(send_address_list=[self.company_email],subject='邮件发送错误信息提醒',body='<br>请向开发人员反馈并修改</br>')
+            return False

Object/encryHlsVodUrl.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python3  
+# -*- coding: utf-8 -*-  
+"""
+@Copyright (C) ansjer cop Video Technology Co.,Ltd.All rights reserved.
+@AUTHOR: ASJRD018
+@NAME: Ansjer
+@software: PyCharm
+@DATE: 2018/6/8 15:22
+@Version: python3.6
+@MODIFY DECORD:ansjer dev
+@file: encryHlsVodUrl.py
+@Contact: chanjunkai@163.com
+"""
+# coding=utf-8
+# + + + ++ + + ++ + + ++ + + ++ + + ++ + + ++ + + ++ + + ++ + + ++ + + ++ + + ++ + + ++ + + ++ + + ++ + + +
+#        ┏┓　　　┏┓+ +
+# 　　　┏┛┻━━━┛┻┓ + +
+# 　　　┃　　　　　　 ┃ 　
+# 　　　┃　　　━　　　┃ ++ + + +
+# 　　 ████━████ ┃+
+# 　　　┃　　　　　　 ┃ +
+# 　　　┃　　　┻　　　┃
+# 　　　┃　　　　　　 ┃ + +
+# 　　　┗━┓　　　┏━┛
+# 　　　　　┃　　　┃　　　　　　　　　　　
+# 　　　　　┃　　　┃ + + + +
+# 　　　　　┃　　　┃　　　　Codes are far away from bugs with the animal protecting　　　
+# 　　　　　┃　　　┃ + 　　　　神兽保佑,代码无bug　　
+# 　　　　　┃　　　┃
+# 　　　　　┃　　　┃　　+　　　　　　　　　
+# 　　　　　┃　 　　┗━━━┓ + +
+# 　　　　　┃ 　　　　　　　┣┓
+# 　　　　　┃ 　　　　　　　┏┛
+# 　　　　　┗┓┓┏━┳┓┏┛ + + + +
+# 　　　　　　┃┫┫　┃┫┫
+# 　　　　　　┗┻┛　┗┻┛+ + + +
+# + + + ++ + + ++ + + ++ + + ++ + + ++ + + ++ + + ++ + + ++ + + ++ + + ++ + + ++ + + ++ + + ++ + + ++ + + +"""
+"""
+"""
+import base64
+import hashlib
+import time
+
+def md5(text, isBackByte=False):
+    """md5加密函数"""
+    md5 = hashlib.md5()
+    if isinstance(text, bytes):
+        md5.update(text)
+    else:
+        md5.update(text.encode('utf-8'))
+
+    if isBackByte:
+        # 返回二进制的加密结果
+        return md5.digest()
+
+        # 返回十六进制的机密结果
+    return md5.hexdigest()
+
+
+def base64_encode(text, isBytes=False):
+    """进行base64编码处理"""
+    if isBytes:
+        return base64.b64encode(text)
+    return base64.b64encode(bytes(text, encoding="utf-8"))
+
+
+def get_timestamp10():
+    """获取当前时间长度为10位长度的时间戳"""
+    return int(time.time())
+
+def getSignUrl(path):
+    secret = 'ansjer';  # 密钥--对应#st的哈希格式为 secret+url+e,e为时间戳单位s，url为请求地址  secure_link_md5 xiaozhong.com$uri$arg_e;
+    # 下载到期时间,time是当前时间,300表示300秒,也就是说从现在到300秒之内文件不过期
+    expire = get_timestamp10() + 1800;
+    res = md5(str(secret) + str(path) + str(expire), True)
+    md5str = str(base64_encode(res, True))
+    md5st = md5str.replace('b\'', '').replace('\'', '').replace('+', '-').replace('/', '_').replace('=', '')
+    url = 'http://52.8.197.107'+path+'.m3u8?' + 'st=' + str(md5st) + '&e=' + str(expire)
+    return url
+
+# print('生成代相关认证签名的地址：','http://192.168.136.45:8384/hls/5553.mp4/index.m3u8?' + 'st=' + str(md5) + '&e=' + str(expire))
+# print('生成代相关认证签名的地址：','http://52.8.197.107/444.mp4.m3u8?' + 'st=' + str(md5) + '&e=' + str(expire))
+# print('生成代相关认证签名的地址：','http://d3puj5e5oiunfy.cloudfront.net/444.mp4.m3u8?' + 'st=' + str(md5) + '&e=' + str(expire))

Object/m3u8generate.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3  
+# -*- coding: utf-8 -*-  
+"""
+@Copyright (C) ansjer cop Video Technology Co.,Ltd.All rights reserved.
+@AUTHOR: ASJRD018
+@NAME: Ansjer
+@software: PyCharm
+@DATE: 2018/6/4 13:42
+@Version: python3.6
+@MODIFY DECORD:ansjer dev
+@file: m3u8generate.py
+@Contact: chanjunkai@163.com
+"""
+import logging
+
+logger = logging.getLogger(__name__)
+
+class PlaylistGenerator(object):
+    def __init__(self, playlist_entries=None, version=3):
+        if playlist_entries == None:
+            # raise StandardError
+            pass
+        self.end_playlist = True
+        self.playlist_entries = playlist_entries
+        self.version = version
+        self.sequence = 0
+        self.duration = self.duration()
+
+    def _generate_playlist(self):
+        playlist = "{}\n{}{}".format(self._m3u8_header_template(), self._generate_playlist_entries(), self._end_list())
+
+        return playlist
+
+    def _generate_playlist_entries(self):
+        playlist = ""
+        for entry in self.playlist_entries:
+            playlist += "#EXTINF:{duration}\n{media}\n".format(duration=float(entry['duration']), media=(entry['name']))
+
+        return playlist.replace(" ", "")
+
+
+    def _generate(self):
+        return self._generate_playlist()
+
+    def _m3u8_header_template(self):
+        header = "#EXTM3U\n#EXT-X-VERSION:{version}\n#EXT-X-TARGETDURATION:{duration}\n#EXT-X-PLAYLIST-TYPE:VOD".format(version=self.version,duration=self.duration).strip()
+        # header = "#EXTM3U\n#EXT-X-VERSION:{version}\n#EXT-X-MEDIA-SEQUENCE:{sequence}\n#EXT-X-TARGETDURATION:{duration}\n#EXT-X-PLAYLIST-TYPE:VOD".format(version=self.version, sequence=self.sequence, duration=self.duration).strip()
+
+        # if self.end_playlist:
+        #     return "{}\n#EXT-X-ENDLIST".format(header)
+        # else:
+        #     return header
+        return header
+
+    def _end_list(self):
+        return "#EXT-X-ENDLIST"
+
+    def duration(self):
+        duration_total = 0
+        for entry in self.playlist_entries:
+            if 'duration' in entry:
+                try:
+                    duration_total += float(entry['duration'])
+                except Exception as e:
+                    logger.exception(e)
+
+        return duration_total
+
+    def generate(self):
+        """ This is a proxy for _generate makes it
+        difficult to edit the real method for future."""
+        return self._generate()

Object/mongodb.py

@@ -0,0 +1,111 @@
+#!/usr/bin/env python3  
+# -*- coding: utf-8 -*-  
+"""
+@Copyright (C) ansjer cop Video Technology Co.,Ltd.All rights reserved.
+@AUTHOR: ASJRD018
+@NAME: Ansjer
+@software: PyCharm
+@DATE: 2018/6/15 14:18
+@Version: python3.6
+@MODIFY DECORD:ansjer dev
+@file: mongodb.py
+@Contact: chanjunkai@163.com
+"""
+# !/usr/bin/python3
+import pymongo
+import math
+import platform
+
+
+class mongodb(object):
+
+    def __init__(self):
+        sysstr = platform.system()
+        if (sysstr == "Windows"):
+            myclient = pymongo.MongoClient('mongodb://192.168.136.45:27017/')
+        elif (sysstr == "Linux"):
+            print("Call Linux tasks")
+            myclient = pymongo.MongoClient()
+        self.myclient = myclient
+        self.db = myclient['ansjer']
+        # self.db = myclient['test_ansjer']
+
+    def check_db_exist(self, database):
+        dblist = self.myclient.database_names()
+        if database in dblist:
+            return True
+        else:
+            return False
+
+    def insert_one(self, col, data):
+        column = self.db[col]
+        res = column.insert_one(data)
+        return res.inserted_id
+
+    def findAll(self, col,page,line,query):
+        collist = self.db.collection_names()
+        if col in collist:  # 判断 customers 集合是否存在
+            # qs = self.db[col].find()
+            if int(page) < 0:
+                count = mdb.cout(col=col, query=query)
+                total = math.ceil(count / int(line))
+                page = int(total) + int(page) + 1
+            qs = self.db[col].find(query).sort("_id", -1)
+            count = qs.count()
+            if page != 0 and line != 0:
+                qs = qs.skip((page - 1) * 10).limit(line)
+            # print(count)
+            data = []
+            for q in qs:
+                q.pop('_id')
+                if 'et' in q:
+                    q.pop('et')
+                data.append(q)
+            res_dict = {'data': data, 'count': count}
+            return res_dict
+        else:
+            print("集合不存在！")
+            return False
+
+    #获取col总数
+    def cout(self,col,query):
+        collist = self.db.collection_names()
+        if col in collist:  # 判断 customers 集合是否存在
+            # qs = self.db[col].find()
+            qs = self.db[col].find(query)
+            count = qs.count()
+        return count
+
+    # 删除集合（//删除表）
+    def drop_col(self,col):
+        column = self.db[col]
+        column.drop()
+        return
+
+if __name__ == '__main__':
+    mdb = mongodb()
+    col = "log_device_operation"
+    # col = "log_access"
+    # mdb.drop_col(col)
+    # exit()
+    # data = {"name": "111", "address": "Lowstreet 27"}
+    # flag = mdb.insert_one(col=col, data=data)
+    # qs = mdb.findAll(col=col, page=1, line=10,query={'UID':'C2887N9EBS87ZAT1111A'})
+    # print(qs)
+    '''创建索引'''
+    # from pymongo import ASCENDING, DESCENDING
+    ss = mdb.db[col].create_index([('type',1)])
+    # ss = mdb.db[col].create_index([('time',1)])
+    #print(ss)
+    ''''''
+    '''
+    604800
+    '''
+    '''
+    增加过期时间
+    '''
+    mdb.db[col].create_index([("et", 1)], expireAfterSeconds=604800)
+    # mdb.db[col].create_index([("et", 1)], expireAfterSeconds=1209600)
+    '''
+    删除索引
+    '''

Service/CommonService.py

@@ -0,0 +1,249 @@
+# -*- coding: utf-8 -*-
+import simplejson as json
+from django.core import serializers
+from pyipip import IPIPDatabase
+import redis,time,base64
+from pathlib import Path
+from django.utils import timezone
+from Ansjer.config import *
+from django_global_request.middleware import get_request
+
+
+# 复用性且公用较高封装代码在这
+class CommonService:
+
+    # 返回数据格式化
+    @staticmethod
+    def response_formal(data={'code': '', 'reason': '', 'result': {}}):
+        resJSON = json.dumps(
+            {
+                "result_code": data['code'],
+                "reason": data['reason'],
+                "result": data['result'],
+                "error_code": data['code'],
+            }, ensure_ascii=False)
+        return resJSON
+
+    # 添加模糊搜索
+    @staticmethod
+    def get_kwargs(data={}):
+        kwargs = {}
+        for (k, v) in data.items():
+            if v is not None and v != u'':
+                kwargs[k + '__icontains'] = v
+        return kwargs
+
+    # 定义静态方法
+    # 格式化query_set转dict
+    @staticmethod
+    def query_set_to_dict(query_set):
+        sqlJSON = serializers.serialize('json', query_set)
+        sqlList = json.loads(sqlJSON)
+        sqlDict = dict(zip(["datas"], [sqlList]))
+        return sqlDict
+
+    @staticmethod
+    def set_redis_data(key, val, expire=0):
+        POOL = redis.ConnectionPool(host=SERVER_HOST, port=6379)
+        CONN = redis.Redis(connection_pool=POOL)
+        CONN.set(key, val)
+        if expire > 0:
+            CONN.expire(key, expire)
+        return True
+
+    @staticmethod
+    def get_redis_data(key):
+        POOL = redis.ConnectionPool(host=SERVER_HOST, port=6379)
+        CONN = redis.Redis(connection_pool=POOL)
+        try:
+            val = CONN.get(key)
+        except Exception as e:
+            return False
+        else:
+            if val == b'False':
+                return False
+            if val:
+                return val
+            else:
+                return False
+
+    @staticmethod
+    def del_redis_data(key):
+        POOL = redis.ConnectionPool(host=SERVER_HOST, port=6379)
+
+        CONN = redis.Redis(connection_pool=POOL)
+        val = CONN.delete(key)
+        if val:
+            return True
+        else:
+            return False
+
+    # 获取文件大小
+    @staticmethod
+    def get_file_size(file_path='', suffix_type='', decimal_point=0):
+
+        # for x in ['bytes', 'KB', 'MB', 'GB', 'TB']:
+        # path = Path() / 'D:/TestServer/123444.mp4'
+        path = Path() / file_path
+        size = path.stat().st_size
+        mb_size = 0.0
+        if suffix_type == 'MB':
+            mb_size = size / 1024.0 / 1024.0
+        if decimal_point != 0:
+            mb_size = round(mb_size, decimal_point)
+        return mb_size
+
+    @staticmethod
+    def get_param_flag(data=[]):
+        print(data)
+        flag = True
+        for v in data:
+            if v is None:
+                flag = False
+                break
+        return flag
+
+    @staticmethod
+    def get_ip_address(request):
+        """
+        获取ip地址
+        :param request:
+        :return:
+        """
+        ip = request.META.get("HTTP_X_FORWARDED_FOR", "")
+        if not ip:
+            ip = request.META.get('REMOTE_ADDR', "")
+        client_ip = ip.split(",")[-1].strip() if ip else ""
+        return client_ip
+
+    # @获取一天每个小时的datetime.datetime
+    @staticmethod
+    def getTimeDict(times):
+        time_dict = {}
+        t = 0
+        for x in range(24):
+            if x < 10:
+                x = '0' + str(x)
+            else:
+                x = str(x)
+            a = times.strftime("%Y-%m-%d") + " " + x + ":00:00"
+            time_dict[t] = timezone.datetime.strptime(a, '%Y-%m-%d %H:%M:%S')
+            t += 1
+        return time_dict
+
+    #根据ip获取地址
+    @staticmethod
+    def getAddr(ip):
+        base_dir = BASE_DIR
+        # ip数据库
+        db = IPIPDatabase(base_dir+'/DB/17monipdb.dat')
+        addr = db.lookup(ip)
+        ts = addr.split('\t')[0]
+        return ts
+
+    #getMoreID
+    @staticmethod
+    def getMoreID(uPhone='13800138000', μs='uID'):
+        if μs == 'uID':
+            userID = str(round(time.time() * 1000000)) + uPhone
+            return userID
+
+        elif μs == 'otaID':
+            otaID = '13800138000' + str(round(time.time() * 1000000))
+            return otaID
+
+        elif μs == 'eID':
+            eID = '13800' + str(round(time.time() * 1000000)) + '138000'
+            return eID
+
+        elif μs == 'ID':
+            eID = '13800' + str(round(time.time() * 1000000)) + '138000'
+            return eID
+
+        elif μs == 'gID':
+            gID = '10000' + str(round(time.time() * 1000000)) + '100001'
+            return gID
+
+        elif μs == 'rID':
+            rID = '10010' + str(round(time.time() * 1000000)) + '100011'
+            return rID
+
+        else:
+            defaultID = '10000100001' + str(round(time.time() * 1000000))
+            return defaultID
+
+    # getMoreID
+    @staticmethod
+    def getUserID(userPhone='13800138000', getUser=True, setOTAID=False, μs=True):
+        if μs == True:
+            if getUser == True:
+                timeID = str(round(time.time() * 1000000))
+                userID = timeID + userPhone
+
+                return userID
+            else:
+                if setOTAID == False:
+                    timeID = str(round(time.time() * 1000000))
+                    ID = userPhone + timeID
+
+                    return ID
+                else:
+                    timeID = str(round(time.time() * 1000000))
+                    eID = '13800' + timeID + '138000'
+                    return eID
+        else:
+            if getUser == True:
+                timeID = str(round(time.time() * 1000))
+                userID = timeID + userPhone
+
+                return userID
+            else:
+                if setOTAID == False:
+                    timeID = str(round(time.time() * 1000))
+                    ID = userPhone + timeID
+
+                    return ID
+                else:
+                    timeID = str(round(time.time() * 1000))
+                    eID = '13800' + timeID + '138000'
+                    return eID
+
+    @staticmethod
+    def get_request_val(key):
+        request = get_request()
+        if request.method == 'GET':
+            request_dict = request.GET
+        if request.method == 'POST':
+            request_dict = request.POST
+        val = request_dict.get(key, None)
+        return val
+
+    @staticmethod
+    def get_userID_byT(token):
+        if token == 'stest':
+            userID = '151547867345163613800138001'
+            var_dump(userID)
+            return userID
+        if token == 'sformal':
+            userID = '151564262337939513800138001'
+            return userID
+        try:
+            access_token = token[::-1]
+            if len(access_token) < 18:
+                return None
+            atoken = access_token[:12] + access_token[18:]
+            try:
+                token_str = base64.urlsafe_b64decode(atoken).decode('utf-8')
+            except Exception as e:
+                print('base64 decode error: %s' % repr(e))
+            else:
+                token_list = token_str.split('&')
+            if len(token_list) != 2:
+                return None
+            ts_str = token_list[0]
+            jsonDict = json.loads(ts_str)
+            userID = jsonDict.get('userID', None)
+        except Exception as e:
+            return None
+        else:
+            return userID