safesite/safesite/views.py

import decimal
import json
import logging
import operator
import os
import pickle
import random
import re
import time

from io import StringIO
from uuid import UUID

import jwt
import requests
from captcha.helpers import captcha_image_url
from captcha.models import CaptchaStore
from django.conf import settings
from django.contrib.auth.hashers import check_password, make_password
from django.contrib.sessions.models import Session
from django.core import serializers
from django.core.serializers.json import DjangoJSONEncoder
from django.db.models import Avg, Count, F, Q, Sum
from django.forms.models import model_to_dict
from django.http import (HttpResponse, HttpResponseRedirect, JsonResponse,
                         request)
from django.shortcuts import redirect, render
from django.template import RequestContext
from django.views.decorators.csrf import csrf_exempt
from django.views.generic import TemplateView
from duibiao import calsim
from groups import models as g_models

from . import forms
from .daoru import (cal_area_risk_level, cal_riskact_level, drequipments,
                    drquestions, drrisks, drtodotroubles, drusers, makeqr,
                    makeqr_area, makeqr_examtest, makeqr_riskact, makeqr_train)
from .export import (exportdoc, exportdoc2, exportsimplexlsx, exportxlsx,
                     exportyjdoc)
from .forms import UserForm
from .models import *
from .models import CompanyInfo
from .safespider import getAqzs, getTzzs
from .tasks import (gettime, send_wechatmsg, send_wechatmsgs, updateAqzs,
                    updateTzzs, yjjs, yjjs_gc, yjjs_px, yjjs_ws, yjjs_yl)

from datetime import date, datetime, timedelta
logger = logging.getLogger('log')

# 分页功能


def fenye(req):
    page = int(req.GET.get('page', 1))
    rows = int(req.GET.get('rows',10))
    endnum = page*rows
    startnum = endnum-rows
    return startnum, endnum

# 特殊字符转json


class MyEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, datetime):
            return obj.strftime('%Y-%m-%d %H:%M')
        elif isinstance(obj, date):
            return obj.strftime("%Y-%m-%d")
        elif isinstance(obj, decimal.Decimal):
            return float(obj)
        elif isinstance(obj, UUID):
            # if the obj is uuid, we simply return the value of uuid
            return obj.hex
        else:
            return json.JSONEncoder.default(self, obj)

# 获取user所在公司


def getcompany(x):
    a = User.objects.get(userid=x)
    if a.ubelongpart.iscompany == 1:
        return str(a.ubelongpart.partid)
    else:
        return a.ubelongpart.partlink.split(',')[1]


def getparts(partid):  # 获取该部门及下属部门
    return Partment.objects.filter(Q(partid=partid) | Q(partlink__contains=',' + str(partid) + ','))

# 转换为datagrid所用json


def transjson(total, obj):
    a = {'total': total, 'rows': list(obj), 'code': 1}
    jsondata = json.dumps(a, cls=MyEncoder)
    return jsondata


def transjson2(v):
    return json.dumps(list(v), cls=DjangoJSONEncoder)

# 转换为combobox所用string


def transstr(obj, str1, str2):
    keylist = []
    for i in list(obj):
        keydictstr = '{"value":"' + str(i[str1])+'","text":"'+i[str2]+'"}'
        keylist.append(keydictstr)
    keystr = '['+','.join(keylist)+']'
    return keystr


def check_login(func):
    def warpper(request, *args, **kwargs):
        is_login = request.session.get('userid', None)
        if is_login:
            return func(request, *args, **kwargs)
        else:
            return redirect('login')
    return warpper


def apicheck_login(func):
    def warpper(request, *args, **kwargs):
        is_login = request.session.get('userid', None)
        if is_login:
            return func(request, *args, **kwargs)
        else:
            return JsonResponse({'code': -1, 'msg': '请登陆'})
    return warpper


def check_session(req):
    if req.session.get('userid', None):
        return JsonResponse({"code": 1})
    else:
        return JsonResponse({"code": -1})




# 存储文件


def upfile(req):
    username = User.objects.get(userid=req.session['userid']).username
    file_name = (time.strftime('%Y%m%d%H%M%S') + '_' +
                 req.FILES['upfile'].name).replace('#', '号')
    user_upload_folder = os.path.join('media', username)
    if not os.path.exists(user_upload_folder):
        os.mkdir(user_upload_folder)
    filepath = os.path.join(user_upload_folder, file_name)
    filepath = filepath.replace('\\', '/')
    with open(filepath, 'wb') as f:
        f.write(req.FILES['upfile'].read())
    return JsonResponse({"code": 1, "filename": file_name, "filepath": filepath})

# html页面
class EquipmentCheckFormUpdateView(TemplateView):
    template_name='equipmentcheckformupdate.html'

class EquipmentCheckFormAddView(TemplateView):
    template_name='equipmentcheckformadd.html'

class EquipmentCheckFormView(TemplateView):
    template_name='equipmentcheckform.html'

def riskas(req):
    return render(req, 'riskas.html')


def reportedit(req):
    return render(req, 'reportedit.html', {'year': req.GET.get('year'), 'month': req.GET.get('month'), 'part': req.GET.get('part')})


def riskedit(req, id):
    return render(req, 'riskedit.html', {'id': id})


def riskcheck(req):  # 风险点排查记录
    return render(req, 'riskactcheck.html')


def taskdo(req):
    return render(req, 'taskdo.html')


def task(req):
    return render(req, 'task.html')


def riskactchose(req):
    area = 0
    if req.GET.get('area', None):
        area = req.GET.get('area')
    return render(req, 'riskactchose.html', locals())


def riskactedit(req, id):
    return render(req, 'riskactedit.html', {'id': id})


def riskactadd(req, kind):
    return render(req, 'riskactadd.html', {'kind':kind})


def riskadd(req, id):
    return render(req, 'riskadd.html', {'id': id})


def risk(req, kind):
    return render(req, 'risk.html', {'kind': kind})

def gridtaskset(req):
    return render(req, 'gridtaskset.html')

def gridtasksetadd(req, riskact):
    return render(req, 'gridtasksetadd.html', {'riskact': riskact})

def gridtasksetedit(req, id):
    return render(req, 'gridtasksetedit.html', {'id': id})

def scheduleset(req):
    return render(req, 'scheduleset.html')

def schedulesetadd(req):
    return render(req, 'schedulesetadd.html')

def schedulesetedit(req, id):
    return render(req, 'schedulesetedit.html', {'id': id})

def inspect(req):
    return render(req, 'inspect.html')

def inspectdetail(req, id):
    return render(req, 'inspectdetail.html', {'id':id})

def inspectitem(req):
    return render(req, 'inspectitem.html')

def inspectitemdetail(req, id):
    return render(req, 'inspectitemdetail.html', {'id':id})

def equipment(req):
    return render(req, 'equipment.html')


def areaedit(req, id):
    return render(req, 'areaedit.html', {'id': id})


def areaadd(req):
    return render(req, 'areaadd.html')


def areadetail(req):
    id = req.GET.get('id')
    return render(req, 'areadetail.html', {'id': id})


def mapshow(req):
    return render(req, 'mapshow.html')


def area(req):
    return render(req, 'area.html')


def personaltrain(req):
    return render(req, 'personaltrain.html')


def examtest(req):
    return render(req, 'examtest.html')


def safecert(req):
    return render(req, 'safecert.html')


def safecertadd(req):
    return render(req, 'safecertadd.html')

def safecertedit(req, id):
    return render(req, 'safecertedit.html', {'id': id})

def examtestdetail(req, id):
    return render(req, 'examtestdetail.html', {'id': id})


def examtestadd(req):
    return render(req, 'examtestadd.html')


def examtestadd2(req):
    return render(req, 'examtestadd2.html')


def questionchoose(req):
    return render(req, 'questionchoose.html')


def exampaperedit(req, id):
    return render(req, 'exampaperedit.html', {'id': id})


def exampaperadd(req):
    return render(req, 'exampaperadd.html')

def exampaperchose(req):
    return render(req, 'exampaperchose.html')

def exampaper(req):
    return render(req, 'exampaper.html')


def examhistory(req, id):
    return render(req, 'examhistory.html', {'id': id})


def questionadd(req):
    return render(req, 'questionadd.html')


def questionadd2(req):
    return render(req, 'questionadd2.html')


def questionadd3(req):
    return render(req, 'questionadd3.html')


def questionedit(req, id):
    obj = Question.objects.get(id=id)
    if obj.type == 1:
        return render(req, 'questionedit.html', {'id': id})
    elif obj.type == 2:
        return render(req, 'questionedit2.html', {'id': id})
    elif obj.type == 3:
        return render(req, 'questionedit3.html', {'id': id})


def question(req):
    return render(req, 'question.html')


def questioncatadd(req):
    return render(req, 'questioncatadd.html')


def questioncatedit(req, id):
    return render(req, 'questioncatedit.html', {'id': id})


def operationspjdadd(req):
    return render(req, 'operationspjdadd.html')


def fxcsadd(req):
    return render(req, 'fxcsadd.html')

def fxcsedit(req, id):
    return render(req, 'fxcsedit.html', {'id': id})

def operationadd(req):
    return render(req, 'operationadd.html')


def operationdetail(req, zyid):
    return render(req, 'operationdetail.html', {'zyid': zyid})


def operation(req):
    return render(req, 'operation.html')


def zuoyepeizhi(req):
    return render(req, 'zuoyepeizhi.html')


def notice(req):
    return render(req, 'notice.html')


def noticeadd(req):
    return render(req, 'noticeadd.html')


def noticedetail(req, id):
    return render(req, 'noticedetail.html', {'id': id})


def noticeedit(req, id):
    return render(req, 'noticeedit.html', {'id': id})


def suggestupdate(req, jyid):
    return render(req, 'suggestupdate.html', {'jyid': jyid})


def suggestdetail(req, jyid):
    return render(req, 'suggestdetail.html', {'jyid': jyid})


def suggestadd(req):
    return render(req, 'suggestadd.html')


def suggest(req):
    return render(req, 'suggest.html')


def medetail(req):
    return render(req, 'medetail.html')


def socerthtml(req):
    return render(req, 'socert.html')


def socertadd(req):
    return render(req, 'socertadd.html')

def socertedit(req, id):
    return render(req, 'socertedit.html', {'id':id})

def rightshtml(req):
    groupid = req.GET.get('groupid')
    return render(req, 'rights.html', {'groupid': groupid})


def misshtml(req):
    return render(req, 'miss.html')


def missadd(req):
    return render(req, 'missadd.html')


def missdetail(req, missid):
    return render(req, 'missdetail.html', {'missid': missid})


def troublehtml(req):
    return render(req, 'trouble.html')


def observehtml(req):
    return render(req, 'observe.html')


def addobserve(req):
    return render(req, 'addobserve.html')


def accesstrouble(req):
    return render(req, 'accesstrouble.html')


def addtrouble(req):
    return render(req, 'addtrouble.html')


def dichtml(req):
    return render(req, 'dichtml.html')


def putreehtml(req):
    return render(req, 'putree.html')


def usergroup(req):
    return render(req, 'usergroup.html')


def getuserf(req):
    return render(req, 'getuser.html')


def getusersf(req):
    return render(req, 'getusers.html')


def trainhtml(req):
    return render(req, 'train.html')

def trainplanhtml(req):
    return render(req, 'trainplan.html')

def trainplanchosehtml(req):
    return render(req, 'trainplanchose.html')

def trainplanaddhtml(req):
    return render(req, 'trainplanadd.html')

def trainplanedithtml(req, id):
    return render(req, 'trainplanedit.html', {'id': id})

def abtrain(req):
    return render(req, 'abtrain.html')


def drillhtml(req):
    return render(req, 'drill.html')


def abdrill(req):
    return render(req, 'abdrill.html')


def reporthtml(req):
    return render(req, 'report.html')


def troubleashtml(req):
    return render(req, 'troubleashtml.html')


def userhtml(req):
    return render(req, 'userhtml.html')


def bhrhtml(req):
    return render(req, 'behavior.html')


def trainfigure(req):
    return render(req, 'trainfigure.html')


def equipmentfigure(req):
    return render(req, 'equipmentfigure.html')

def resbility(req):
    return render(req, 'resbility.html')


def addresbility(req):#责任制
    return render(req,'resbilityadd.html')
def resbilitydetail(req, id):
    return render(req, 'resbilitydetail.html', {'id': id})

def operproce(req):#操作规程
    return render(req, 'operproce.html')
def addoperproce(req):#责任制
    return render(req,'operproceadd.html')

def operprocedetail(req, id):
    return render(req, 'operprocedetail.html', {'id': id})

def datashow2(req):
    return render(req,'datashow2.html')
def checkdetail(req,id):
    return render(req,'checkdetail.html',{'id':id})
def checktask(req):#检查项目
    return render(req, 'checktable.html')
def addchecktask(req):#责任制
    return render(req,'checktabadd.html')
def checkjob(req):
    return render(req,'checkjob.html')
def addcheckjob(req,id):
    return render(req,'checkjobadd.html', {'id': id})
def checklist(req):
    return render(req,'checklist.html')
def addcheckrw(req):
    return render(req,'checklistadd.html')
def addcheckrw2(req):
    return render(req,'checklistadd2.html')
def alarmindex(req):#告警
    return render(req,'alarm.html')
def detailjob(req,id):
    return render(req,'checkjobdetail.html',{'id':id})
def updchecktable(req,id):
    return render(req,'checktabupd.html',{'id':id})
def mainhtml(req):
    # 计算一些数据
    userid = req.session['userid']
    companyid = getcompany(userid)
    first_day, first_day_of_next_month = gettime()
    # 查询
    a = Trouble.objects.filter(usecomp__partid=companyid, deletemark=1)
    totalyh = a.count()
    monthyh = a.filter(fxsj__range=(
        first_day, first_day_of_next_month)).count()
    yhnum = a.filter(todouser__userid=userid).count()
    b = Train.objects.filter(usecomp__partid=companyid, deletemark=1)
    pxnum = b.filter(state=0, submituser__userid=userid).count()
    totalpx = b.count()
    monthpx = b.filter(starttime__range=(
        first_day, first_day_of_next_month)).count()
    c = Drill.objects.filter(usecomp__partid=companyid, deletemark=1)
    totalyl = c.count()
    ylnum = c.filter(state=0, submituser__userid=userid).count()
    monthyl = c.filter(starttime__range=(
        first_day, first_day_of_next_month)).count()
    return render(req, 'main.html', {'yhnum': yhnum, 'totalyh': totalyh, 'monthyh': monthyh, 'pxnum': pxnum, 'totalpx': totalpx, 'monthpx': monthpx, 'ylnum': ylnum, 'totalyl': totalyl, 'monthyl': monthyl})

def checkpw(data): #密码复杂度校验
    reg = re.compile('(?=.*[0-9])(?=.*[a-zA-Z]).{8,30}')
    return re.match(reg,data)

def init_permission(user,req):
    permission_dict = {}
    x = []
    if user.issuper==1:
        menus = user.usecomp.role.permissions.all()
    else:
        bgroups = user.userg.filter(usecomp=user.usecomp) #所属公司的用户组
        
        if bgroups:
            for i in bgroups:
                if i.menulist:
                    x.extend(i.menulist)
        menus = Menu.objects.exclude(menuid__in=[11, 9]).filter(menuid__in=list(set(x)), deletemark=1)
    for item in menus:
        permission_dict[item.menucode] = ({
                                        'url':item.url,
                                        'parentid':item.parentid.menuid if item.parentid else None,
                                        'id': item.menuid,
                                        'name': item.menuname,
                                        })
    req.session['permissions'] = permission_dict



def login(req):
    if req.session.get('userid', None):
        return redirect('index')
    if req.method == 'POST':
        user_form = UserForm(req.POST)
        if user_form.is_valid():
            username = req.POST.get('username')
            password = req.POST.get('password')
            user = User.objects.filter(username=username, deletemark=1)
            if user.exists():
                if check_password(password, user[0].epassword):
                    req.session['userid'] = user[0].userid
                    req.session.set_expiry(60*40)
                    init_permission(user[0],req)
                    return redirect('index')
                else:
                    msg = '密码错误'
                    return render(req, 'login.html', locals())
            else:
                msg = '用户不存在或被禁用'
                return render(req, 'login.html', locals())
        else:
            msg = '验证码错误'
            return render(req, 'login.html', locals())
    else:
        user_form = UserForm()
        return render(req, 'login.html', locals())


def index(req):
    if not req.session.get('userid', None):
        return redirect('login')
    userid = req.session['userid']
    user = User.objects.get(userid=userid)
    pwstr = 0
    if checkpw(user.password):
        pwstr = 1
    companyname = user.usecomp.partname
    name = user.name
    openid = user.openid
    headimgurl = user.headimgurl
    nickname = user.nickname
    issuper = user.issuper
    token = user.token
    return render(req, 'index.html', locals())


def logout(req):
    if req.session.get('userid', None):
        logger.info('method: %s user: %s 登出' %
                    (req.method, req.session['userid']))
        req.session.flush()
    return redirect('login')


def changepwd(req):
    userid = req.session['userid']
    oldpassword = req.POST.get('oldpassword')
    newpassword = req.POST.get('newpassword')
    a = User.objects.get(userid=userid)
    if check_password(oldpassword, a.epassword):
        a.password = newpassword
        a.epassword = make_password(newpassword)
        a.save()
        del req.session['userid']
        return JsonResponse({"code": 1})
    else:
        return JsonResponse({"code": 2})


def mainapi(req):
    # 计算一些数据
    userid = req.session['userid']
    companyid = getcompany(userid)
    first_day, first_day_of_next_month = gettime()
    # 查询
    a = Trouble.objects.filter(usecomp__partid=companyid, deletemark=1)
    totalyh = a.count()
    monthyh = a.filter(fxsj__range=(
        first_day, first_day_of_next_month)).count()
    yhnum = a.filter(todouser__userid=userid).count()

    b = Train.objects.filter(usecomp__partid=companyid, deletemark=1)
    pxnum = b.filter(state=0, submituser__userid=userid).count()
    totalpx = b.count()
    monthpx = b.filter(starttime__range=(
        first_day, first_day_of_next_month)).count()

    c = Drill.objects.filter(usecomp__partid=companyid, deletemark=1)
    totalyl = c.count()
    ylnum = c.filter(state=0, submituser__userid=userid).count()
    monthyl = c.filter(starttime__range=(
        first_day, first_day_of_next_month)).count()

    gcobjs = Observe.objects.filter(deletemark=1, usecomp__partid=companyid)
    gcnum = gcobjs.filter(looktime__range=(
        first_day, first_day_of_next_month)).count()
    monthgc = gcobjs.filter(submittime__range=(
        first_day, first_day_of_next_month)).count()

    wsobjs = Miss.objects.filter(deletemark=1, usecomp__partid=companyid)
    monthws = wsobjs.filter(submittime__range=(
        first_day, first_day_of_next_month)).count()

    return JsonResponse({"code": 1, "yhnum": yhnum, "totalyh": totalyh, "monthyh": monthyh, "pxnum": pxnum, "totalpx": totalpx, "monthpx": monthpx, "ylnum": monthyl, "totalyl": totalyl, "xwnum": monthgc, "wsnum": monthws})


def getpgr_ubp(userid, ubp):
    a = ubp
    if a.aqy != ',':
        if ','+str(userid)+',' in a.aqy:
            if a.bmzg != ',':
                if ','+str(userid)+',' in a.bmzg:
                    return False
                else:
                    zgstr = a.bmzg
                    zglist = zgstr.split(',')
                    zglist = list(filter(None, zglist))
                    todouser = User.objects.get(userid=zglist[0])
                    return todouser
            else:
                return False
        else:
            if ','+str(userid)+',' in a.bmzg:
                return False
            else:
                aqystr = a.aqy
                aqylist = aqystr.split(',')
                aqylist = list(filter(None, aqylist))
                todouser = User.objects.get(userid=aqylist[0])
                return todouser
    else:
        if a.bmzg != ',':
            if ','+str(userid)+',' in a.bmzg:
                return False
            else:
                zgstr = a.bmzg
                zglist = zgstr.split(',')
                zglist = list(filter(None, zglist))
                todouser = User.objects.get(userid=zglist[0])
                return todouser
        else:
            return False


def getpgr(userid, ubp):
    currentpart = ubp
    if userid == 'zpbm':
        return getpgr_ubp(userid, currentpart)
    else:
        a = getpgr_ubp(userid, currentpart)
        while a == False:
            currentpart = currentpart.parentid  # 已找不到上级部门
            if currentpart:
                a = getpgr_ubp(userid, currentpart)
            else:
                return User.objects.get(userid=userid)
        return a

# 系统智能选取评估审核人 主管


def getpgr_ubp2(userid, ubp):
    a = ubp
    if a.bmzg != ',':
        zgstr = a.bmzg
        zglist = zgstr.split(',')
        zglist = list(filter(None, zglist))
        todouser = User.objects.get(userid=zglist[0])
        return todouser
    else:
        return False


def getpgr2(userid, ubp):
    currentpart = ubp
    a = getpgr_ubp2(userid, currentpart)
    while a == False:
        currentpart = currentpart.parentid  # 已找不到上级部门
        if currentpart:
            a = getpgr_ubp2(userid, currentpart)
        else:
            return User.objects.get(userid=userid)
    return a

# 系统智能选取作业审批人


def getspr_ubp(ubp):
    a = ubp
    if a.bmzg != ',':
        zgstr = a.bmzg
        zglist = zgstr.split(',')
        zglist = list(filter(None, zglist))
        return zglist[0]
    else:
        return False


def getspr(ubp):
    currentpart = ubp
    a = getspr_ubp(currentpart)
    while a == False:
        currentpart = currentpart.parentid  # 已找不到上级部门
        if currentpart:
            a = getspr_ubp(currentpart)
        else:
            return User.objects.get(ubelongpart=currentpart, issuper=1)
    return a


def getsprs(userid, ubp):
    currentpart = ubp
    a = getsprs_ubp(userid, currentpart)
    while a == False:
        currentpart = currentpart.parentid  # 已找不到上级部门
        if currentpart:
            a = getsprs_ubp(userid, currentpart)
        else:
            return User.objects.get(ubelongpart=currentpart, issuper=1)
    return a


def getsprs_ubp(userid, ubp):  # 主管
    a = ubp
    if a.bmzg != ',':
        zgstr = a.bmzg
        zglist = zgstr.split(',')
        zglist = list(map(int, list(filter(None, zglist))))
        if userid in zglist:
            return [userid]
        else:
            return zglist
    else:
        return False


def getsprs2(userid, ubp):
    currentpart = ubp
    a = getsprs_ubp2(userid, currentpart)
    while a == False:
        currentpart = currentpart.parentid  # 已找不到上级部门
        if currentpart:
            a = getsprs_ubp2(userid, currentpart)
        else:
            return User.objects.get(ubelongpart=currentpart, issuper=1)
    return a


def getsprs_ubp2(userid, ubp):  # 主管和被授权人员
    a = ubp
    if a.bmzg != ',':
        zgstr = a.bmzg
        zglist = zgstr.split(',')
        zglist = list(map(int, list(filter(None, zglist))))
        bsqstr = a.bsq
        bsqlist = list(map(int, list(filter(None, bsqstr.split(',')))))
        # if userid in zglist:
        #     return [userid]
        # elif userid in bsqlist:
        #     zglist.append(userid)
        #     return zglist
        # else:
        #     return zglist
        zglist.extend(bsqlist)
        return list(set(zglist))
    else:
        return False


def menutree(req):
    userid = req.session['userid']
    menus = []
    user = User.objects.get(userid=userid)
    if user.issuper == 1:  # 如果是超管
        menus = user.usecomp.role.permissions.filter(type=1).exclude(menuid__in=[11, 9]).order_by(
            'sortnum').values('menuid', 'menucode', 'parentid', 'url', 'menuname', 'icon').distinct()
    else:
        bgroups = user.userg.all()
        x = []
        for i in bgroups:
            x.extend(i.menulist)
        menus = Menu.objects.exclude(menuid__in=[11, 9]).filter(menuid__in=list(set(x)), deletemark=1,type=1).order_by(
            'sortnum').values('menuid', 'menucode', 'parentid', 'url', 'menuname', 'icon').distinct()
    return HttpResponse(json.dumps(list(menus)), content_type="application/json")


def apirights(req):
    a = req.GET.get('a')
    if a == 'detail':
        groupid = req.GET.get('groupid')
        haverights = Group.objects.get(groupid=groupid).menulist
        userid = req.session['userid']
        user = User.objects.get(userid=userid)
        allrights = user.usecomp.role.permissions.all()
        menus = allrights.exclude(menuid__in=[11, 9]).order_by(
            'sortnum').values('menuid', 'menucode', 'parentid', 'url', 'menuname', 'icon').distinct()
        if haverights:
            for i in menus:
                if i['menuid'] in haverights:
                    i['checked'] = True
                else:
                    i['checked'] = False
        return HttpResponse(json.dumps(list(menus)), content_type="application/json")
    elif a == 'edit':
        groupid = req.GET.get('groupid')
        data = req.POST.get('data')
        data = json.loads(data)
        rlist = [11, 9]
        for i in data:
            rlist.append(i['id'])
        Group.objects.filter(groupid=groupid).update(
            menulist=list(set(rlist)))
        return JsonResponse({"code": 1})
    elif a == 'have':
        userid = req.session['userid']
        user = User.objects.get(userid=userid)
        allrights = list(user.usecomp.role.permissions.all().values_list('menuid',flat=True))
        return JsonResponse({'code': 1, 'rights': allrights})


def addyh(req):
    userid = req.session['userid']
    user = User.objects.get(userid=userid)
    yhdata = json.loads(req.body.decode('utf-8'))
    troubleid = yhdata['troubleid'] if 'troubleid' in yhdata else ''
    fxsj = yhdata['fxsj']
    yhdd = yhdata['yhdd']
    yhms = yhdata['yhms']
    yhtp = '?'.join(yhdata['yhtp']) if 'yhtp' in yhdata else []
    zghtp = '?'.join(yhdata['zghtp']) if 'zghtp' in yhdata else []
    yhdj = yhdata['yhdj']
    yhpg = yhdata['yhpg'] if 'yhpg' in yhdata else ''
    jclx = yhdata['jclx']
    yhlx = yhdata['yhlx'] if 'yhlx' in yhdata else ''
    yhlxo = yhdata['yhlxo'] if 'yhlxo' in yhdata else ''
    yhlb = yhdata['yhlb'] if 'yhlb' in yhdata else ''
    yyfx = yhdata['yyfx'] if 'yyfx' in yhdata else ''
    zgcs = yhdata['zgcs'] if 'zgcs' in yhdata else ''
    zgbm = yhdata['zgbm'] if 'zgbm' in yhdata else ''
    zgr = yhdata['zgr'] if 'zgr' in yhdata else ''
    zgqx = yhdata['zgqx'] if 'zgqx' in yhdata else ''
    zgms = yhdata['zgms'] if 'zgms' in yhdata else ''
    sybzt = 0
    if troubleid != '':
        a = Trouble.objects.get(troubleid=troubleid)
    else:
        a = Trouble()
    companyid = getcompany(userid)
    a.usecomp = Partment.objects.get(partid=companyid)
    a.fxsj = fxsj
    a.fxbm = user.ubelongpart
    a.fxr = user
    a.yhdd = yhdd
    if 'yhqy' in yhdata:
        if yhdata['yhqy']:
            a.yhqy = Area.objects.get(id=yhdata['yhqy'])
    a.yhms = yhms
    a.yhtp = yhtp
    a.yhnum = 'YH'+time.strftime('%Y%m%d%H%M%S')
    a.yyfx = yyfx
    a.zgcs = zgcs
    a.zgms = zgms
    if yhdj != '':
        a.yhdj = Dickey.objects.get(dickeyid=yhdj)
    if yhpg != '':
        a.yhpg = Dickey.objects.get(dickeyid=yhpg)
    if jclx != '':
        a.jclx = Dickey.objects.get(dickeyid=jclx)
    if yhlxo:
        a.yhlxo = Dickey.objects.get(dickeyid=yhlxo)
    if yhlx != '':
        a.yhlx = Dicclass.objects.get(dicid=yhlx)
    if yhlb != '':
        a.yhlb = Dickey.objects.get(dickeyid=yhlb)
    if a.yhdj.dickeyname == '无隐患' or zgms != '':
        # 直接到待复查
        a.zghtp = zghtp
        a.yhzt = 5
        x = getpgr(userid, user.ubelongpart)
        a.todouser = x
        a.fcr = x
        a.zpr = user
        a.pgr = user
        a.csqrr = user
        a.shr = user
        a.sybzt = 0
        if zgbm and zgr:
            a.zgbm = Partment.objects.get(partid=zgbm)
            a.zgr = User.objects.get(userid=zgr)
        else:
            a.zgbm = a.fxbm
            a.zgr = a.fxr
        a.save()
        m = TroubleAccess(troubleid=a, clr=user, yhzt=0,
                          action='新增隐患已整改', result=1)
        m.save()
        postdict = {
            'touser': 'oPGqkweX75QtLmgehUN-ipR4hcyc',
            'template_id': 'lOuwSE67vZC3ZVFYPZvz2eb7JdFxqx7ysMFkXrYmYh0',
            "miniprogram": {"appid": "wx5c39b569f01c27db", "path": "pages/trouble/accesstrouble?troubleid="+str(a.troubleid)},
            'data': {
                'first': {
                    'value': a.yhdj.dickeyname + '待复查:'
                },
                'keyword1': {
                    'value': a.yhms
                },
                'keyword2': {
                    'value': a.fxsj
                },
                'keyword3': {
                    'value': a.yhdd
                },
                'remark': {
                    'value': '该隐患已完成整改，请及时复查。'
                }
            }
        }
        postdict['touser'] = a.todouser.openid
        send_wechatmsg.delay(postdict)
        yjjs.delay(companyid)
        return JsonResponse({"code": 1, "trouble": a.troubleid, "yhnum": a.yhnum})
    elif zgr != '' and (yyfx == '' or zgcs == ''):
        # 直接到整改措施待上传
        a.zgbm = Partment.objects.get(partid=zgbm)
        a.zgr = User.objects.get(userid=zgr)
        a.zgqx = zgqx
        a.yhzt = 7
        a.todouser = User.objects.get(userid=zgr)
        if a.zgr != user:
            a.fcr = user
        else:
            a.fcr = getpgr(userid, user.ubelongpart.parentid)
        a.pgr = user
        a.zpr = user
        a.shr = user
        a.csqrr = user
        a.sybzt = 0
        a.save()
        m = TroubleAccess(troubleid=a, clr=user, yhzt=0,
                          action='新增隐患并指派整改人', result=1)
        m.save()
        postdict = {
            'touser': 'oPGqkweX75QtLmgehUN-ipR4hcyc',
            'template_id': 'lOuwSE67vZC3ZVFYPZvz2eb7JdFxqx7ysMFkXrYmYh0',
            "miniprogram": {"appid": "wx5c39b569f01c27db", "path": "pages/trouble/accesstrouble?troubleid="+str(a.troubleid)},
            'data': {

                'first': {
                    'value': a.yhdj.dickeyname + '原因分析/整改措施待上传:'
                },
                'keyword1': {
                    'value': a.yhms
                },
                'keyword2': {
                    'value': a.fxsj
                },
                'keyword3': {
                    'value': a.yhdd
                },
                'remark': {
                    'value': '整改期限为'+zgqx+',请您先及时填写原因分析，制定整改措施。'
                }
            }
        }
        postdict['touser'] = a.todouser.openid
        send_wechatmsg.delay(postdict)
        yjjs.delay(companyid)
        return JsonResponse({"code": 1, "trouble": a.troubleid, "yhnum": a.yhnum})
    elif zgr != '' and yyfx != '' and zgcs != '':
        # 到待整改
        a.zgbm = Partment.objects.get(partid=zgbm)
        a.zgr = User.objects.get(userid=zgr)
        a.zgqx = zgqx
        a.yhzt = 3
        a.todouser = User.objects.get(userid=zgr)
        if a.zgr != user:
            a.fcr = user
        else:
            parentpart = user.ubelongpart.parentid
            if parentpart:
                a.fcr = getpgr(userid, user.ubelongpart.parentid)
            else:
                a.fcr = user
        a.shr = user
        a.pgr = user
        a.zpr = user
        a.csqrr = user
        a.sybzt = 0
        a.save()
        m = TroubleAccess(troubleid=a, clr=user, yhzt=0,
                          action='新增隐患并指派整改人', result=1)
        m.save()
        postdict = {
            'touser': 'oPGqkweX75QtLmgehUN-ipR4hcyc',
            'template_id': 'lOuwSE67vZC3ZVFYPZvz2eb7JdFxqx7ysMFkXrYmYh0',
            "miniprogram": {"appid": "wx5c39b569f01c27db", "path": "pages/trouble/accesstrouble?troubleid="+str(a.troubleid)},
            'data': {

                'first': {
                    'value': a.yhdj.dickeyname + '待整改:'
                },
                'keyword1': {
                    'value': a.yhms
                },
                'keyword2': {
                    'value': a.fxsj
                },
                'keyword3': {
                    'value': a.yhdd
                },
                'remark': {
                    'value': '整改期限为'+zgqx+',请您及时完成整改。'
                }
            }
        }
        postdict['touser'] = a.todouser.openid
        send_wechatmsg.delay(postdict)
        yjjs.delay(companyid)
        return JsonResponse({"code": 1, "trouble": a.troubleid, "yhnum": a.yhnum})
    elif zgbm != '' and zgr == '':
        # 到整改部门待评估 指派部门整改
        a.yhzt = 1
        x = getpgr('zpbm', Partment.objects.get(partid=zgbm))
        if x == False:
            return JsonResponse({"code": 101})
        a.todouser = x
        a.shr = x
        a.csqrr = x
        a.fcr = user
        a.pgr = user
        a.zgbm = Partment.objects.get(partid=zgbm)
        a.sybzt = 0
        a.save()
        m = TroubleAccess(troubleid=a, clr=user, yhzt=0,
                          action='新增隐患并指派整改部门', result=1)
        m.save()
        postdict = {
            'touser': 'oPGqkweX75QtLmgehUN-ipR4hcyc',
            'template_id': 'lOuwSE67vZC3ZVFYPZvz2eb7JdFxqx7ysMFkXrYmYh0',
            "miniprogram": {"appid": "wx5c39b569f01c27db", "path": "pages/trouble/accesstrouble?troubleid="+str(a.troubleid)},
            'data': {

                'first': {
                    'value': a.yhdj.dickeyname + '待评估:'
                },
                'keyword1': {
                    'value': a.yhms
                },
                'keyword2': {
                    'value': a.fxsj
                },
                'keyword3': {
                    'value': a.yhdd
                },
                'remark': {
                    'value': '请您及时评估并制定整改通知单。'
                }
            }
        }
        postdict['touser'] = a.todouser.openid
        send_wechatmsg.delay(postdict)
        return JsonResponse({"code": 1, "trouble": a.troubleid, "yhnum": a.yhnum})
    else:
        # 正常流程到待评估
        a.yhzt = 1
        x = getpgr(userid, user.ubelongpart)
        a.pgr = x
        a.todouser = x
        a.sybzt = 0
        a.save()
        m = TroubleAccess(troubleid=a, clr=user, yhzt=0,
                          action='新增隐患', result=1)
        m.save()
        postdict = {
            'touser': 'oPGqkweX75QtLmgehUN-ipR4hcyc',
            'template_id': 'lOuwSE67vZC3ZVFYPZvz2eb7JdFxqx7ysMFkXrYmYh0',
            "miniprogram": {"appid": "wx5c39b569f01c27db", "path": "pages/trouble/accesstrouble?troubleid="+str(a.troubleid)},
            'data': {

                'first': {
                    'value': a.yhdj.dickeyname + '待评估:'
                },
                'keyword1': {
                    'value': a.yhms
                },
                'keyword2': {
                    'value': a.fxsj
                },
                'keyword3': {
                    'value': a.yhdd
                },
                'remark': {
                    'value': '请您及时评估并制定整改通知单。'
                }
            }
        }
        postdict['touser'] = a.todouser.openid
        send_wechatmsg.delay(postdict)
        return JsonResponse({"code": 1, "trouble": a.troubleid, "yhnum": a.yhnum})


def getyh(req):
    if 'userid' in req.session:
        userid = req.session['userid']
        troubleid = req.GET.get('troubleid')
        a = Trouble.objects.filter(troubleid=troubleid).values('sybzt', 'troubleid', 'fxr__userid', 'fxr__name', 'yhms', 'yhzt', 'fxsj', 'tbsj', 'yhlb__dickeyname', 'yhlb__dickeyid', 'todouser__name', 'yhpg__dickeyname', 'yhnum', 'yhdd', 'fxbm__partname', 'yhdj__dickeyname', 'yhdj__dickeyid', 'yhpg__dickeyname', 'yhpg__dickeyid', 'jclx__dickeyname', 'jclx__dickeyid', 'yhlx__dicname',
                                                               'yhlx__dicid', 'yyfx', 'zgcs', 'yhtp', 'zghtp', 'zgms', 'zgbm__partname', 'zgbm__partid', 'zgr__name', 'zgqx', 'fcr__ubelongpart__partname', 'fcr__name', 'shr__ubelongpart__partname', 'shr__name', 'pgr__ubelongpart__partname', 'pgr__name', 'zpr__ubelongpart__partname', 'zpr__name', 'csqrr__ubelongpart__partname', 'csqrr__name', 'shyj', 'fcyj', 'shresult', 'zgbm', 'zgr', 'pgyj', 'yhqy__name', 'yhqy__id')[0]
        # print(a['yhtp'])
        if a['yhtp'] != '':
            a['yhtp'] = a['yhtp'].split('?')
        if a['zghtp'] != '':
            a['zghtp'] = a['zghtp'].split('?')
        for key in a:
            if a[key] == None:
                a[key] = ''
        # print(a['yhtp'])
        return JsonResponse(a)
        # return JsonResponse()
    else:
        return JsonResponse({"code": 0})


def accessyh(req):
    userid = req.session['userid']
    yhdata = json.loads(req.body.decode('utf-8'))
    troubleid = yhdata['troubleid']
    a = Trouble.objects.get(troubleid=troubleid)
    companyid = a.usecomp.partid
    b = User.objects.get(userid=userid)
    shresult = yhdata['shresult']
    if a.yhzt == 5:  # 待复查
        fcyj = yhdata['fcyj']
        if shresult == 'reject':
            a.shresult = 3
            a.yhzt = 3
            a.sybzt = 5
            if a.zgr != None:
                a.todouser = a.zgr
            else:
                a.todouser = a.fxr
            a.fcyj = fcyj
            a.save()
            m = TroubleAccess(troubleid=a, clr=b, yhzt=5,
                              action='复查未通过', opinion=fcyj, result=0)
            m.save()
            postdict = {
                'touser': 'oPGqkweX75QtLmgehUN-ipR4hcyc',
                'template_id': 'lOuwSE67vZC3ZVFYPZvz2eb7JdFxqx7ysMFkXrYmYh0',
                "miniprogram": {"appid": "wx5c39b569f01c27db", "path": "pages/trouble/accesstrouble?troubleid="+str(a.troubleid)},
                'data': {
                    'first': {'value': a.yhdj.dickeyname + '待整改:'},
                    'keyword1': {'value': a.yhms},
                    'keyword2': {'value': a.fxsj},
                    'keyword3': {'value': a.yhdd},
                    'remark': {'value': '您提交的整改结果未通过复查，请重新整改。'}
                }
            }
            postdict['touser'] = a.todouser.openid
            send_wechatmsg.delay(postdict)
            return JsonResponse({"code": 1})
        else:
            a.yhzt = 6
            a.sybzt = 5
            a.todouser = None
            a.fcyj = fcyj
            a.save()
            m = TroubleAccess(troubleid=a, clr=b, yhzt=5,
                              action='整改结果复查通过', opinion=fcyj, result=1)
            m.save()
            objs = Inspect.objects.filter(trouble=a)
            if objs.exists():
                obj = objs[0]
                obj.equipment.state = 1
                obj.equipment.save()
            yjjs.delay(companyid)
            return JsonResponse({"code": 1})
        # elif a.zgr==None and a.zgms=='':#无隐患
        #     a.yhzt=6
        #     a.sybzt=5
        #     a.todouser=None
        #     a.fcyj=fcyj
        #     a.save()
        #     m = TroubleAccess(troubleid=a,clr=b,yhzt=5,action='整改结果复查通过',opinion=fcyj,result=1)
        #     m.save()
        #     yjjs.delay(companyid)
        #     return JsonResponse({"code":1})
        # elif a.zgr==None:#直接整改的
        #     a.yhzt=6
        #     a.sybzt=5
        #     a.todouser=None
        #     a.fcyj=fcyj
        #     a.save()
        #     m=TroubleAccess(troubleid=a,clr=b,yhzt=5,action='整改结果复查通过',opinion=fcyj,result=1)
        #     m.save()
        #     yjjs.delay(companyid)
        #     return JsonResponse({"code":1})

    elif a.yhzt == 3:  # 提交整改后
        if a.sybzt == 4 or a.sybzt == 5:
            a.shresult = 4
        else:
            a.shresult = 1
        if a.shr == a.fcr or a.shr == None:
            a.yhzt = 5
            a.sybzt = 3
            a.todouser = a.fcr
        else:
            a.yhzt = 4
            a.sybzt = 3
            a.todouser = a.shr
        a.zgms = yhdata['zgms']
        a.zghtp = '?'.join(yhdata['zghtp'])
        a.zgsj = datetime.now()
        a.save()
        m = TroubleAccess(troubleid=a, clr=b, yhzt=3,
                          action='提交整改结果', result=1)
        m.save()
        return JsonResponse({"code": 1})
    elif a.yhzt == 4:  # 待审核
        shyj = yhdata['shyj']
        if shresult == 'reject':
            a.shresult = 2
            a.yhzt = 3
            a.sybzt = 4
            a.todouser = a.zgr
            a.shyj = shyj
            a.save()
            m = TroubleAccess(troubleid=a, clr=b, yhzt=4,
                              action='审核未通过', opinion=shyj, result=0)
            m.save()
            postdict = {
                'touser': 'oPGqkweX75QtLmgehUN-ipR4hcyc',
                'template_id': 'lOuwSE67vZC3ZVFYPZvz2eb7JdFxqx7ysMFkXrYmYh0',
                "miniprogram": {"appid": "wx5c39b569f01c27db", "path": "pages/trouble/accesstrouble?troubleid="+str(a.troubleid)},
                'data': {
                    'first': {'value': a.yhdj.dickeyname + '待整改:'},
                    'keyword1': {'value': a.yhms},
                    'keyword2': {'value': a.fxsj},
                    'keyword3': {'value': a.yhdd},
                    'remark': {'value': '您提交的整改结果未通过审核，请重新整改。'}
                }
            }
            postdict['touser'] = a.todouser.openid
            send_wechatmsg.delay(postdict)
            return JsonResponse({"code": 1})
        else:
            a.yhzt = 5
            a.sybzt = 4
            a.todouser = a.fcr
            a.shyj = shyj
            a.save()
            m = TroubleAccess(troubleid=a, clr=b, yhzt=4,
                              action='整改结果审核通过', opinion=shyj, result=1)
            m.save()
            return JsonResponse({"code": 1})
    elif a.yhzt == 1:
        if yhdata['shresult'] == 'reject':
            if 'accept' in yhdata:
                if yhdata['accept'] == 'no':
                    a.shresult = 6
                    a.yhzt = 6
                    a.sybzt = 1
                    a.todouser = None
                    a.pgyj = yhdata['pgyj']
                    a.save()
                    m = TroubleAccess(
                        troubleid=a, clr=a.pgr, yhzt=6, action='未采纳', opinion=yhdata['pgyj'])
                    m.save()
                    postdict = {
                        'touser': 'oPGqkweX75QtLmgehUN-ipR4hcyc',
                        'template_id': 'lOuwSE67vZC3ZVFYPZvz2eb7JdFxqx7ysMFkXrYmYh0',
                        "miniprogram": {"appid": "wx5c39b569f01c27db", "path": "pages/trouble/accesstrouble?troubleid="+str(a.troubleid)},
                        'data': {
                            'first': {'value': a.yhdj.dickeyname + '未被采纳:'},
                            'keyword1': {'value': a.yhms},
                            'keyword2': {'value': a.fxsj},
                            'keyword3': {'value': a.yhdd},
                            'remark': {'value': '请查看未采纳原因'}
                        }
                    }
                    postdict['touser'] = a.fxr.openid
                    send_wechatmsg.delay(postdict)
                    return JsonResponse({"code": 1})
                else:
                    a.shresult = 5
                    a.yhzt = 0
                    a.sybzt = 1
                    a.todouser = a.fxr
                    a.pgyj = yhdata['pgyj']
                    a.save()
                    m = TroubleAccess(
                        troubleid=a, clr=a.pgr, yhzt=0, action='请'+a.fxr.name+'重新填报', result=0)
                    m.save()
                    postdict = {
                        'touser': 'oPGqkweX75QtLmgehUN-ipR4hcyc',
                        'template_id': 'lOuwSE67vZC3ZVFYPZvz2eb7JdFxqx7ysMFkXrYmYh0',
                        "miniprogram": {"appid": "wx5c39b569f01c27db", "path": "pages/trouble/accesstrouble?troubleid="+str(a.troubleid)},
                        'data': {
                            'first': {'value': a.yhdj.dickeyname + '被退回需重新上报:'},
                            'keyword1': {'value': a.yhms},
                            'keyword2': {'value': a.fxsj},
                            'keyword3': {'value': a.yhdd},
                            'remark': {'value': '请查看评估意见并修改后上传。'}
                        }
                    }
                    postdict['touser'] = a.todouser.openid
                    send_wechatmsg.delay(postdict)
                    return JsonResponse({"code": 1})
        elif 'zppg' in yhdata and yhdata['zppg'] == 'yes':
            a.yhzt = 1
            a.sybzt = 1
            # a.yhms=req.POST.get('yhms')
            a.todouser = User.objects.get(userid=yhdata['newr'])
            a.fcr = a.todouser
            a.pgr = a.todouser
            a.save()
            m = TroubleAccess(troubleid=a, clr=b, yhzt=1,
                              action='请'+a.fcr.name+'继续评估和复查', result=1)
            m.save()
            postdict = {
                'touser': 'oPGqkweX75QtLmgehUN-ipR4hcyc',
                'template_id': 'lOuwSE67vZC3ZVFYPZvz2eb7JdFxqx7ysMFkXrYmYh0',
                "miniprogram": {"appid": "wx5c39b569f01c27db", "path": "pages/trouble/accesstrouble?troubleid="+str(a.troubleid)},
                'data': {
                    'first': {'value': a.yhdj.dickeyname + '待评估:'},
                    'keyword1': {'value': a.yhms},
                    'keyword2': {'value': a.fxsj},
                    'keyword3': {'value': a.yhdd},
                    'remark': {'value': '请及时评估该隐患并制定整改通知单。'}
                }
            }
            postdict['touser'] = a.todouser.openid
            send_wechatmsg.delay(postdict)
            return JsonResponse({"code": 1})
        else:
            # print(yhdata['zgcs']=='')
            if yhdata['zgcs'] != '':
                a.yhzt = 3
                a.sybzt = 1
                a.yyfx = yhdata['yyfx']
                a.zgcs = yhdata['zgcs']
                a.yhpg = Dickey.objects.get(dickeyid=yhdata['yhpg'])
                a.yhlx = Dicclass.objects.get(dicid=yhdata['yhlx'])
                a.yhlb = Dickey.objects.get(dickeyid=yhdata['yhlb'])
                a.zgbm = Partment.objects.get(partid=yhdata['zgbm'])
                a.zgr = User.objects.get(userid=yhdata['zgr'])
                a.zgqx = yhdata['zgqx']
                a.todouser = a.zgr
                if a.pgr == None:
                    a.pgr = b
                a.zpr = b
                if a.fcr:
                    pass
                else:
                    a.fcr = b
                a.csqrr = b
                a.shr = b
                a.save()
                m = TroubleAccess(troubleid=a, clr=b, yhzt=1,
                                  action='指派'+a.zgr.name+'整改', result=1)
                m.save()
                postdict = {
                    'touser': 'oPGqkweX75QtLmgehUN-ipR4hcyc',
                    'template_id': 'lOuwSE67vZC3ZVFYPZvz2eb7JdFxqx7ysMFkXrYmYh0',
                    "miniprogram": {"appid": "wx5c39b569f01c27db", "path": "pages/trouble/accesstrouble?troubleid="+str(a.troubleid)},
                    'data': {
                        'first': {'value': a.yhdj.dickeyname + '待整改:'},
                        'keyword1': {'value': a.yhms},
                        'keyword2': {'value': a.fxsj},
                        'keyword3': {'value': a.yhdd},
                        'remark': {'value': '整改期限为'+yhdata['zgqx']+',请您及时完成整改。'}
                    }
                }
                postdict['touser'] = a.todouser.openid
                send_wechatmsg.delay(postdict)
                return JsonResponse({"code": 1})
            else:
                a.yhzt = 7
                a.sybzt = 1
                # a.yhms=req.POST.get('yhms')
                # print(req.POST.get('yhms'))
                a.yhpg = Dickey.objects.get(dickeyid=yhdata['yhpg'])
                a.yhlx = Dicclass.objects.get(dicid=yhdata['yhlx'])
                a.yhlb = Dickey.objects.get(dickeyid=yhdata['yhlb'])
                a.zgbm = Partment.objects.get(partid=yhdata['zgbm'])
                a.zgr = User.objects.get(userid=yhdata['zgr'])
                a.zgqx = yhdata['zgqx']
                a.todouser = a.zgr
                if a.pgr == None:
                    a.pgr = b
                a.zpr = b
                a.csqrr = b
                a.shr = b
                if a.fcr:
                    pass
                else:
                    a.fcr = b
                a.save()
                m = TroubleAccess(troubleid=a, clr=b, yhzt=1,
                                  action='指派'+a.zgr.name+'整改', result=1)
                m.save()
                postdict = {
                    'touser': 'oPGqkweX75QtLmgehUN-ipR4hcyc',
                    'template_id': 'lOuwSE67vZC3ZVFYPZvz2eb7JdFxqx7ysMFkXrYmYh0',
                    "miniprogram": {"appid": "wx5c39b569f01c27db", "path": "pages/trouble/accesstrouble?troubleid="+str(a.troubleid)},
                    'data': {
                        'first': {'value': a.yhdj.dickeyname + '待整改:'},
                        'keyword1': {'value': a.yhms},
                        'keyword2': {'value': a.fxsj},
                        'keyword3': {'value': a.yhdd},
                        'remark': {'value': '整改期限为'+yhdata['zgqx']+',请您及时完成整改。'}
                    }
                }
                postdict['touser'] = a.todouser.openid
                send_wechatmsg.delay(postdict)
                return JsonResponse({"code": 1})
    elif a.yhzt == 7:
        a.yhzt = 2
        a.sybzt = 7
        a.yyfx = yhdata['yyfx']
        a.zgcs = yhdata['zgcs']
        a.todouser = a.zpr
        a.save()
        m = TroubleAccess(troubleid=a, clr=b, yhzt=7,
                          action='制定整改措施/方案', result=1)
        m.save()
        postdict = {
            'touser': 'oPGqkweX75QtLmgehUN-ipR4hcyc',
            'template_id': 'lOuwSE67vZC3ZVFYPZvz2eb7JdFxqx7ysMFkXrYmYh0',
            "miniprogram": {"appid": "wx5c39b569f01c27db", "path": "pages/trouble/accesstrouble?troubleid="+str(a.troubleid)},
            'data': {
                'first': {'value': a.yhdj.dickeyname + '待整改:'},
                'keyword1': {'value': a.yhms},
                'keyword2': {'value': a.fxsj},
                'keyword3': {'value': a.yhdd},
                'remark': {'value': '整改期限为'+a.zgqx.strftime("%Y-%m-%d %H:%M")+',请您先先制定整改措施/方案。'}
            }
        }
        postdict['touser'] = a.todouser.openid
        send_wechatmsg.delay(postdict)
        return JsonResponse({"code": 1})
    elif a.yhzt == 0:
        a.yhzt = 1
        a.todouser = a.pgr
        a.sybzt = 0
        a.save()
        m = TroubleAccess(troubleid=a, clr=a.fxr, yhzt=0,
                          action='重新修改隐患', result=1)
        m.save()
        postdict = {
            'touser': 'oPGqkweX75QtLmgehUN-ipR4hcyc',
            'template_id': 'lOuwSE67vZC3ZVFYPZvz2eb7JdFxqx7ysMFkXrYmYh0',
            "miniprogram": {"appid": "wx5c39b569f01c27db", "path": "pages/trouble/accesstrouble?troubleid="+str(a.troubleid)},
            'data': {

                'first': {
                    'value': a.yhdj.dickeyname + '待评估:'
                },
                'keyword1': {
                    'value': a.yhms
                },
                'keyword2': {
                    'value': a.fxsj
                },
                'keyword3': {
                    'value': a.yhdd
                },
                'remark': {
                    'value': '发现人重新提交隐患，请您及时评估并制定整改通知单。'
                }
            }
        }
        postdict['touser'] = a.todouser.openid
        send_wechatmsg.delay(postdict)
        return JsonResponse({"code": 1})
    elif a.yhzt == 2:
        a.yhzt = 3
        a.sybzt = 2
        a.yyfx = yhdata['yyfx']
        a.zgcs = yhdata['zgcs']
        a.todouser = a.zgr
        a.save()
        m = TroubleAccess(troubleid=a, clr=a.csqrr, yhzt=2,
                          action='确认整改措施', result=1)
        m.save()
        postdict = {
            'touser': 'oPGqkweX75QtLmgehUN-ipR4hcyc',
            'template_id': 'lOuwSE67vZC3ZVFYPZvz2eb7JdFxqx7ysMFkXrYmYh0',
            "miniprogram": {"appid": "wx5c39b569f01c27db", "path": "pages/trouble/accesstrouble?troubleid="+str(a.troubleid)},
            'data': {
                'first': {'value': a.yhdj.dickeyname + '待整改:'},
                'keyword1': {'value': a.yhms},
                'keyword2': {'value': a.fxsj},
                'keyword3': {'value': a.yhdd},
                'remark': {'value': '整改措施已确认,请您及时完成整改。'}
            }
        }
        postdict['touser'] = a.todouser.openid
        send_wechatmsg.delay(postdict)
        return JsonResponse({"code": 1})

def parttree2(req):
    userid = req.session['userid']
    companyid = getcompany(userid)
    list_items = (Partment.objects.filter(partlink__contains=','+companyid+',')).annotate(
        id=F('partid'), parentId=F('parentid'), name=F('partname')).values('id', 'parentId', 'name')
    return HttpResponse(json.dumps(list(list_items)), content_type="application/json")


def getdicclass(req):
    dicid = req.GET.get('dicid')
    a = Dicclass.objects.filter(parentid=dicid).values('dicid', 'dicname')
    str = transstr(a, 'dicid', 'dicname')
    return HttpResponse(str, content_type="application/json")


def getdickey(req):
    userid = req.session['userid']
    companyid = getcompany(userid)
    a = Dickey.objects.filter(dicparent=req.GET.get('dicclass'), deletemark=1)
    a = (a.filter(usecomps__contains=',1,') | a.filter(usecomps__contains=',' +
                                                       companyid+',')).exclude(nousecomps__contains=','+companyid+',')
    a = a.values('dickeyid', 'dicparent__dicname', 'dickeyname',
                 'dicparent__dicid', 'detail').order_by('dickeyid')
    total = a.count()
    if req.GET.get('a') == 'combobox':
        return HttpResponse(transstr(a, 'dickeyid', 'dickeyname'), content_type="application/json")
    else:
        if req.GET.get('dicclass') == '33':
            for i in a:
                objs = Operationspjd.objects.filter(zylx=Dickey.objects.get(
                    dickeyid=i['dickeyid']), usecomp=Partment.objects.get(partid=companyid))
                str = '作业负责人-作业部门-属地部门'
                for x in objs:
                    str = str + '-' + x.jdmc
                i['splcdetail'] = str
            a = a
        return HttpResponse(transjson(total, a), content_type="application/json")


def addtrain(req):
    userid = req.session['userid']
    companyid = getcompany(userid)
    a = Train()
    a.trainname = req.POST.get('trainname')
    a.trainplace = req.POST.get('trainplace')
    a.starttime = req.POST.get('starttime')
    a.usecomp = Partment.objects.get(partid=companyid)
    a.trainlevel = Dicclass.objects.get(dicid=req.POST.get('trainlevel'))
    a.traincontent = Dickey.objects.get(dickeyid=req.POST.get('traincontent'))
    a.manlevel = Dickey.objects.get(dickeyid=req.POST.get('manlevel'))
    a.traintype = Dickey.objects.get(dickeyid=req.POST.get('traintype'))
    a.detailcontent = req.POST.get('detailcontent')
    a.teacher = req.POST.get('teacher', None)
    if req.POST.get('lecturer', None):
        x = User.objects.get(userid=req.POST.get('lecturer'))
        a.lecturer = x
        a.teacher = x.name
    if req.POST.get('trainplan', None):
        a.trainplan = TrainPlan.objects.get(id=req.POST.get('trainplan'))
    a.state = 0
    a.participantnum = req.POST.get('participantnum')
    a.submituser = User.objects.get(userid=userid)
    a.duration = req.POST.get('duration')
    a.trainnum = 'PX'+time.strftime('%Y%m%d%H%M%S')
    a.material = req.POST.get('upfile')
    a.save()
    a.checkqr = makeqr_train(
        'https://safeyun.ctcshe.com/miniprogram/checktrain?trainid='+str(a.trainid))
    a.save()
    plist = req.POST.getlist('trainpart')
    ustr = req.POST.get('participant')
    ulist = ustr.split(',')
    b = []
    for i in ulist:
        x = User.objects.get(userid=i)
        m = Trainuser(train=a, participant=x)
        m.save()
        b.append(x.openid)
    for i in plist:
        a.trainpart.add(Partment.objects.get(partid=i))
    postdict = {
        'touser': '',
        'template_id': 'lOuwSE67vZC3ZVFYPZvz2eb7JdFxqx7ysMFkXrYmYh0',
        'data': {
            'first': {
                'value': a.trainlevel.dicname + '培训通知:'
            },
            'keyword1': {
                'value': a.trainname
            },
            'keyword2': {
                'value': a.starttime
            },
            'keyword3': {
                'value': a.trainplace
            },
            'remark': {
                'value': a.teacher+'授课,时长为'+a.duration+'小时，请您务必参加'
            }
        }
    }
    send_wechatmsgs.delay(postdict, b)
    return JsonResponse({"code": 1})


def adddrill(req):
    userid = req.session['userid']
    companyid = getcompany(userid)
    a = Drill()
    a.drillname = req.POST.get('drillname')
    a.drillplace = req.POST.get('drillplace')
    a.starttime = req.POST.get('starttime')
    a.usecomp = Partment.objects.get(partid=companyid)
    a.drilllevel = Dicclass.objects.get(dicid=req.POST.get('drilllevel'))
    a.drillcontent = Dickey.objects.get(dickeyid=req.POST.get('drillcontent'))
    a.drilltype = Dickey.objects.get(dickeyid=req.POST.get('drilltype'))
    a.detailcontent = req.POST.get('detailcontent')
    if req.POST.get('chief'):
        a.chief = User.objects.get(userid=req.POST.get('chief'))
    a.state = 0
    a.participantnum = req.POST.get('participantnum')
    a.submituser = User.objects.get(userid=userid)
    a.drillnum = 'YL'+time.strftime('%Y%m%d%H%M%S')
    a.save()
    plist = req.POST.getlist('drillpart')
    ustr = req.POST.get('participant')
    ulist = ustr.split(',')
    b = []
    for i in ulist:
        x = User.objects.get(userid=i)
        m = Drilluser(drillid=a, participant=x)
        m.save()
        b.append(x.openid)
    for i in plist:
        a.drillpart.add(Partment.objects.get(partid=i))
    postdict = {
        'touser': 'oPGqkweX75QtLmgehUN-ipR4hcyc',
        'template_id': 'lOuwSE67vZC3ZVFYPZvz2eb7JdFxqx7ysMFkXrYmYh0',
        'data': {
            'first': {
                'value': a.drilllevel.dicname + '演练通知:'
            },
            'keyword1': {
                'value': a.drillname
            },
            'keyword2': {
                'value': a.starttime
            },
            'keyword3': {
                'value': a.drillplace
            },
            'remark': {
                'value': a.chief.name+'为总指挥，请务必参加！'
            }
        }
    }
    send_wechatmsgs.delay(postdict, b)
    return JsonResponse({"code": 1})


def accesstrain(req):
    userid = req.session.get('userid')
    trainid = req.GET.get('trainid')
    detailcontent = req.POST.get('detailcontent')
    pxxg = req.POST.get('pxxg')
    knownum = req.POST.get('knownum')
    duration = req.POST.get('duration')
    upfile = req.POST.get('upfile')
    a = Train.objects.filter(trainid=trainid)
    a.update(detailcontent=detailcontent, knownum=knownum,
             material=upfile, state=1, duration=duration, pxxg=pxxg)
    companyid = getcompany(userid)
    # 绑定考试
    if req.POST.get('examtest'):
        a.update(examtest=ExamTest.objects.get(id=req.POST.get('examtest')))
        for i in Trainuser.objects.filter(train__trainid=trainid):
            objs = ExamTestDetail.objects.filter(
                examtest__id=req.POST.get('examtest'), user=i.participant)
            if objs.exists():
                i.examtestdetail = objs[0]
                i.save()
    yjjs_px.delay(companyid)
    return JsonResponse({"code": 1})


def accessdrill(req):
    drillid = req.GET.get('drillid')
    detailcontent = req.POST.get('detailcontent')
    participantnum = req.POST.get('participantnum')
    knownum = req.POST.get('knownum')
    upfile = req.POST.get('upfile')
    a = Drill.objects.filter(drillid=drillid)
    a.update(detailcontent=detailcontent, participantnum=participantnum,
             knownum=knownum, material=upfile, state=1)
    if req.POST.get('participant'):
        a[0].participant.clear()
        ustr = req.POST.get('participant')
        ulist = ustr.split(',')
        for i in ulist:
            x = User.objects.get(userid=i)
            m = Drilluser(drillid=a[0], participant=x)
            m.save()
    userid = req.session.get('userid')
    companyid = getcompany(userid)
    yjjs_yl.delay(companyid)
    return JsonResponse({"code": 1})


def grouphandle(req):
    if req.GET.get('a') == 'addgrouph':
        return render(req, 'abgroup.html')
    elif req.GET.get('a') == 'delgroup':
        userid = req.session['userid']
        a = Group.objects.get(groupid=req.GET.get('groupid'))
        if User.objects.get(userid=userid).issuper == 1 and a.grouptype not in [1, 2, 3]:
            groupid = req.GET.get('groupid')
            Group.objects.filter(groupid=groupid).delete()
            return JsonResponse({"code": 1})
        else:
            return JsonResponse({"code": 0})
    elif req.GET.get('a') == 'removeuser':
        groupid = req.GET.get('groupid')
        userid = req.GET.get('userid')
        useridx = req.session['userid']
        if User.objects.get(userid=useridx).issuper == 1:
            a = Group.objects.get(groupid=groupid)
            a.users.remove(User.objects.get(userid=userid))
            return JsonResponse({"code": 1})
        else:
            return JsonResponse({"code": 0})
    elif req.GET.get('a') == 'addguser':
        groupid = req.GET.get('groupid')
        users = req.POST.get('users').split(',')
        a = Group.objects.get(groupid=groupid)
        for i in users:
            if User.objects.get(userid=int(i)) not in a.users.all():
                a.users.add(User.objects.get(userid=int(i)))
        return JsonResponse({"code": 1})
    elif req.GET.get('a') == 'list':
        userid = req.session['userid']
        companyid = getcompany(userid)
        a = Group.objects.filter(usecomp__partid=companyid).exclude(
            grouptype=0).order_by('groupid').values('groupid', 'groupname', 'grouptype')
        total = a.count()
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif req.GET.get('a') == 'list2':  # 排除全体用户组
        userid = req.session['userid']
        companyid = getcompany(userid)
        a = Group.objects.filter(usecomp__partid=companyid).exclude(
            grouptype=0).exclude(grouptype=3).order_by('groupid').values('groupid', 'groupname', 'grouptype')
        total = a.count()
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif req.GET.get('a') == 'combobox':
        userid = req.session['userid']
        companyid = getcompany(userid)
        a = Group.objects.filter(usecomp__partid=companyid).exclude(
            grouptype=0).values('groupid', 'groupname')
        keystr = transstr(a, 'groupid', 'groupname')
        return HttpResponse(keystr, content_type="application/json")
    elif req.method == 'POST':
        data = json.loads(req.body.decode('utf-8'))
        userid = req.session['userid']
        companyid = getcompany(userid)
        if data['groupid'] == '':
            a = Group()
            a.groupname = data['groupname']
            a.usecomp = Partment.objects.get(partid=companyid)
            a.save()
            return JsonResponse({"code": 1})
        else:
            return JsonResponse({"code": 0})


def troublehandle(req):
    a = req.GET.get('a')
    if a == 'detail':
        troubleid = req.GET.get('troubleid')
        a = Trouble.objects.filter(troubleid=troubleid)
        x = a.values('yhnum', 'fxr__name', 'yhms', 'yhzt', 'fxsj', 'tbsj', 'yhlb__dickeyname', 'yhpg__dickeyname', 'yhdd', 'fxbm__partname', 'yhdj__dickeyname', 'yhpg__dickeyname',
                     'jclx__dickeyname', 'yhlx__dicname', 'yyfx', 'zgcs', 'yhtp', 'zghtp', 'zgms', 'zgbm__partname', 'zgr__name', 'zgqx', 'yhqy__name', 'yhqy__id')[0]
        b = TroubleAccess.objects.filter(troubleid=a[0]).order_by(
            'accesssj').values('clr__name', 'opinion', 'action', 'accesssj')
        x['lcxq'] = list(b)
        if x['yhtp'] != '':
            x['yhtp'] = x['yhtp'].split('?')
        else:
            x['yhtp'] == []
        if x['zghtp'] != '':
            x['zghtp'] = x['zghtp'].split('?')
        else:
            x['zghtp'] == []
        for key in x:
            if x[key] == None:
                x[key] = ''
        return HttpResponse(json.dumps(x, cls=MyEncoder), content_type="application/json")
    elif a == 'detailhtml':
        troubleid = req.GET.get('troubleid')
        return render(req, 'troubledetail.html', {'troubleid': troubleid})
    elif a == 'todonum':
        todonum = Trouble.objects.filter(todouser=User.objects.get(
            userid=req.session['userid'])).exclude(deletemark=0).count()
        return JsonResponse({'code': 1, 'todonum': todonum})
    elif a == 'exportword':
        troubleid = req.GET.get('troubleid')
        v = exportdoc('yh', troubleid)
        return JsonResponse({"code": 1, 'downloadurl': v})
    elif a == 'exportexcel':
        userid = req.session['userid']
        companyid = getcompany(userid)
        a = Trouble.objects.filter(
            usecomp=Partment.objects.get(partid=companyid), deletemark=1)
        yhzt = req.GET.get('yhzt')
        yhlx = req.GET.get('yhlx')
        yhlb = req.GET.get('yhlb')
        jclx = req.GET.get('jclx')
        yhpg = req.GET.get('yhpg')
        fxbm = req.GET.get('fxbm')
        fxr = req.GET.get('fxr')
        qssj = req.GET.get('qssj')
        jssj = req.GET.get('jssj')
        zgbm = req.GET.get('zgbm')
        fxrname = req.GET.get('fxrname',None)
        if yhzt != '' and yhzt != None:
            a = a.filter(yhzt=yhzt)
        if yhlx:
            a = a.filter(yhlx__dicid=yhlx)
        if yhlb:
            a = a.filter(yhlb__dickeyid=yhlb)
        if jclx:
            a = a.filter(jclx__dickeyid=jclx)
        if yhpg:
            a = a.filter(yhpg__dickeyid=yhpg)
        if fxbm or fxr:
            if fxr:
                a = a.filter(fxr__userid=fxr)
            elif fxbm:
                parts = Partment.objects.filter(
                    partlink__contains=','+str(fxbm)+',') | Partment.objects.filter(partid=fxbm)
                a = a.filter(fxbm__in=parts)
        if qssj:
            a = a.filter(fxsj__gte=qssj)
        if jssj:
            a = a.filter(fxsj__lte=jssj)
        if zgbm:
            parts = Partment.objects.filter(
                partlink__contains=','+str(zgbm)+',') | Partment.objects.filter(partid=zgbm)
            a = a.filter(Q(zgbm__in=parts) | Q(fxbm__in=parts, zgbm=None))
        if fxrname:
            a = a.filter(fxr__name=fxrname)
        res = exportxlsx('yh', a)
        return res
    elif a == 'del':
        userid = req.session['userid']
        if User.objects.get(userid=userid).issuper == 1:
            a = Trouble.objects.get(troubleid=req.POST.get('troubleid'))
            a.deletemark = 0
            a.save()
            return JsonResponse({"code": 1})
        else:
            a = Trouble.objects.get(troubleid=req.POST.get('troubleid'))
            b = TroubleAccess.objects.filter(
                troubleid__troubleid=req.POST.get('troubleid')).count()
            if b == 1 and a.fxr.userid == userid:
                a.deletemark = 0
                a.save()
                return JsonResponse({"code": 1})
            else:
                return JsonResponse({"code": 0})
    elif a == 'listtodo':
        userid = req.session['userid']
        a = Trouble.objects.filter(todouser=User.objects.get(
            userid=userid)).exclude(deletemark=0)
        total = a.count()
        startnum, endnum = fenye(req)
        obj = a.order_by('-fxsj')[startnum:endnum].values('troubleid', 'fxr__userid', 'fxr__name', 'yhms', 'yhzt', 'fxsj', 'tbsj',
                                                          'yhlb__dickeyname', 'todouser__name', 'todouser__userid', 'yhpg__dickeyname', 'yhnum', 'yhdj__dickeyname', 'shresult', 'zgqx')
        return HttpResponse(transjson(total, obj), content_type="application/json")
    elif a == 'listself':
        userid = req.session['userid']
        a = Trouble.objects.filter(fxr__userid=userid).exclude(deletemark=0)
        total = a.count()
        startnum, endnum = fenye(req)
        obj = a.order_by('-fxsj')[startnum:endnum].values('troubleid', 'fxr__userid', 'fxr__name', 'yhms', 'yhzt', 'fxsj', 'tbsj',
                                                          'yhlb__dickeyname', 'todouser__name', 'todouser__userid', 'yhpg__dickeyname', 'yhnum', 'yhdj__dickeyname', 'shresult', 'zgqx')
        return HttpResponse(transjson(total, obj), content_type="application/json")
    elif a == 'listall':
        userid = req.session['userid']
        companyid = getcompany(userid)
        a = Trouble.objects.filter(usecomp=Partment.objects.get(
            partid=companyid)).exclude(deletemark=0)
        yhzt = req.GET.get('yhzt')
        yhlx = req.GET.get('yhlx')
        yhlb = req.GET.get('yhlb')
        jclx = req.GET.get('jclx')
        yhpg = req.GET.get('yhpg')
        fxbm = req.GET.get('fxbm')
        fxr = req.GET.get('fxr')
        qssj = req.GET.get('qssj')
        jssj = req.GET.get('jssj')
        yhqy = req.GET.get('yhqy')
        zgbm = req.GET.get('zgbm')
        fxrname = req.GET.get('fxrname',None)
        if yhzt != '' and yhzt != None:
            a = a.filter(yhzt=yhzt)
        if yhlx:
            a = a.filter(yhlx__dicid=yhlx)
        if yhlb:
            a = a.filter(yhlb__dickeyid=yhlb)
        if jclx:
            a = a.filter(jclx__dickeyid=jclx)
        if yhpg:
            a = a.filter(yhpg__dickeyid=yhpg)
        if fxbm or fxr:
            if fxr:
                a = a.filter(fxr__userid=fxr)
            elif fxbm:
                parts = Partment.objects.filter(
                    partlink__contains=','+str(fxbm)+',') | Partment.objects.filter(partid=fxbm)
                a = a.filter(fxbm__in=parts)
        if qssj:
            a = a.filter(fxsj__gte=qssj)
        if jssj:
            a = a.filter(fxsj__lte=jssj)
        if yhqy:
            a = a.filter(yhqy__id=yhqy)
        if zgbm:
            parts = Partment.objects.filter(
                partlink__contains=','+str(zgbm)+',') | Partment.objects.filter(partid=zgbm)
            a = a.filter(Q(zgbm__in=parts) | Q(fxbm__in=parts, zgbm=None))
        if fxrname:
            a = a.filter(fxr__name__contains=fxrname)
        total = a.count()
        startnum, endnum = fenye(req)
        obj = a.order_by('-fxsj')[startnum:endnum].values('troubleid', 'fxr__userid', 'fxr__name', 'yhms', 'yhzt', 'fxsj', 'tbsj',
                                                          'yhlb__dickeyname', 'todouser__name', 'todouser__userid', 'yhpg__dickeyname', 'yhnum', 'yhdj__dickeyname', 'shresult', 'zgqx')
        return HttpResponse(transjson(total, obj), content_type="application/json")
    elif a == 'listsearch':
        userid = req.session['userid']
        companyid = getcompany(userid)
        a = Trouble.objects.filter(usecomp=Partment.objects.get(
            partid=companyid)).exclude(deletemark=0)
        yhzt = req.GET.get('yhzt')
        yhlx = req.GET.get('yhlx')
        yhlb = req.GET.get('yhlb')
        jclx = req.GET.get('jclx')
        yhpg = req.GET.get('yhpg')
        fxbm = req.GET.get('fxbm')
        fxr = req.GET.get('fxr')
        qssj = req.GET.get('qssj')
        jssj = req.GET.get('jssj')
        yhqy = req.GET.get('yhqy')
        zgbm = req.GET.get('zgbm')
        fxrname = req.GET.get('fxrname',None)
        if yhzt != '' and yhzt != None:
            a = a.filter(yhzt=yhzt)
        if yhlx:
            a = a.filter(yhlx__dicid=yhlx)
        if yhlb:
            a = a.filter(yhlb__dickeyid=yhlb)
        if jclx:
            a = a.filter(jclx__dickeyid=jclx)
        if yhpg:
            a = a.filter(yhpg__dickeyid=yhpg)
        if fxbm or fxr:
            if fxr:
                a = a.filter(fxr__userid=fxr)
            elif fxbm:
                parts = Partment.objects.filter(
                    partlink__contains=','+str(fxbm)+',') | Partment.objects.filter(partid=fxbm)
                a = a.filter(fxbm__in=parts)
        if qssj:
            a = a.filter(fxsj__gte=qssj)
        if jssj:
            a = a.filter(fxsj__lte=jssj)
        if yhqy:
            a = a.filter(yhqy__id=yhqy)
        if zgbm:
            parts = Partment.objects.filter(
                partlink__contains=','+str(zgbm)+',') | Partment.objects.filter(partid=zgbm)
            a = a.filter(Q(zgbm__in=parts) | Q(fxbm__in=parts, zgbm=None))
        if fxrname:
            a = a.filter(fxr__name__contains=fxrname)
        total = a.count()
        startnum, endnum = fenye(req)
        obj = a.order_by('-fxsj')[startnum:endnum].values('troubleid', 'fxr__userid', 'fxr__name', 'yhms', 'yhzt', 'fxsj', 'tbsj', 'yhlb__dickeyname',
                                                          'todouser__name', 'yhpg__dickeyname', 'yhnum', 'yhdj__dickeyname', 'shresult', 'zgqx', 'yhtp', 'zghtp', 'todouser__userid')
        return HttpResponse(transjson(total, obj), content_type="application/json")
    
    elif a == 'listarea':
        userid = req.session['userid']
        companyid = getcompany(userid)
        a = Trouble.objects.filter(
            usecomp__partid=companyid, deletemark=1).exclude(yhzt=6)
        yhqy = req.GET.get('yhqy')
        if yhqy:
            a = a.filter(yhqy__id=yhqy)
        total = a.count()
        startnum, endnum = fenye(req)
        obj = a.order_by('-fxsj')[startnum:endnum].values('troubleid', 'fxr__userid', 'fxr__name', 'yhms', 'yhzt', 'fxsj', 'tbsj',
                                                          'yhlb__dickeyname', 'todouser__name', 'yhpg__dickeyname', 'yhnum', 'yhdj__dickeyname', 'shresult', 'zgqx', 'yhtp', 'zghtp')
        return HttpResponse(transjson(total, obj), content_type="application/json")

# 图表查询


def charthandle(req):
    userid = req.session['userid']
    companyid = getcompany(userid)
    if req.GET.get('a') == 'yjycqst':
        yjyc_vl = Yjyc.objects.filter(usecomp__partid=companyid).order_by(
            '-buildtime')[:12].values('year', 'month', 'yjz', 'ycz')
        return HttpResponse(transjson(yjyc_vl.count(), yjyc_vl), content_type="application/json")
    elif req.GET.get('a') == 'yjycz':
        year = int(req.GET.get('year'))
        month = int(req.GET.get('month'))
        objs = Yjyc.objects.filter(
            usecomp__partid=companyid, year=year, month=month)
        if objs.exists():
            nowyjz = objs[0].yjz
            nowycz = objs[0].ycz
            return JsonResponse({'code': 1, 'yjz': nowyjz, 'ycz': nowycz})
        else:
            return JsonResponse({'code': 0})
    elif req.GET.get('a') == 'yjycznow':
        first_day, first_day_of_next_month = gettime()
        year = first_day.year
        month = first_day.month
        a = Yjyc.objects.get_or_create(usecomp__partid=companyid, year=year, month=month, defaults={
                                       'usecomp': Partment.objects.get(partid=companyid), 'year': year, 'month': month})[0]
        nowyjz = a.yjz
        nowycz = a.ycz
        return JsonResponse({'code': 1, 'yjz': nowyjz, 'ycz': nowycz})
    elif req.GET.get('a') == 'yhlbt':  # 隐患类别图
        if req.GET.get('year'):
            year = int(req.GET.get('year'))
            month = int(req.GET.get('month'))
            if req.GET.get('part'):
                partid = req.GET.get('part')
            else:
                partid = companyid
            first_day, first_day_of_next_month = gettime(
                datetime(year, month, 1))
            children = []
            a = Trouble.objects.filter(deletemark=1).filter(
                Q(fxbm=partid) | Q(fxbm__partlink__contains=',' + str(partid) + ','))
            for i in Dickey.objects.filter(dicparent__dicid=16):
                y = a.filter(yhlb=i, fxsj__range=(
                    first_day, first_day_of_next_month)).count()
                children.append({'name': i.dickeyname, 'value': y})
            children2 = []
            for i in Dickey.objects.filter(dicparent__dicid=17):
                y = a.filter(yhlb=i, fxsj__range=(
                    first_day, first_day_of_next_month)).count()
                children2.append({'name': i.dickeyname, 'value': y})
            value = [{'name': '现场管理', 'children': children},
                     {'name': '基础管理', 'children': children2}]
            return JsonResponse({'code': 1, 'value': value})
        else:
            children = []
            a = Trouble.objects.filter(usecomp__partid=companyid, deletemark=1)
            if req.GET.get('qssj'):
                a = a.filter(fxsj__gte=req.GET.get('qssj'))
            if req.GET.get('jssj'):
                a = a.filter(fxsj__lte=req.GET.get('jssj'))
            if req.GET.get('fxbm'):
                parts = Partment.objects.filter(partlink__contains=',' + req.GET.get(
                    'fxbm') + ',') | Partment.objects.filter(partid=req.GET.get('fxbm'))
                a = a.filter(fxbm__in=parts)
            for i in Dickey.objects.filter(dicparent__dicid=16):
                y = a.filter(yhlb=i).count()
                children.append({'name': i.dickeyname, 'value': y})
            children2 = []
            for i in Dickey.objects.filter(dicparent__dicid=17):
                y = a.filter(yhlb=i).count()
                children2.append({'name': i.dickeyname, 'value': y})
            value = [{'name': '现场管理', 'children': children},
                     {'name': '基础管理', 'children': children2}]
            return JsonResponse({'code': 1, 'value': value})
    elif req.GET.get('a') == 'yhpgt':
        if req.GET.get('year'):
            year = int(req.GET.get('year'))
            month = int(req.GET.get('month'))
            if req.GET.get('part'):
                partid = req.GET.get('part')
            else:
                partid = companyid
            parts = Partment.objects.filter(Q(partid=partid) | Q(
                partlink__contains=',' + str(partid) + ','))
            a = Trouble.objects.filter(deletemark=1, fxbm__in=parts)
            value = []
            key = []
            first_day, first_day_of_next_month = gettime(
                datetime(year, month, 1))
            for i in Dickey.objects.filter(dicparent__dicid=19):
                x = i.dickeyname
                y = a.filter(yhpg=i, fxsj__range=(
                    first_day, first_day_of_next_month)).count()
                key.append(x)
                value.append({'value': y, 'name': x})
            return JsonResponse({'code': 1, 'key': key, 'value': value})
        else:
            a = Trouble.objects.filter(usecomp__partid=companyid, deletemark=1)
            if req.GET.get('qssj'):
                a = a.filter(fxsj__gte=req.GET.get('qssj'))
            if req.GET.get('jssj'):
                a = a.filter(fxsj__lte=req.GET.get('jssj'))
            if req.GET.get('fxbm'):
                parts = Partment.objects.filter(partlink__contains=',' + req.GET.get(
                    'fxbm') + ',') | Partment.objects.filter(partid=req.GET.get('fxbm'))
                a = a.filter(fxbm__in=parts)
            value = []
            key = []
            for i in Dickey.objects.filter(dicparent__dicid=19):
                x = i.dickeyname
                y = a.filter(yhpg=i).count()
                key.append(x)
                value.append({'value': y, 'name': x})
            return JsonResponse({'code': 1, 'key': key, 'value': value})
    elif req.GET.get('a') == 'pxjbt':
        year = int(req.GET.get('year'))
        month = int(req.GET.get('month'))
        if req.GET.get('part'):
            partid = req.GET.get('part')
        else:
            partid = companyid
        parts = Partment.objects.filter(Q(partid=partid) | Q(
            partlink__contains=',' + str(partid) + ','))
        first_day, first_day_of_next_month = gettime(datetime(year, month, 1))
        a = Train.objects.filter(deletemark=1, trainpart__in=parts, state=1)
        value = []
        key = []
        for i in Dicclass.objects.filter(parentid__dicid=4):
            x = i.dicname
            y = a.filter(trainlevel=i, starttime__range=(
                first_day, first_day_of_next_month)).count()
            key.append(x)
            value.append({'value': y, 'name': x})
        return JsonResponse({'code': 1, 'key': key, 'value': value})
    elif req.GET.get('a') == 'yllxt':  # 演练类型饼图
        year = int(req.GET.get('year'))
        month = int(req.GET.get('month'))
        if req.GET.get('part'):
            partid = req.GET.get('part')
        else:
            partid = companyid
        parts = Partment.objects.filter(Q(partid=partid) | Q(
            partlink__contains=',' + str(partid) + ','))
        first_day, first_day_of_next_month = gettime(datetime(year, month, 1))
        a = Drill.objects.filter(drillpart__in=parts, deletemark=1, state=1)
        value = []
        key = []
        for i in Dickey.objects.filter(dicparent__dicid=12):
            x = i.dickeyname
            y = a.filter(drilltype=i, starttime__range=(
                first_day, first_day_of_next_month)).count()
            key.append(x)
            value.append({'value': y, 'name': x})
        return JsonResponse({'code': 1, 'key': key, 'value': value})
    elif req.GET.get('a') == 'yjb':  # 某月各预警指数表
        year = int(req.GET.get('year'))
        month = int(req.GET.get('month'))
        a = Yjyc.objects.filter(
            usecomp__partid=companyid, year=year, month=month)
        data = a.values('drillvalue', 'trainvalue', 'troublevalue',
                        'observevalue', 'missvalue', 'yjz')[0]
        return JsonResponse({'code': 1, 'data': [{'name': '预警值', 'score': data.pop('yjz')}, {'name': '事故隐患', 'score': data.pop('troublevalue')}, {'name': '教育培训', 'score': data.pop('trainvalue')}, {'name': '应急演练', 'score': data.pop('drillvalue')}, {'name': '行为观察', 'score': data.pop('observevalue')}, {'name': '未遂事件', 'score': data.pop('missvalue')}]})
    elif req.GET.get('a') == 'yjhbfx':  # 预警环比分析
        year = int(req.GET.get('year'))
        month = int(req.GET.get('month'))
        if month-1 < 1:
            bmonth = 12
            byear = year-1
        else:
            bmonth = month-1
            byear = year
        a = Yjyc.objects.filter(usecomp__partid=companyid)
        data = {}
        nmonthyjz = a.filter(year=year, month=month)[0].yjz
        bmonthyjz = a.filter(year=byear, month=bmonth)[0].yjz
        return JsonResponse({'code': 1, 'data': [{'month': month, 'yjz': nmonthyjz}, {'month': bmonth, 'yjz': bmonthyjz}]})
    elif req.GET.get('a') == 'yhfxbmb':  # 隐患发现部门分布表
        year = int(req.GET.get('year'))
        month = int(req.GET.get('month'))
        if req.GET.get('part'):
            partid = req.GET.get('part')
        else:
            partid = companyid
        first_day, first_day_of_next_month = gettime(datetime(year, month, 1))
        alist = []
        for i in (Partment.objects.filter(Q(partid=partid) | Q(parentid__partid=partid))).order_by('partid'):
            objs = Trouble.objects.filter(deletemark=1)
            x = (objs.filter(fxbm=i) | objs.filter(fxbm__partlink__contains=',' +
                                                   str(i.partid)+',')).filter(fxsj__range=(first_day, first_day_of_next_month))
            a = x.count()
            b = i.partname
            c = x.exclude(yhzt=6).count()
            alist.append({'partname': b, 'yhnum': a, 'nonum': c})
        return JsonResponse({'code': 1, 'data': alist})
    elif req.GET.get('a') == 'pxbmb':  # 培训部门分布表
        year = int(req.GET.get('year'))
        month = int(req.GET.get('month'))
        first_day, first_day_of_next_month = gettime(datetime(year, month, 1))
        alist = []
        if req.GET.get('part'):
            partid = req.GET.get('part')
        else:
            partid = companyid
        for i in Partment.objects.filter(Q(partid=partid) | Q(parentid__partid=partid)).order_by('partid'):
            parts = Partment.objects.filter(Q(partid=i.partid)|Q(partlink__contains=','+str(i.partid)+','))
            x = Train.objects.filter(trainpart__in=parts, state=1, deletemark=1, starttime__range=(
                first_day, first_day_of_next_month))
            b = i.partname
            c = x.count()
            d = x.filter(trainlevel__dicid=5).count()
            e = x.filter(trainlevel__dicid=6).count()
            f = x.filter(trainlevel__dicid=7).count()
            g = x.filter(trainlevel__dicid=42).count()
            alist.append({'partname': b, 'pxnum': c, 'gsjnum': d,
                          'cjjnum': e, 'bzjnum': f, 'fcjnum': g})
        return JsonResponse({'code': 1, 'data': alist})
    elif req.GET.get('a') == 'ylbmb':  # 演练部门分布表
        year = int(req.GET.get('year'))
        month = int(req.GET.get('month'))
        if req.GET.get('part'):
            partid = req.GET.get('part')
        else:
            partid = companyid
        first_day, first_day_of_next_month = gettime(datetime(year, month, 1))
        alist = []
        for i in Partment.objects.filter(Q(partid=partid) | Q(parentid__partid=partid)).order_by('partid'):
            parts = Partment.objects.filter(Q(partid=i.partid)|Q(partlink__contains=','+str(i.partid)+','))
            x = Drill.objects.filter(drillpart__in=parts, state=1, deletemark=1, starttime__range=(
                first_day, first_day_of_next_month))
            b = i.partname
            c = x.count()
            d = x.filter(drilllevel__dicid=20).count()
            e = x.filter(drilllevel__dicid=21).count()
            f = x.filter(drilllevel__dicid=22).count()
            alist.append({'partname': b, 'ylnum': c,
                          'gsjnum': d, 'cjjnum': e, 'bzjnum': f})
        return JsonResponse({'code': 1, 'data': alist})
    elif req.GET.get('a') == 'yhqst':  # 隐患趋势图
        x_s = Yjyc.objects.filter(
            usecomp__partid=companyid).order_by('buildtime')
        objs = Trouble.objects.filter(deletemark=1, usecomp__partid=companyid)
        if req.GET.get('fxbm'):
            parts = Partment.objects.filter(partlink__contains=',' + req.GET.get(
                'fxbm') + ',') | Partment.objects.filter(partid=req.GET.get('fxbm'))
            objs = objs.filter(fxbm__in=parts)
        data = {}
        data['现场管理类'] = []
        data['基础管理类'] = []
        data['全部'] = []
        data['时间轴'] = []
        for i in x_s:
            first_day, first_day_of_next_month = gettime(
                datetime(i.year, i.month, 1))
            totalobj = objs.filter(fxsj__range=(
                first_day, first_day_of_next_month))
            num = totalobj.count()
            xcglnum = totalobj.filter(yhlx__dicid=16).count()
            jcglnum = totalobj.filter(yhlx__dicid=17).count()
            data['全部'].append(num)
            data['现场管理类'].append(xcglnum)
            data['基础管理类'].append(jcglnum)
            data['时间轴'].append(str(i.year)+'-'+str(i.month))
        return JsonResponse(data, safe=False)
    elif req.GET.get('a') == 'gzbqst':  # 各指标趋势图
        x_s = Yjyc.objects.filter(
            usecomp__partid=companyid).order_by('buildtime')
        yhobjs = Trouble.objects.filter(
            deletemark=1, usecomp__partid=companyid)
        pxobjs = Train.objects.filter(deletemark=1, usecomp__partid=companyid)
        ylobjs = Drill.objects.filter(deletemark=1, usecomp__partid=companyid)
        gcobjs = Observe.objects.filter(
            deletemark=1, usecomp__partid=companyid)
        wsobjs = Miss.objects.filter(deletemark=1, usecomp__partid=companyid)
        data = {}
        data['隐患'] = []
        data['培训'] = []
        data['演练'] = []
        data['观察'] = []
        data['事件'] = []
        data['时间轴'] = []
        for i in x_s:
            first_day, first_day_of_next_month = gettime(
                datetime(i.year, i.month, 1))
            yhnum = yhobjs.filter(fxsj__range=(
                first_day, first_day_of_next_month)).count()
            pxnum = pxobjs.filter(starttime__range=(
                first_day, first_day_of_next_month)).count()
            ylnum = ylobjs.filter(starttime__range=(
                first_day, first_day_of_next_month)).count()
            gcnum = gcobjs.filter(looktime__range=(
                first_day, first_day_of_next_month)).count()
            wsnum = wsobjs.filter(misstime__range=(
                first_day, first_day_of_next_month)).count()
            data['隐患'].append(yhnum)
            data['培训'].append(pxnum)
            data['演练'].append(ylnum)
            data['观察'].append(gcnum)
            data['事件'].append(wsnum)
            data['时间轴'].append(str(i.year)+'-'+str(i.month))
        return JsonResponse(data, safe=False)
    elif req.GET.get('a') == 'yhztt':  # 隐患状态图
        objs = Trouble.objects.filter(deletemark=1, usecomp__partid=companyid)
        if req.GET.get('qssj'):
            objs = objs.filter(fxsj__gte=req.GET.get('qssj'))
        if req.GET.get('jssj'):
            objs = objs.filter(fxsj__lte=req.GET.get('jssj'))
        if req.GET.get('fxbm'):
            parts = Partment.objects.filter(partlink__contains=',' + req.GET.get(
                'fxbm') + ',') | Partment.objects.filter(partid=req.GET.get('fxbm'))
            objs = objs.filter(fxbm__in=parts)
        ztdict = {'待新增': 0, '待评估': 1, '措施待提交': 7,
                  '措施待确认': 2, '待整改': 3, '待审核': 4, '待复查': 5}
        ztnumli = []
        for key in ztdict:
            objnum = objs.filter(yhzt=ztdict[key]).count()
            objdict = {'value': objnum, 'name': key}
            ztnumli.append(objdict)
        return JsonResponse(ztnumli, safe=False)
    elif req.GET.get('a') == 'gcbmb':  # 观察部门分布表
        year = int(req.GET.get('year'))
        month = int(req.GET.get('month'))
        first_day, first_day_of_next_month = gettime(datetime(year, month, 1))
        a = Observe.objects.filter(deletemark=1, looktime__range=(
            first_day, first_day_of_next_month))
        alist = []
        if req.GET.get('part'):
            partid = req.GET.get('part')
        else:
            partid = companyid
        for i in Partment.objects.filter(Q(partid=partid) | Q(parentid__partid=partid)).order_by('partid'):
            y = 0
            for m in Partment.objects.filter(partlink__contains=','+str(i.partid)+',') | Partment.objects.filter(partid=i.partid):
                y = y + a.filter(lookpart=m).count()
            b = i.partname
            c = y
            alist.append({'partname': b, 'gcnum': c})
        return JsonResponse({'code': 1, 'data': alist})
    elif req.GET.get('a') == 'wsbmb':  # 未遂部门分布表
        year = int(req.GET.get('year'))
        month = int(req.GET.get('month'))
        first_day, first_day_of_next_month = gettime(datetime(year, month, 1))
        a = Miss.objects.filter(deletemark=1, misstime__range=(
            first_day, first_day_of_next_month))
        alist = []
        if req.GET.get('part'):
            partid = req.GET.get('part')
        else:
            partid = companyid
        for i in Partment.objects.filter(Q(partid=partid) | Q(parentid__partid=partid)).order_by('partid'):
            y = 0
            for m in Partment.objects.filter(partlink__contains=','+str(i.partid)+',') | Partment.objects.filter(partid=i.partid):
                y = y + a.filter(misspart=m).count()
            b = i.partname
            c = y
            alist.append({'partname': b, 'wsnum': c})
        return JsonResponse({'code': 1, 'data': alist})
    elif req.GET.get('a') == 'gclxt':  # 观察类型饼图
        year = int(req.GET.get('year'))
        month = int(req.GET.get('month'))
        first_day, first_day_of_next_month = gettime(datetime(year, month, 1))
        if req.GET.get('part'):
            partid = req.GET.get('part')
        else:
            partid = companyid
        parts = Partment.objects.filter(Q(partid=partid) | Q(
            partlink__contains=',' + str(partid) + ','))
        a = Observe.objects.filter(lookpart__in=parts, deletemark=1, looktime__range=(
            first_day, first_day_of_next_month))
        value = []
        key = []
        for i in Dicclass.objects.filter(parentid__dicid=23):
            x = i.dicname
            y = Unsafes.objects.filter(observe__in=a, unsafedicclass=i).count()
            key.append(x)
            value.append({'value': y, 'name': x})
        return JsonResponse({'code': 1, 'key': key, 'value': value})


def apiriskas(req):
    userid = req.session['userid']
    companyid = getcompany(userid)
    if req.GET.get('a') == 'fxdlxt':  # 风险点类型图
        objs = RiskAct.objects.filter(usecomp__partid=companyid)
        if req.GET.get('zrbm', None):
            partid = req.GET.get('zrbm')
            objs = objs.filter(zrbm__partid=partid)
        legendData = []
        seriesData = []
        for i in Dickey.objects.filter(dicparent__dicid=53):
            legendData.append(i.dickeyname)
            seriesData.append({'value': objs.filter(
                type=i).count(), 'name': i.dickeyname})
        return JsonResponse({'code': 1, 'legendData': legendData, 'seriesData': seriesData})
    elif req.GET.get('a') == 'fxdjbt':  # 风险点级别图
        objs = RiskAct.objects.filter(usecomp__partid=companyid)
        if req.GET.get('zrbm', None):
            partid = req.GET.get('zrbm')
            objs = objs.filter(zrbm__partid=partid)
        legendData = ['低风险', '一般风险', '较大风险', '重大风险']
        seriesData = []
        for i in legendData:
            seriesData.append(
                {'value': objs.filter(level=i).count(), 'name': i})
        return JsonResponse({'code': 1, 'legendData': legendData, 'seriesData': seriesData})
    elif req.GET.get('a') == 'fxjbt':  # 风险级别图
        objs = Risk.objects.filter(usecomp__partid=companyid)
        if req.GET.get('zrbm', None):
            partid = req.GET.get('zrbm')
            objs = objs.filter(riskact__zrbm__partid=partid)
        legendData = ['低风险', '一般风险', '较大风险', '重大风险']
        seriesData = []
        for i in legendData:
            seriesData.append(
                {'value': objs.filter(level=i).count(), 'name': i})
        return JsonResponse({'code': 1, 'legendData': legendData, 'seriesData': seriesData})
    elif req.GET.get('a') == 'fxdqyt':  # 风险点区域图
        objs = RiskAct.objects.filter(usecomp__partid=companyid)
        objs2 = Risk.objects.filter(usecomp__partid=companyid)
        if req.GET.get('zrbm', None):
            partid = req.GET.get('zrbm')
            objs = objs.filter(zrbm__partid=partid)
            objs2 = objs2.filter(riskact__zrbm__partid=partid)
        xAxisData = []
        series = []
        #areas = Area.objects.filter(usecomp__partid=companyid,deletemark=1)
        #riskactareas = Area.objects.filter(usecomp__partid=companyid,deletemark=1).annotate(num=Count('riskactarea')).filter(num__gt=0).order_by('-num')
        riskactareas = objs.values('area').annotate(
            num=Count('area')).order_by('-num')
        for i in riskactareas:
            xAxisData.append(Area.objects.get(id=i['area']).name)
        data = {}
        data['datariskact'] = []  # 风险点总数
        data['datariskact1'] = []  # 低风险点数
        data['datariskact2'] = []  # 一般风险点数
        data['datariskact3'] = []  # 较大风险点数
        data['datariskact4'] = []  # 重大风险点数
        data['datarisk'] = []  # 风险总数
        data['datarisk1'] = []  # 低风险数
        data['datarisk2'] = []  # 一般风险数
        data['datarisk3'] = []  # 较大风险数
        data['datarisk4'] = []  # 重大风险数
        for i in riskactareas:
            objsxx = objs.filter(area__id=i['area'])
            data['datariskact'].append(objsxx.count())
            data['datariskact1'].append(objsxx.filter(level="低风险").count())
            data['datariskact2'].append(objsxx.filter(level="一般风险").count())
            data['datariskact3'].append(objsxx.filter(level="较大风险").count())
            data['datariskact4'].append(objsxx.filter(level="重大风险").count())
            objsxx2 = objs2.filter(riskact__area__id=i['area'])
            data['datarisk'].append(objsxx2.count())
            data['datarisk1'].append(objsxx2.filter(level="低风险").count())
            data['datarisk2'].append(objsxx2.filter(level="一般风险").count())
            data['datarisk3'].append(objsxx2.filter(level="较大风险").count())
            data['datarisk4'].append(objsxx2.filter(level="重大风险").count())
        return JsonResponse({'code': 1, 'xAxisData': xAxisData, 'seriesData': data})


def fxhandle(req):
    a = req.GET.get('a')
    if a == 'exportyjdoc':
        userid = req.session['userid']
        companyid = getcompany(userid)
        vl = json.loads(req.body.decode())
        vl['companyname'] = Partment.objects.get(partid=companyid).partname
        v = exportyjdoc(vl)
        return JsonResponse({"code": 1, 'downloadurl': v})
    elif a == 'yhfxpm':
        userid = req.session['userid']
        companyid = getcompany(userid)
        partsall = Partment.objects.filter(
            partlink__contains=',' + companyid + ',') | Partment.objects.filter(partid=companyid)
        objs = Trouble.objects.filter(
            fxr__ubelongpart__partid__in=partsall, deletemark=1)
        # userall = User.objects.filter(ubelongpart__in=partsall,deletemark=1)
        # objs=[]
        # for i in userall:
        #     yhnum = Trouble.objects.filter(fxr=i)
        if req.GET.get('qssj'):
            objs = objs.filter(fxsj__gte=req.GET.get('qssj'))
        if req.GET.get('jssj'):
            objs = objs.filter(fxsj__lte=req.GET.get('jssj'))
        if req.GET.get('jclx'):
            objs = objs.filter(jclx=Dickey.objects.filter(
                dickeyid=req.GET.get('jclx')))
        #     yhnum = yhnum.count()
        #     objs.append({'fxr__userid':i.userid,'fxr__name':i.name,'fxbm__partname':i.ubelongpart.partname,'number':yhnum})
        # objs.sort(key=takeSecond,reverse=True)
        if req.GET.get('fxbm'):
            fxbm = req.GET.get('fxbm')
            parts = Partment.objects.filter(
                partlink__contains=',' + fxbm + ',') | Partment.objects.filter(partid=fxbm)
            objs = objs.filter(fxbm__in=parts)
        #     objs=[]
        #     for i in userlist:
        #         yhnum = Trouble.objects.filter(fxr=i)
        #         if req.GET.get('qssj'):
        #             yhnum = yhnum.filter(fxsj__gte=req.GET.get('qssj'))
        #         if req.GET.get('jssj'):
        #             yhnum = yhnum.filter(fxsj__lte=req.GET.get('jssj'))
        #         yhnum = yhnum.count()
        #         objs.append({'fxr__userid':i.userid,'fxr__name':i.name,'fxbm__partname':i.ubelongpart.partname,'number':yhnum})
        #     objs.sort(key=takeSecond,reverse=True)
        # objs = objs.values('fxr__userid','fxr__name','fxbm__partname').annotate(number = Count('fxr')).order_by('-number')
        total = objs.count()
        objs = objs.values('fxr__userid', 'fxr__name', 'fxbm__partname').annotate(
            number=Count('fxr')).order_by('-number')
        return HttpResponse(transjson(total, objs), content_type="application/json")
    elif a == 'yhzgpm':
        userid = req.session['userid']
        companyid = getcompany(userid)
        objs = Trouble.objects.filter(usecomp__partid=companyid, deletemark=1)
        if req.GET.get('zgr'):
            objs = objs.filter(zgr__name__contains=req.GET.get('zgr'))
        if req.GET.get('qssj'):
            objs = objs.filter(fxsj__gte=req.GET.get('qssj'))
        if req.GET.get('jssj'):
            objs = objs.filter(fxsj__lte=req.GET.get('jssj'))
        objs = objs.values('zgr__userid', 'zgr__name', 'zgbm__partname').annotate(
            number=Count('zgr')).order_by('-number')
        total = objs.count()
        return HttpResponse(transjson(total, objs), content_type="application/json")
    # elif a == 'exportexcel':
    #     datalist = req.POST.get('data')
    #     downloadurl = exportsimplexlsx(datalist)
    #     return JsonResponse({'code':1,'downloadurl':downloadurl})


def takeSecond(elem):
    return elem['number']


def userhandle(req):
    if req.GET.get('a') == 'adduserh':
        return render(req, 'abuser.html')
    elif req.GET.get('a') == 'edituserh':
        return render(req, 'abuser.html')
    elif req.GET.get('a') == 'del':
        a = req.GET.get('userid')
        userid = req.session['userid']
        if User.objects.get(userid=userid).issuper == 1:
            if User.objects.get(userid=a).issuper == 1:
                return JsonResponse({"code": 0})
            else:
                user = User.objects.get(userid=a)
                user.deletemark=0
                user.save()
                bgroups = user.userg.all()#该用户所属用户组
                for i in bgroups:
                    i.users.remove(user)
                for i in Partment.objects.filter(Q(aqy__contains=','+str(a)+',')|Q(bmzg__contains=','+str(a)+',')|Q(bsq__contains=','+str(a)+',')):#从部门权限中移除
                    i.aqy = i.aqy.replace(','+str(a)+',',',')
                    i.bmzg = i.bmzg.replace(','+str(a)+',',',')
                    i.bsq = i.bsq.replace(','+str(a)+',',',')
                    i.save()
                return JsonResponse({"code": 1})
        else:
            return JsonResponse({"code": 0})
    elif req.GET.get('a') == 'add':
        if req.POST.get('userid') != '':
            a = User.objects.filter(userid=req.POST.get('userid'))
            newname = req.POST.get('username')
            if User.objects.filter(username=newname).exclude(username=a[0].username).count() == 0:
                name = req.POST.get('name')
                empid = req.POST.get('empid')
                ubelongpart = Partment.objects.get(
                    partid=req.POST.get('ubelongpart'))
                # if req.POST.getlist('group',None):
                #     a[0].userg.add(*req.POST.getlist('group'))
                a.update(name=name, empid=empid,
                         ubelongpart=ubelongpart, username=newname)
                profile, _ = Userprofile.objects.get_or_create(user=a[0], defaults={'user':a[0]})
                profile.realname = req.POST.get('realname', '')
                profile.cardnum = req.POST.get('cardnum', '')
                profile.gender = req.POST.get('gender', '男')
                profile.save()
                return JsonResponse({"code": 1})
            else:
                return JsonResponse({"code": 0})
        else:
            newname = req.POST.get('username')
            if User.objects.filter(username=newname).count() == 0:
                a = User()
                a.name = req.POST.get('name')
                a.empid = req.POST.get('empid')
                a.username = req.POST.get('username')
                a.password = req.POST.get('password')
                a.epassword = make_password(req.POST.get('password'))
                a.ubelongpart = Partment.objects.get(
                    partid=req.POST.get('ubelongpart'))
                a.save()
                companyid = getcompany(a.userid)
                a.usecomp = Partment.objects.get(partid=companyid)
                profile, _ = Userprofile.objects.get_or_create(user=a, defaults={'user':a})
                profile.realname = req.POST.get('realname', '')
                profile.cardnum = req.POST.get('cardnum', '')
                profile.gender = req.POST.get('gender', '男')
                profile.save()
                a.save()
                # if req.POST.getlist('group',None):
                #     #a.userg.add(*req.POST.getlist('group'))
                #     objs = Group.objects.filter(groupid__in=req.POST.getlist('group'))
                #     for i in objs:
                #         if i.grouptype == 1:

                #         i.users.add(a)
                Group.objects.get(usecomp__partid=companyid,
                                  grouptype=3).users.add(a)
                return JsonResponse({"code": 1})
            else:
                return JsonResponse({"code": 0})


def getuser(req):
    userid = req.session['userid']
    if req.GET.get('partid'):
        partid = req.GET.get('partid')
        parts = Partment.objects.filter(
            partlink__contains=','+partid+',') | Partment.objects.filter(partid=partid)
        if req.GET.get('a') == 'datagrid':
            a = User.objects.filter(
                ubelongpart__in=parts, deletemark=1).exclude(issuper=1)
            total = a.count()
            if req.GET.get('page', None):
                startnum, endnum = fenye(req)
                a = a[startnum:endnum]
            a = a.values('userid', 'empid', 'name', 'ubelongpart__partname',
                         'ubelongpart__partid', 'username', 'openid', 'userprofile__cardnum', 'userprofile__gender')
            return HttpResponse(transjson(total, a), content_type="application/json")
        else:
            a = User.objects.filter(ubelongpart__in=parts, deletemark=1).exclude(
                issuper=1).values('userid', 'name')
            keystr = transstr(a, 'userid', 'name')
            return HttpResponse(keystr, content_type="application/json")
    elif req.GET.get('groupid'):
        groupid = req.GET.get('groupid')
        a = Group.objects.get(groupid=groupid).users.filter(deletemark=1).all().values(
            'userid', 'empid', 'name', 'ubelongpart__partname', 'ubelongpart__partid', 'username')
        total = a.count()
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif req.GET.get('userid'):
        a = User.objects.filter(userid=req.GET.get('userid')).values(
            'userid', 'empid', 'name', 'ubelongpart__partid', 'username', 'openid', 'headimgurl', 'nickname', 'userprofile__realname', 'userprofile__cardnum', 'userprofile__gender')
        b = list(a)[0]
        return HttpResponse(json.dumps(b, cls=MyEncoder), content_type="application/json")
    elif req.GET.get('name'):
        if req.GET.get('a') == 'datagrid':
            companyid = getcompany(userid)
            parts = Partment.objects.filter(
                partlink__contains=','+companyid+',') | Partment.objects.filter(partid=companyid)
            a = User.objects.filter(ubelongpart__in=parts, deletemark=1).filter(Q(name__contains=req.GET.get('name'))|Q(username__contains=req.GET.get('name'))).order_by(
                'userid').values('userid', 'empid', 'name', 'ubelongpart__partname', 'ubelongpart__partid', 'username', 'openid', 'userprofile__cardnum', 'userprofile__gender')
            total = a.count()
            return HttpResponse(transjson(total, a), content_type="application/json")
    else:
        companyid = getcompany(userid)
        parts = Partment.objects.filter(
            partlink__contains=','+companyid+',') | Partment.objects.filter(partid=companyid)
        if req.GET.get('a') == 'combobox':
            a = User.objects.filter(ubelongpart__in=parts, deletemark=1).exclude(
                issuper=1).values('userid', 'name')
            keystr = transstr(a, 'userid', 'name')
            return HttpResponse(keystr, content_type="application/json")
        else:
            a = User.objects.filter(
                ubelongpart__in=parts, deletemark=1).exclude(issuper=1)
            total = a.count()
            startnum, endnum = fenye(req)
            a = a.order_by('userid')[startnum:endnum].values(
                'userid', 'empid', 'name', 'ubelongpart__partname', 'ubelongpart__partid', 'username', 'openid', 'userprofile__cardnum', 'userprofile__gender')
            return HttpResponse(transjson(total, a), content_type="application/json")


def parthandle(req):
    if req.GET.get('a') == "addparth":
        return render(req, 'abpart.html')
    elif req.GET.get('a') == 'editparth':
        return render(req, 'abpart.html')
    elif req.GET.get('a') == 'detail':
        a = Partment.objects.filter(partid=req.GET.get('partid')).values(
            'partid', 'partname', 'parentid', 'iscompany')
        b = list(a)[0]
        return HttpResponse(json.dumps(b, cls=MyEncoder), content_type="application/json")
    elif req.GET.get('a') == 'del':
        a = req.POST.get('partid')
        if Partment.objects.filter(partlink__contains=','+a+',').exists() or User.objects.filter(ubelongpart=a).exists():
            return JsonResponse({"code": 0})
        else:
            Partment.objects.get(partid=a).delete()
            return JsonResponse({"code": 1})
    elif req.GET.get('a') == 'addpart':
        if req.POST.get('partid') != '':
            partid = req.POST.get('partid')
            partname = req.POST.get('partname')
            parentid = req.POST.get('parentid')
            partobj = Partment.objects.get(partid=partid)
            if partobj.iscompany==1:
                partobj.partname = partname
                partobj.save()
            else:
                oldpartlink = partobj.partlink + partid + ','
                partlink = Partment.objects.get(
                    partid=parentid).partlink + parentid + ','
                Partment.objects.filter(partid=partid).update(
                    partname=partname, parentid=parentid, partlink=partlink)
                Partment.objects.filter(partlink__contains=oldpartlink).update(
                    partlink=partlink + partid + ',')
            return JsonResponse({"code": 1})
        else:
            try:
                a = Partment()
                a.parentid = Partment.objects.get(
                    partid=req.POST.get('parentid'))
                a.partname = req.POST.get('partname')
                a.partlink = Partment.objects.get(partid=req.POST.get(
                    'parentid')).partlink + str(req.POST.get('parentid')) + ','
                a.save()
                return JsonResponse({"code": 1})
            except:
                return JsonResponse({"code": 0})
    elif req.GET.get('a') == 'tree':
        userid = req.session['userid']
        companyid = getcompany(userid)
        list_items = (Partment.objects.filter(Q(partlink__contains=','+companyid+',') | Q(partid=companyid),Q(deletemark=1))
                      ).annotate(id=F('partid'), parentId=F('parentid'), name=F('partname')).values('id', 'parentId', 'name')
        return HttpResponse(json.dumps(list(list_items)), content_type="application/json")
    elif req.GET.get('a') == 'tree4':#不能选自己部门及以下
        userid = req.session['userid']
        companyid = getcompany(userid)
        expart = req.GET.get('expart')
        list_items = (Partment.objects.filter(Q(partlink__contains=','+companyid+',') | Q(partid=companyid),Q(deletemark=1)).exclude(Q(partid=expart)|Q(partlink__contains=','+expart+','))).annotate(id=F('partid'), parentId=F('parentid'), name=F('partname')).values('id', 'parentId', 'name')
        return HttpResponse(json.dumps(list(list_items)), content_type="application/json")
    elif req.GET.get('a') == 'tree2':
        userid = req.session['userid']
        companyid = getcompany(userid)
        list_items = (Partment.objects.filter(partlink__contains=','+companyid+',',deletemark=1)).annotate(id=F('partid'),
                                                                                              parentId=F('parentid'), name=F('partname')).values('id', 'parentId', 'name', 'iscompany')
        return HttpResponse(json.dumps(list(list_items)), content_type="application/json")
    elif req.GET.get('a') == 'tree3':  # 能够指派的部门,包括自己所在的部门
        userid = req.session['userid']
        parts = Partment.objects.filter(Q(aqy__contains=','+str(userid)+',') | Q(
            bmzg__contains=','+str(userid)+',') | Q(bsq__contains=','+str(userid)+','))
        for i in parts:
            parts = parts | Partment.objects.filter(
                partlink__contains=','+str(i.partid)+',')
        parts = parts | Partment.objects.filter(
            partid=User.objects.get(userid=userid).ubelongpart.partid)
        list_items = parts.annotate(id=F('partid'), parentId=F('parentid'), name=F(
            'partname')).values('id', 'parentId', 'name', 'iscompany')
        return HttpResponse(json.dumps(list(list_items)), content_type="application/json")
    elif req.GET.get('a') == 'getzgdatagrid':
        partid = req.GET.get('partid')
        zgstr = Partment.objects.get(partid=partid).bmzg
        if zgstr == ',':
            return HttpResponse(json.dumps([]), content_type="application/json")
        else:
            zglist = zgstr.split(',')
            zglist = list(filter(None, zglist))
            orderlist = []
            for i in zglist:
                orderlist.extend(list(User.objects.filter(
                    userid=i).values('userid', 'name')))
            return HttpResponse(json.dumps(orderlist), content_type="application/json")
    elif req.GET.get('a') == 'getaqydatagrid':
        partid = req.GET.get('partid')
        aqystr = Partment.objects.get(partid=partid).aqy
        if aqystr == ',':
            return HttpResponse(json.dumps([]), content_type="application/json")
        else:
            aqylist = aqystr.split(',')
            aqylist = list(filter(None, aqylist))
            orderlist = []
            for i in aqylist:
                orderlist.extend(list(User.objects.filter(
                    userid=i).values('userid', 'name')))
            return HttpResponse(json.dumps(orderlist), content_type="application/json")
    elif req.GET.get('a') == 'getbsqdatagrid':
        partid = req.GET.get('partid')
        bsqstr = Partment.objects.get(partid=partid).bsq
        if bsqstr == ',':
            return HttpResponse(json.dumps([]), content_type="application/json")
        else:
            bsqlist = bsqstr.split(',')
            bsqlist = list(filter(None, bsqlist))
            items = User.objects.filter(
                userid__in=bsqlist).values('userid', 'name')
            return HttpResponse(json.dumps(list(items)), content_type="application/json")
    elif req.GET.get('a') == 'addzg':
        partid = req.GET.get('partid')
        users = req.POST.get('users')
        try:
            userlist = users.split(',')
            obj = Partment.objects.get(partid=partid)
            zgstr = obj.bmzg
            zglist = zgstr.split(',')
            zglist = list(filter(None, zglist))
            zglist.extend(userlist)
            addo = list(set(zglist))
            addo.sort(key=zglist.index)
            zgstr = ','+','.join(addo)+','
            obj.bmzg = zgstr
            obj.save()
            a = Group.objects.get(grouptype=2, usecomp=Partment.objects.get(
                partid=getcompany(req.session['userid'])))
            for i in userlist:
                if User.objects.get(userid=int(i)) not in a.users.all():
                    a.users.add(User.objects.get(userid=int(i)))
        except:
            pass
        return JsonResponse({"code": 1})
    elif req.GET.get('a') == 'addaqy':
        partid = req.GET.get('partid')
        users = req.POST.get('users')
        try:
            userlist = users.split(',')
            obj = Partment.objects.get(partid=partid)
            aqystr = obj.aqy
            aqylist = aqystr.split(',')
            aqylist = list(filter(None, aqylist))
            aqylist.extend(userlist)
            addo = list(set(aqylist))
            addo.sort(key=aqylist.index)
            aqystr = ','+','.join(addo)+','
            obj.aqy = aqystr
            obj.save()
            a = Group.objects.get(grouptype=1, usecomp=Partment.objects.get(
                partid=getcompany(req.session['userid'])))
            for i in userlist:
                if User.objects.get(userid=int(i)) not in a.users.all():
                    a.users.add(User.objects.get(userid=int(i)))
        except:
            pass
        return JsonResponse({"code": 1})
    elif req.GET.get('a') == 'addbsq':
        partid = req.GET.get('partid')
        users = req.POST.get('users')
        try:
            userlist = users.split(',')
            obj = Partment.objects.get(partid=partid)
            bsqstr = obj.bsq
            bsqlist = bsqstr.split(',')
            bsqlist = list(filter(None, bsqlist))
            bsqlist.extend(userlist)
            addo = list(set(bsqlist))
            addo.sort(key=bsqlist.index)
            bsqstr = ','+','.join(bsqlist)+','
            obj.bsq = bsqstr
            obj.save()
        except:
            pass
        return JsonResponse({"code": 1})
    elif req.GET.get('a') == 'removezg':
        partid = req.GET.get('partid')
        userid = req.GET.get('userid')
        obj = Partment.objects.get(partid=partid)
        zgstr = obj.bmzg
        zgstr = zgstr.replace(','+userid+',', ',')
        obj.bmzg = zgstr
        obj.save()
        a = Group.objects.get(grouptype=2, usecomp=Partment.objects.get(
            partid=getcompany(req.session['userid'])))
        a.users.remove(User.objects.get(userid=userid))
        return JsonResponse({"code": 1})
    elif req.GET.get('a') == 'removeaqy':
        partid = req.GET.get('partid')
        userid = req.GET.get('userid')
        obj = Partment.objects.get(partid=partid)
        aqystr = obj.aqy
        aqystr = aqystr.replace(','+userid+',', ',')
        obj.aqy = aqystr
        obj.save()
        a = Group.objects.get(grouptype=1, usecomp=Partment.objects.get(
            partid=getcompany(req.session['userid'])))
        a.users.remove(User.objects.get(userid=userid))
        return JsonResponse({"code": 1})
    elif req.GET.get('a') == 'removebsq':
        partid = req.GET.get('partid')
        userid = req.GET.get('userid')
        obj = Partment.objects.get(partid=partid)
        bsqstr = obj.bsq
        bsqstr = bsqstr.replace(','+userid+',', ',')
        obj.bsq = bsqstr
        obj.save()
        return JsonResponse({"code": 1})


def dicthandle(req):
    if req.GET.get('a') == 'adddicth':
        return render(req, 'abdict.html')
    elif req.GET.get('a') == 'deldict':
        userid = req.session['userid']
        dickeyid = req.GET.get('dickeyid')
        a = Dickey.objects.get(dickeyid=dickeyid)
        if userid == 8:
            a.deletemark = 0
            a.save()
            return JsonResponse({"code": 1})
        elif User.objects.get(userid=userid).issuper == 1:
            companyid = getcompany(userid)
            nl = a.nousecomps.split(',')
            nl.append(companyid)
            nl = ','+','.join(list(filter(None, nl)))+','
            a.nousecomps = nl
            a.save()
            return JsonResponse({"code": 1})
        else:
            return JsonResponse({"code": 0})
    elif req.GET.get('a') == 'editdicth':
        return render(req, 'abdict.html')
    elif req.GET.get('a') == 'canedit':
        userid = req.session['userid']
        companyid = getcompany(userid)
        dickeyid = req.GET.get('dickeyid')
        a = Dickey.objects.get(dickeyid=dickeyid)
        if userid == 8:
            return JsonResponse({"code": 1})
        elif a.usecomps == ','+str(companyid)+',' and a.nousecomps == '' and User.objects.get(userid=userid).issuper == 1:
            return JsonResponse({"code": 1})
        else:
            return JsonResponse({"code": 0})
    elif req.method == 'POST':
        userid = req.session['userid']
        companyid = getcompany(userid)
        data = json.loads(req.body.decode('utf-8'))
        dickeyid = data['dickeyid']
        dickeyname = data['dickeyname']
        dicparent = data['dicparent']
        detail = data['detail']
        if dickeyid != '':
            a = Dickey.objects.get(dickeyid=dickeyid)
            if ',1,' in a.usecomps and companyid != '1':
                return JsonResponse({"code": 0})
            else:
                a.dickeyname = dickeyname
                a.dicparent = Dicclass.objects.get(dicid=dicparent)
                a.detail = detail
                a.save()
                return JsonResponse({"code": 1})
        else:
            Dickey.objects.create(dickeyname=dickeyname, dicparent=Dicclass.objects.get(
                dicid=dicparent), usecomps=','+companyid+',', detail=detail)
            return JsonResponse({"code": 1})


def pxhandle(req):
    if req.GET.get('a') == 'listsearch':
        userid = req.session['userid']
        companyid = getcompany(userid)
        a = Train.objects.filter(usecomp=Partment.objects.get(
            partid=companyid)).exclude(deletemark=0)
        qssj = req.GET.get('qssj', None)
        jssj = req.GET.get('jssj', None)
        pxbm = req.GET.get('trainpart', None)
        pxjb = req.GET.get('trainlevel', None)
        pxnr = req.GET.get('traincontent', None)
        if pxjb:
            a = a.filter(trainlevel__dicid=pxjb)
        if pxnr:
            a = a.filter(traincontent__dickeyid=pxnr)
        if pxbm:
            a = a.filter(trainpart__partid=pxbm)
        if qssj:
            a = a.filter(starttime__gte=qssj)
        if jssj:
            a = a.filter(starttime__lte=jssj)
        total = a.count()
        startnum, endnum = fenye(req)
        obj = a.order_by('-starttime')[startnum:endnum].values('trainnum', 'trainid', 'state', 'trainplace', 'starttime',
                                                               'trainname', 'traintype__dickeyname', 'teacher', 'lecturer__name', 'submituser__name', 'submituser__userid', 'lecturer__userid', 'trainplan__year', 'trainplan__month', 'trainplan__purpose')
        return HttpResponse(transjson(total, obj), content_type="application/json")
    elif req.GET.get('a') == 'detailhtml':
        trainid = req.GET.get('trainid')
        return render(req, 'traindetail.html', {'trainid': trainid})
    elif req.GET.get('a') == 'listall':
        userid = req.session['userid']
        companyid = getcompany(userid)
        a = Train.objects.filter(usecomp=Partment.objects.get(
            partid=companyid), deletemark=1).order_by('-modifytime')
        total = a.count()
        startnum, endnum = fenye(req)
        a = a[startnum:endnum].values('trainnum', 'trainid', 'state', 'trainplace', 'starttime', 'trainname',
                                      'traintype__dickeyname', 'teacher', 'lecturer__name', 'submituser__name', 'submituser__userid', 'lecturer__userid', 'trainplan__year', 'trainplan__month', 'trainplan__purpose')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif req.GET.get('a') == 'listtodo':
        userid = req.session['userid']
        companyid = getcompany(userid)
        a = Train.objects.filter(usecomp=Partment.objects.get(
            partid=companyid), deletemark=1, state=0, submituser__userid=userid).order_by('-modifytime')
        total = a.count()
        startnum, endnum = fenye(req)
        a = a[startnum:endnum].values('trainnum', 'trainid', 'state', 'trainplace', 'starttime', 'trainname',
                                      'traintype__dickeyname', 'teacher', 'lecturer__name', 'submituser__name', 'submituser__userid')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif req.GET.get('a') == 'listcj':
        userid = req.session['userid']
        companyid = getcompany(userid)
        a = Trainuser.objects.filter(participant=User.objects.get(
            userid=userid), train__deletemark=1).order_by('-train__modifytime')
        total = a.count()
        startnum, endnum = fenye(req)
        a = a[startnum:endnum].values('train__trainnum', 'train__trainid', 'train__state', 'train__trainplace',
                                      'train__starttime', 'train__trainname', 'checked', 'train__teacher', 'train__lecturer__name')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif req.GET.get('a') == 'dqdnum':
        userid = req.session['userid']
        companyid = getcompany(userid)
        dqdnum = Trainuser.objects.filter(participant=User.objects.get(
            userid=userid), checked=0, train__deletemark=1, train__state=1).count()
        return JsonResponse({'code': 1, 'dqdnum': dqdnum})
    elif req.GET.get('a') == 'detail':
        trainid = req.GET.get('trainid')
        a = Train.objects.filter(trainid=trainid)
        x = a.values('trainid', 'trainnum', 'state', 'trainplace', 'starttime', 'trainname', 'traintype__dickeyname', 'teacher', 'lecturer__name', 'submituser__name', 'submittime', 'trainlevel__dicname',
                     'traincontent__dickeyname', 'manlevel__dickeyname', 'detailcontent', 'participantnum', 'knownum', 'duration', 'material', 'checkqr', 'examtest__num', 'examtest__name')[0]
        for key in x:
            if x[key] == None:
                x[key] = ''
        x['material'] = x['material'].split('?')
        # 对many字段单独处理
        str1 = []
        for i in a.values('trainpart__partname'):
            str1.append(i['trainpart__partname'])
        x['trainpart'] = ','.join(str1)
        str2 = []
        objs = Trainuser.objects.filter(train=a[0])
        detailobjs = objs.order_by('checked').values(
            'participant__name', 'participant__ubelongpart__partname', 'checked', 'qdsj', 'isnew')
        for i in objs.filter(checked=1):
            str2.append(i.participant.name)
        x['participantname'] = ','.join(str2)
        x['participantnum'] = objs.filter(checked=1).count()
        x['cjrydetail'] = list(detailobjs)
        return HttpResponse(json.dumps(x, cls=MyEncoder), content_type="application/json")
    elif req.GET.get('a') == 'check':
        userid = req.session['userid']
        trainid = req.GET.get('trainid')
        obj = Trainuser.objects.filter(train=Train.objects.get(
            trainid=trainid), participant=User.objects.get(userid=userid))
        if obj.exists():
            obj.update(checked=1, qdsj=datetime.now())
        else:
            Trainuser.objects.create(train=Train.objects.get(trainid=trainid), participant=User.objects.get(
                userid=userid), checked=1, qdsj=datetime.now(), isnew=1)
        return JsonResponse({"code": 1})
    elif req.GET.get('a') == 'exportword':
        trainid = req.GET.get('trainid')
        v = exportdoc('px', trainid)
        return JsonResponse({"code": 1, 'downloadurl': v})
    elif req.GET.get('a') == 'exportexcel':
        # pxids=json.loads(req.body.decode())['pxids']
        userid = req.session['userid']
        companyid = getcompany(userid)
        a = Train.objects.filter(usecomp=Partment.objects.get(
            partid=companyid)).exclude(deletemark=0)
        qssj = req.GET.get('qssj', None)
        jssj = req.GET.get('jssj', None)
        pxbm = req.GET.get('trainpart', None)
        pxjb = req.GET.get('trainlevel', None)
        pxnr = req.GET.get('traincontent', None)
        if pxjb:
            a = a.filter(trainlevel__dicid=pxjb)
        if pxnr:
            a = a.filter(traincontent__dickeyid=pxnr)
        if pxbm:
            a = a.filter(trainpart__partid=pxbm)
        if qssj:
            a = a.filter(starttime__gte=qssj)
        if jssj:
            a = a.filter(starttime__lte=jssj)
        v = exportxlsx('px', a)
        return JsonResponse({"code": 1, 'downloadurl': v})
    elif req.GET.get('a') == 'del':
        trainid = req.GET.get('trainid')
        userid = req.session['userid']
        a = Train.objects.get(trainid=trainid)
        if User.objects.get(userid=userid).issuper == 1:
            a.deletemark = 0
            a.save()
            return JsonResponse({"code": 1})
        elif a.submituser.userid == userid and a.state == 0:
            a.deletemark = 0
            a.save()
            return JsonResponse({"code": 1})
        else:
            return JsonResponse({"code": 0})


def ylhandle(req):
    if req.GET.get('a') == 'listall':
        userid = req.session['userid']
        companyid = getcompany(userid)
        startnum, endnum = fenye(req)
        a = Drill.objects.filter(usecomp=Partment.objects.get(
            partid=companyid), deletemark=1).order_by('-starttime')
        total = a.count()
        startnum, endnum = fenye(req)
        a = a[startnum:endnum].values('drillnum', 'drillid', 'state', 'drillplace', 'starttime',
                                      'drillname', 'drilltype__dickeyname', 'chief__name', 'submituser__name', 'submituser__userid')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif req.GET.get('a') == 'listtodo':
        userid = req.session['userid']
        companyid = getcompany(userid)
        a = Drill.objects.filter(usecomp=Partment.objects.get(
            partid=companyid), deletemark=1, submituser__userid=userid, state=0).order_by('-starttime')
        total = a.count()
        startnum, endnum = fenye(req)
        a = a[startnum:endnum].values('drillnum', 'drillid', 'state', 'drillplace', 'starttime',
                                      'drillname', 'drilltype__dickeyname', 'chief__name', 'submituser__name', 'submituser__userid')
        total = a.count()
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif req.GET.get('a') == 'detailhtml':
        drillid = req.GET.get('drillid')
        return render(req, 'drilldetail.html', {'drillid': drillid})
    elif req.GET.get('a') == 'detail':
        drillid = req.GET.get('drillid')
        a = Drill.objects.filter(drillid=drillid)
        x = a.values('drillid', 'drillnum', 'state', 'drillplace', 'starttime', 'drilllevel__dicname', 'drillname', 'drilltype__dickeyname',
                     'chief__name', 'submituser__name', 'submittime', 'drillcontent__dickeyname', 'detailcontent', 'participantnum', 'knownum', 'material')[0]
        for key in x:
            if x[key] == None:
                x[key] = ''
        x['material'] = x['material'].split('?')
        # 对many字段单独处理
        str1 = []
        for i in a.values('drillpart__partname'):
            str1.append(i['drillpart__partname'])
        x['drillpart'] = ','.join(str1)
        str2 = []
        for i in a.values('participant__name'):
            str2.append(i['participant__name'])
        x['participantname'] = ','.join(str2)
        return JsonResponse(x)
    elif req.GET.get('a') == 'exportword':
        drillid = req.GET.get('drillid')
        v = exportdoc('yl', drillid)
        return JsonResponse({"code": 1, 'downloadurl': v})
    elif req.GET.get('a') == 'exportexcel':
        userid = req.session['userid']
        companyid = getcompany(userid)
        a = Drill.objects.filter(usecomp=Partment.objects.get(
            partid=companyid), deletemark=1)
        qssj = req.GET.get('qssj')
        jssj = req.GET.get('jssj')
        ylbm = req.GET.get('drillpart')
        yljb = req.GET.get('drilllevel')
        ylnr = req.GET.get('drillcontent')
        if yljb:
            a = a.filter(drilllevel__dicid=yljb)
        if ylnr:
            a = a.filter(drillcontent__dickeyid=ylnr)
        if ylbm:
            a = a.filter(drillpart__partid=ylbm)
        if qssj:
            a = a.filter(starttime__gte=qssj)
        if jssj:
            a = a.filter(starttime__lte=jssj)
        v = exportxlsx('yl', a)
        return JsonResponse({"code": 1, 'downloadurl': v})
    elif req.GET.get('a') == 'del':
        drillid = req.GET.get('drillid')
        userid = req.session['userid']
        a = Drill.objects.get(drillid=drillid)
        if User.objects.get(userid=userid).issuper == 1:
            a.deletemark = 0
            a.save()
            return JsonResponse({"code": 1})
        elif a.submituser.userid == userid and a.state == 0:
            a.deletemark = 0
            a.save()
            return JsonResponse({"code": 1})
        else:
            return JsonResponse({"code": 0})
    elif req.GET.get('a') == 'listsearch':
        userid = req.session['userid']
        companyid = getcompany(userid)
        a = Drill.objects.filter(usecomp=Partment.objects.get(
            partid=companyid), deletemark=1)
        qssj = req.GET.get('qssj')
        jssj = req.GET.get('jssj')
        ylbm = req.GET.get('drillpart')
        yljb = req.GET.get('drilllevel')
        ylnr = req.GET.get('drillcontent')
        if yljb:
            a = a.filter(drilllevel__dicid=yljb)
        if ylnr:
            a = a.filter(drillcontent__dickeyid=ylnr)
        if ylbm:
            a = a.filter(drillpart__partid=ylbm)
        if qssj:
            a = a.filter(starttime__gte=qssj)
        if jssj:
            a = a.filter(starttime__lte=jssj)
        total = a.count()
        startnum, endnum = fenye(req)
        obj = a.order_by('-starttime')[startnum:endnum].values('drillnum', 'drillid', 'state', 'drillplace',
                                                               'starttime', 'drillname', 'drilltype__dickeyname', 'chief__name', 'submituser__name', 'submituser__userid')
        return HttpResponse(transjson(total, a), content_type="application/json")


def gchandle(req):
    a = req.GET.get('a')
    userid = req.session['userid']
    companyid = getcompany(userid)
    if a == 'add':
        obj = Observe()
        gcdata = json.loads(req.body.decode('utf-8'))
        obj.actname = gcdata['actname']
        obj.lookplace = gcdata['lookplace']
        obj.looktime = gcdata['looktime']
        obj.looker = User.objects.get(userid=userid)
        obj.lookpart = User.objects.get(userid=userid).ubelongpart
        if 'looktime2' in gcdata:
            if gcdata['looktime2']:
                obj.looktime2 = gcdata['looktime2']
        if 'lookeder' in gcdata:
            obj.lookeder = gcdata['lookeder']
        if 'otherunsafe' in gcdata:
            obj.otherunsafe = gcdata['otherunsafe']
        if 'safecontent' in gcdata:
            obj.safecontent = gcdata['safecontent']
        obj.looknum = 'GC'+time.strftime('%Y%m%d%H%M%S')
        obj.usecomp = Partment.objects.get(partid=companyid)
        if 'lookimg' in gcdata:
            obj.lookimg = '?'.join(gcdata['lookimg'])
        obj.save()
        if 'lookers' in gcdata:
            ulist = gcdata['lookers'].split(',')
            for i in ulist:
                x = User.objects.get(userid=i)
                obj.lookers.add(x)
        if 'unsafe' in gcdata:
            olist = gcdata['unsafe']
            for i in olist:
                if i != 0:
                    dickey = Dickey.objects.get(dickeyid=i)
                    m = Unsafes(observe=obj, unsafedickey=dickey,
                                unsafedicclass=dickey.dicparent)
                    m.save()
        yjjs_gc.delay(companyid)
        return JsonResponse({"code": 1})
    elif a == 'listall':
        startnum, endnum = fenye(req)
        a = Observe.objects.filter(usecomp=Partment.objects.get(
            partid=companyid), deletemark=1).order_by('-looktime')
        total = a.count()
        a = a[startnum:endnum].values('lookid', 'looknum', 'lookplace',
                                      'actname', 'looktime', 'looker__name', 'lookeder', 'otherunsafe')
        for i in a:
            objs = Observeto.objects.filter(
                observe__lookid=i['lookid'], user__userid=userid)
            if objs.exists():
                i['read'] = 1
                i['readtime'] = objs[0].submittime
            else:
                i['read'] = 0
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'listself':
        startnum, endnum = fenye(req)
        a = Observe.objects.filter(
            looker__userid=userid, deletemark=1).order_by('-looktime')
        total = a.count()
        a = a[startnum:endnum].values('lookid', 'looknum', 'lookplace',
                                      'actname', 'looktime', 'looker__name', 'lookeder', 'otherunsafe')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'del':
        lookid = req.GET.get('lookid')
        a = Observe.objects.get(lookid=lookid)
        if User.objects.get(userid=userid).issuper == 1:
            a.deletemark = 0
            a.save()
            yjjs_gc.delay(companyid)
            return JsonResponse({"code": 1})
        else:
            return JsonResponse({"code": 0})
    elif a == 'listsearch':
        startnum, endnum = fenye(req)
        a = Observe.objects.filter(
            usecomp=Partment.objects.get(partid=companyid), deletemark=1)
        # print(req.GET.get('qssj'))
        if req.GET.get('gcr'):
            a = a.filter(looker__userid=req.GET.get('gcr'))
        if req.GET.get('gcbm'):
            parts = Partment.objects.filter(partlink__contains=','+req.GET.get(
                'gcbm')+',') | Partment.objects.filter(partid=req.GET.get('gcbm'))
            a = a.filter(lookpart__in=parts)
        if req.GET.get('qssj'):
            a = a.filter(looktime__gte=req.GET.get('qssj'))
        if req.GET.get('jssj'):
            a = a.filter(looktime__lte=req.GET.get('jssj'))
        total = a.count()
        startnum, endnum = fenye(req)
        a = a.order_by('-looktime')[startnum:endnum].values('lookid', 'looknum',
                                                            'lookplace', 'actname', 'looktime', 'looker__name', 'lookeder')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'exportexcel':
        a = Observe.objects.filter(
            usecomp=Partment.objects.get(partid=companyid), deletemark=1)
        if req.GET.get('gcr'):
            a = a.filter(looker__userid=req.GET.get('gcr'))
        if req.GET.get('gcbm'):
            parts = Partment.objects.filter(partlink__contains=','+req.GET.get(
                'gcbm')+',') | Partment.objects.filter(partid=req.GET.get('gcbm'))
            a = a.filter(lookpart__in=parts)
        if req.GET.get('qssj'):
            a = a.filter(looktime__gte=req.GET.get('qssj'))
        if req.GET.get('jssj'):
            a = a.filter(looktime__lte=req.GET.get('jssj'))
        res = exportxlsx('gc', a)
        return res
    elif a == 'detailhtml':
        return render(req, 'observedetail.html', {'lookid': req.GET.get('lookid')})
    elif a == 'detail':
        lookid = req.GET.get('lookid')
        a = Observe.objects.filter(lookid=lookid)
        x = a.values('lookid', 'looknum', 'lookplace', 'actname', 'looktime', 'looker__name', 'lookeder',
                     'otherunsafe', 'safecontent', 'lookpart__partname', 'submittime', 'lookimg', 'looktime2')[0]
        b = Unsafes.objects.filter(observe=a[0]).values(
            'unsafedicclass__dicname', 'unsafedickey__dickeyname')
        x['gcnr'] = list(b)
        if x['lookimg']:
            x['lookimg'] = x['lookimg'].split('?')
        else:
            x['lookimg'] = []
        x['lookers'] = []
        for i in a[0].lookers.all():
            x['lookers'].append(i.name)
        x['lookers'] = ','.join(x['lookers'])
        Observeto.objects.get_or_create(observe=a[0], user=User.objects.get(
            userid=req.session['userid']), defaults={'read': 1})
        return HttpResponse(json.dumps(x, cls=MyEncoder), content_type="application/json")
    elif a == 'getdics':
        gcdict = {}
        gclist = []
        objs = Dicclass.objects.filter(
            parentid=23).order_by('dicid')  # 行为观察字典集合
        for i in objs:
            x = {'value': i.dicid, 'text': i.dicname}
            obj = Dickey.objects.filter(dicparent=i.dicid, deletemark=1)
            obj = (obj.filter(usecomps__contains=',1,') | obj.filter(usecomps__contains=',' +
                                                                     companyid+',')).exclude(nousecomps__contains=','+companyid+',').order_by('dickeyid')
            x0 = []
            for i in obj:
                x0.append({'value': i.dickeyid, 'text': i.dickeyname})
            x['child'] = x0
            gclist.append(x)
        gcdict['data'] = gclist
        return JsonResponse(gcdict)
    elif a == 'noreadnum':
        a = Observe.objects.filter(usecomp=Partment.objects.get(
            partid=companyid), deletemark=1).count()
        b = Observeto.objects.filter(
            user__userid=userid, observe__deletemark=1).count()
        noread = a-b
        return JsonResponse({'noread': noread})
    elif a == 'exportword':
        data = json.loads(req.body.decode('utf-8'))
        url = exportdoc2('gc', data)
        return JsonResponse({"code": 1, "downloadurl": url})


def observepic(req):
    userid = req.session['userid']
    companyid = getcompany(userid)

    if req.GET.get('a') == 'gclxt':  # 观察类型饼图
        year = int(req.GET.get('year'))
        month = int(req.GET.get('month'))
        first_day, first_day_of_next_month = gettime(datetime(year, month, 1))
        if req.GET.get('part'):
            partid = req.GET.get('part')
        else:
            partid = companyid
        parts = Partment.objects.filter(Q(partid=partid) | Q(
            partlink__contains=',' + str(partid) + ','))
        a = Observe.objects.filter(lookpart__in=parts, deletemark=1, looktime__range=(
            first_day, first_day_of_next_month))
        value = []
        key = []
        for i in Dicclass.objects.filter(parentid__dicid=23):
            x = i.dicname
            y = Unsafes.objects.filter(observe__in=a, unsafedicclass=i).count()
            key.append(x)
            value.append({'value': y, 'name': x})
        return JsonResponse({'code': 1, 'key': key, 'value': value})
    elif req.GET.get('a') == 'gclzx':  # 观察类型折线图
        year = int(req.GET.get('year'))
        months = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
        userfy = []  # 人员反映
        userwz = []  # 员工的位置
        grfh = []  # 个人防护装备
        gjhsb = []  # 工具和设备
        cxhbz = []  # 程序和标准
        rtgcx = []  # 人体工程学
        hjzj = []  # 环境整洁

        for month in months:
            first_day, first_day_of_next_month = gettime(
                datetime(year, month, 1))
            if req.GET.get('part'):
                partid = req.GET.get('part')
            else:
                partid = companyid
            parts = Partment.objects.filter(Q(partid=partid) | Q(
                partlink__contains=',' + str(partid) + ','))
            a = Observe.objects.filter(lookpart__in=parts, deletemark=1, looktime__range=(
                first_day, first_day_of_next_month))
            for i in Dicclass.objects.filter(parentid__dicid=23):
                if i.dicid == 24:
                    userfy.append(Unsafes.objects.filter(
                        observe__in=a, unsafedicclass=i).count())
                elif i.dicid == 25:
                    userwz.append(Unsafes.objects.filter(
                        observe__in=a, unsafedicclass=i).count())
                elif i.dicid == 26:
                    grfh.append(Unsafes.objects.filter(
                        observe__in=a, unsafedicclass=i).count())
                elif i.dicid == 27:
                    gjhsb.append(Unsafes.objects.filter(
                        observe__in=a, unsafedicclass=i).count())
                elif i.dicid == 28:
                    cxhbz.append(Unsafes.objects.filter(
                        observe__in=a, unsafedicclass=i).count())
                elif i.dicid == 29:
                    rtgcx.append(Unsafes.objects.filter(
                        observe__in=a, unsafedicclass=i).count())
                elif i.dicid == 30:
                    hjzj.append(Unsafes.objects.filter(
                        observe__in=a, unsafedicclass=i).count())

        return JsonResponse({'code': 1, 'months': months, 'userfy': userfy, 'userwz': userwz, 'grfh': grfh, 'gjhsb': gjhsb, 'cxhbz': cxhbz, 'rtgcx': rtgcx, 'hjzj': hjzj, })
    elif req.GET.get('a') == 'gclxbg':
        userid = req.session['userid']
        companyid = getcompany(userid)
        a = Observe.objects.filter(
            usecomp=Partment.objects.get(partid=companyid), deletemark=1)

        if req.GET.get('qssj'):  # 开始时间
            a = a.filter(looktime__gte=req.GET.get('qssj'))
        if req.GET.get('jssj'):  # 结束时间
            a = a.filter(looktime__lte=req.GET.get('jssj'))
        if req.GET.get('fxbm'):
            gcbm = req.GET.get('fxbm')
            parts = Partment.objects.filter(
                partlink__contains=',' + gcbm + ',') | Partment.objects.filter(partid=gcbm)
            a = a.filter(lookpart__in=parts)

        total = a.count()
        objs = a.values('looker__userid', 'looker__name', 'lookpart__partname').annotate(
            number=Count('looker')).order_by('-number')
        return HttpResponse(transjson(total, objs), content_type="application/json")


def dicchandle(req):
    a = req.GET.get('a')
    if a == 'tree':
        a = Dicclass.objects.exclude(dicid=1).order_by('dicid').annotate(id=F(
            'dicid'), parentId=F('parentid'), name=F('dicname')).values('id', 'parentId', 'name')
        return HttpResponse(json.dumps(list(a)), content_type="application/json")


def bwlogin2(req):
    if req.method == 'GET':
        try:
            code = req.GET.get('code')
        except:
            # 还未关注公众号
            return render(req, 'bindwechat2.html', {'msg': '还未绑定公众号！'})
        content = requests.get('https://api.weixin.qq.com/sns/oauth2/access_token?appid=wx4d75244c1b980b5b&secret=edf7d23a457fb4df5ad47eeb9d4b7a39&code=' +
                               code+'&grant_type=authorization_code').content.decode('utf-8')
        tokendict = json.loads(content)
        openid = tokendict['openid']
        access_token = tokendict['access_token']
        userinfo = requests.get('https://api.weixin.qq.com/sns/userinfo?access_token=' +
                                access_token+'&openid='+openid+'&lang=zh_CN').content.decode('utf-8')  # 拉取用户信息
        userinfo = json.loads(userinfo)
        nickname = userinfo['nickname']
        headimgurl = userinfo['headimgurl']
        return render(req, 'bwlogin2.html', {'openid': openid, 'nickname': nickname, 'headimgurl': headimgurl})
    else:
        username = req.POST.get('username')
        password = req.POST.get('password')
        openid = req.POST.get('openid')
        nickname = req.POST.get('nickname')
        headimgurl = req.POST.get('headimgurl')
        user = User.objects.filter(username=username, deletemark=1)
        if user.exists():
            if check_password(password, user[0].epassword):
                mpuser = User.objects.filter(
                    openid=openid).exclude(username=username)
                if mpuser.exists():
                    # 已绑定其他账号
                    return render(req, 'bindwechat.html', {'msg': '您的微信已绑定平台下'+mpuser[0].username+'账号,不可重复绑定，请先至pc端解绑！', 'code': 0})
                else:
                    if user[0].openid == '0' or user[0].openid == None or user[0].openid == '':
                        user.update(openid=openid,
                                    headimgurl=headimgurl, nickname=nickname)
                        return render(req, 'bindwechat.html', {'msg': '绑定成功，请刷新电脑端浏览器！', 'code': 1})
                    else:
                        if user[0].openid == openid:
                            return render(req, 'bindwechat.html', {'msg': '绑定成功，请刷新电脑端浏览器！', 'code': 1})
                        else:
                            # 已绑定其他账号
                            return render(req, 'bindwechat.html', {'msg': '该平台账号已绑定昵称为'+user[0].nickname+'的微信,不可重复绑定，请先至pc端解绑！', 'code': 0})
            else:
                return render(req, 'bwlogin.html', {'msg': '密码错误'})
        else:
            return render(req, 'bwlogin.html', {'msg': '用户不存在或已禁用'})


def bwlogin(req):
    if req.method == 'GET':
        try:
            code = req.GET.get('code')
        except:
            # 还未关注公众号
            return render(req, 'bindwechat.html', {'msg': '还未绑定公众号！'})
        content = requests.get('https://api.weixin.qq.com/sns/oauth2/access_token?appid=wx4d75244c1b980b5b&secret=edf7d23a457fb4df5ad47eeb9d4b7a39&code=' +
                               code+'&grant_type=authorization_code').content.decode('utf-8')
        tokendict = json.loads(content)
        openid = tokendict['openid']
        access_token = tokendict['access_token']
        mpuser = User.objects.filter(openid=openid)
        if mpuser.exists():
            # 已绑定账号
            return render(req, 'bindwechat.html', {'msg': '您的微信已绑定平台下'+mpuser[0].username+'账号,不可重复绑定，可先至pc端解绑！', 'code': 0})
        userinfo = requests.get('https://api.weixin.qq.com/sns/userinfo?access_token=' +
                                access_token+'&openid='+openid+'&lang=zh_CN').content.decode('utf-8')  # 拉取用户信息
        userinfo = json.loads(userinfo)
        nickname = userinfo['nickname']
        headimgurl = userinfo['headimgurl']
        return render(req, 'bwlogin.html', {'openid': openid, 'nickname': nickname, 'headimgurl': headimgurl})
    else:
        username = req.POST.get('username')
        password = req.POST.get('password')
        openid = req.POST.get('openid')
        nickname = req.POST.get('nickname')
        headimgurl = req.POST.get('headimgurl')
        user = User.objects.filter(username=username, deletemark=1)
        if user.exists():
            if check_password(password, user[0].epassword):
                User.objects.filter(openid=openid).update(
                    openid=None, headimgurl=None, nickname=None)
                user.update(openid=openid, headimgurl=headimgurl,
                            nickname=nickname)
                return render(req, 'bindwechat.html', {'msg': '绑定成功，请刷新电脑端浏览器！', 'code': 1})
            else:
                return render(req, 'bwlogin.html', {'msg': '密码错误'})
        else:
            return render(req, 'bwlogin.html', {'msg': '用户不存在或已禁用'})


def unbindwechat(req):#解绑公众号全部置空
    userid = req.session['userid']
    user = User.objects.get(userid=userid)
    if user.openid:
        User.objects.filter(openid=user.openid).update(openid=None,headimgurl=None, nickname=None, mpopenid=None)
    user.openid=None
    user.headimgurl=None
    user.nickname=None
    user.mpopenid=None
    user.save()
    return JsonResponse({"code": 1})


def unbindmp(req): #解绑小程序仅仅置空mpopenid
    userid = req.session['userid']
    user = User.objects.get(userid=userid)
    if user.mpopenid:
        User.objects.filter(mpopenid=user.mpopenid).update(mpopenid=None)
    user.mpopenid=None
    user.save()
    req.session.flush() #清除登陆态
    return JsonResponse({"code": 1})


def vewechat(req):
    return HttpResponse('201810170853050zbwtyaxirqeb757umcehktirlemh2ib10kcdovka13hchyf4s', content_type="text/plain")

def vewechat2(req):
    return redirect('/media/verify/boUR15vyNu.txt')

def minip_px(req):
    f = StringIO()
    f.write('86beeba7de3c84c26244f19287f49a03')
    res = HttpResponse(content_type='APPLICATION/OCTET-STREAM')
    res['Content-Disposition'] = 'attachment;filename=boUR15vyNu.txt'
    res.write(f.getvalue())
    return res


def mplogin(req):
    res = req.body.decode('utf-8')
    try:
        code = req.POST.get('code')
    except:
        code = json.loads(res)['code']
    info = requests.get('https://api.weixin.qq.com/sns/jscode2session?appid=wx5c39b569f01c27db&secret=68762892f8df2b4a0b1940c5250a8dc0&js_code=' +
                        code+'&grant_type=authorization_code').content.decode('utf-8')
    info = json.loads(info)
    mpopenid = info['openid']
    session_key = info['session_key']
    objs = User.objects.filter(mpopenid=mpopenid)
    if objs.exists():
        a = objs[0]
        userid = a.userid
        username = a.username
        req.session['userid'] = userid
        allrights = list(a.usecomp.role.permissions.all().values_list('menuid',flat=True))
        # print(req.session,req.COOKIES)
        return JsonResponse({"code": 1, 'userid': userid, 'username': username, 'mpopenid': mpopenid,'openid':a.openid, 'nickname':a.nickname, 'headimgurl':a.headimgurl, 'companyid':a.usecomp.partid, 'rights': allrights, 'name':a.name})
    else:
        return JsonResponse({"code": 0, 'mpopenid': mpopenid})


def bindmp(req):
    data = json.loads(req.body.decode('utf-8'))
    username = data['username']
    password = data['password']
    mpopenid = data['mpopenid']
    userinfo = data.get('userinfo', None)
    # print(username,password,mpopenid)
    user = User.objects.filter(username=username, deletemark=1)
    if user.exists():
        if check_password(password, user[0].epassword):
            if userinfo:
                user.update(mpopenid=mpopenid,headimgurl=userinfo['avatarUrl'],nickname=userinfo['nickName'])
            else:
                user.update(mpopenid=mpopenid)
            return JsonResponse({"code": 1})
        else:
            return JsonResponse({"code": 0})
    else:
        return JsonResponse({"code": 0})




def setup(req):
    if req.GET.get('a') == 'setuph':
        userid = req.session['userid']
        companyid = getcompany(userid)
        obj = Yjsetup.objects.filter(usecomp__partid=companyid).values()
        return render(req, 'setup.html', obj[0])
    elif req.GET.get('a') == 'setup':
        userid = req.session['userid']
        companyid = getcompany(userid)
        obj = Yjsetup.objects.filter(usecomp__partid=companyid).values()
        #a = {'total':total,'rows':list(obj),'code':1}
        #jsondata = json.dumps(a,cls=MyEncoder)
        return JsonResponse(obj[0])
    elif req.method == 'POST':
        userid = req.session['userid']
        companyid = getcompany(userid)
        yjsetupid = req.POST.get('yjsetupid')
        monthyhavg = req.POST.get('monthyhavg')
        safev = req.POST.get('safev')
        warnv = req.POST.get('warnv')
        alertv = req.POST.get('alertv')
        maxv = req.POST.get('maxv')
        yhpgqz = req.POST.get('yhpgqz')
        yhdjqz = req.POST.get('yhdjqz')
        yhsblqz = req.POST.get('yhsblqz')
        yhzglqz = req.POST.get('yhzglqz')
        pxdjqz = req.POST.get('pxdjqz')
        pxxgqz = req.POST.get('pxxgqz')
        yldjqz = req.POST.get('yldjqz')
        ylxgqz = req.POST.get('ylxgqz')
        Yjsetup.objects.filter(yjsetupid=yjsetupid).update(monthyhavg=monthyhavg, safev=safev, warnv=warnv, alertv=alertv, maxv=maxv,
                                                           yhpgqz=yhpgqz, yhdjqz=yhdjqz, yhsblqz=yhsblqz, yhzglqz=yhzglqz, pxdjqz=pxdjqz, pxxgqz=pxxgqz, yldjqz=yldjqz, ylxgqz=ylxgqz
                                                           )
        return JsonResponse({"code": 1})


def test(req):
    print(req.body)
    print(json.loads(req.body.decode('utf-8'))['yhtp'])


def importusers(req):
    companyid = req.GET.get('companyid')
    drusers(companyid)
    return JsonResponse({"code": 1})


@apicheck_login
def apicompany(req):
    if int(req.session.get('userid')) == 8:
        a = req.GET.get('a')
        menurights = [11,1,2,3,4,5,6,7,8,9,10,12,13,15,16,17,18,19,20,21,22,23,24,28,29,32,36,46,47,48,50]  # 初始化菜单编码
        if a == 'add':
            admin = req.GET.get('admin')
            company = req.GET.get('company')
            y = Partment()
            if Partment.objects.filter(partname=company).exists():
                return JsonResponse({'code': 0})
            else:
                y.partname = company
                y.partlink = ','
                y.iscompany = 1
                y.save()
                x = User()
                x.username = admin
                x.name = '超级管理员'
                x.password = 'Aq123456'
                x.epassword = make_password('Aq123456')
                x.issuper = 1
                x.ubelongpart = y
                x.usecomp = y
                x.save()
                y.bmzg = ','+str(x.userid)+','
                y.save()
                part = Partment.objects.get(partid=y.partid)
                Group.objects.create(
                    groupname='超管', grouptype=0, usecomp=part, menulist=menurights)
                Group.objects.create(
                    groupname='安全员', grouptype=1, usecomp=part, menulist=menurights)
                Group.objects.create(
                    groupname='全体用户', grouptype=3, usecomp=part, menulist=menurights)
                z = Group(groupname='主管', grouptype=2,
                          usecomp=part, menulist=menurights)
                z.save()
                z.users.add(x)
                Yjsetup.objects.create(monthyhavg=100, safev=50, warnv=75, alertv=100, maxv=200, yhpgqz=4,
                                       yhdjqz=4, yhsblqz=1, yhzglqz=4, pxdjqz=3, pxxgqz=4, yldjqz=3, ylxgqz=3, usecomp=y)
                Map.objects.create(
                    name='默认地图', pic='/static/safesite/mystatic/images/snc.jpg', usecomp=y, default=1)
                return JsonResponse({'code': 1, 'companyid': y.partid})
    else:
        return JsonResponse({'code': 0, 'msg': 'no right!'})


def drapi(req):
    a = req.GET.get('a')
    if a == 'user':
        userid = req.session['userid']
        companyid = getcompany(userid)
        file_name = 'c'+str(companyid)+'_'+req.FILES['upfile'].name
        upload_folder = 'media/temp'
        if not os.path.exists(upload_folder):
            os.mkdir(upload_folder)
        filepath = os.path.join(upload_folder, file_name)
        filepath = filepath.replace('\\', '/')
        with open(filepath, 'wb') as f:
            f.write(req.FILES['upfile'].read())
        return JsonResponse(drusers(companyid, filepath))
    elif a == 'equipment':
        userid = req.session['userid']
        companyid = getcompany(userid)
        file_name = 'c'+str(companyid)+'_'+req.FILES['upfile'].name
        upload_folder = 'media/temp'
        if not os.path.exists(upload_folder):
            os.mkdir(upload_folder)
        filepath = os.path.join(upload_folder, file_name)
        filepath = filepath.replace('\\', '/')
        with open(filepath, 'wb') as f:
            f.write(req.FILES['upfile'].read())
        # try:
        equipmentdict = drequipments(companyid, filepath)
        if equipmentdict:
            return JsonResponse({"code": 2, "equipmentdict": equipmentdict})
        else:
            return JsonResponse({"code": 1})
    elif a == 'risk':
        userid = req.session['userid']
        companyid = getcompany(userid)
        file_name = 'c'+str(companyid)+'_'+req.FILES['upfile'].name
        upload_folder = 'media/temp'
        if not os.path.exists(upload_folder):
            os.mkdir(upload_folder)
        filepath = os.path.join(upload_folder, file_name)
        filepath = filepath.replace('\\', '/')
        with open(filepath, 'wb') as f:
            f.write(req.FILES['upfile'].read())
        try:
            risks = drrisks(companyid, filepath)
            if risks:
                return JsonResponse({"code": 2, "risks": risks})
            else:
                return JsonResponse({"code": 1})
        except:
            return JsonResponse({"code": 0})
    elif a == 'question':
        userid = req.session['userid']
        companyid = getcompany(userid)
        file_name = 'c'+str(companyid)+'_'+req.FILES['upfile'].name
        upload_folder = 'media/temp'
        if not os.path.exists(upload_folder):
            os.mkdir(upload_folder)
        filepath = os.path.join(upload_folder, file_name)
        filepath = filepath.replace('\\', '/')
        with open(filepath, 'wb') as f:
            f.write(req.FILES['upfile'].read())
        msg = drquestions(companyid, filepath, userid)
        if msg:
            return JsonResponse({"code": 2, "msg": msg})
        else:
            return JsonResponse({"code": 1})
    elif a == 'todotrouble':
        userid = req.session['userid']
        companyid = getcompany(userid)
        file_name = 'c'+str(companyid)+'_'+req.FILES['upfile'].name
        upload_folder = 'media/temp'
        if not os.path.exists(upload_folder):
            os.mkdir(upload_folder)
        filepath = os.path.join(upload_folder, file_name)
        filepath = filepath.replace('\\', '/')
        with open(filepath, 'wb') as f:
            f.write(req.FILES['upfile'].read())
        msg = drtodotroubles(companyid, filepath, userid)
        if msg:
            return JsonResponse({"code": 2, "msg": msg})
        else:
            return JsonResponse({"code": 1})

@apicheck_login
def apimiss(req):
    a = req.GET.get('a')
    userid = req.session['userid']
    companyid = getcompany(userid)
    if a == 'add':
        obj = Miss()
        data = json.loads(req.body.decode('utf-8'))
        obj.missplace = data['missplace']
        obj.misstime = data['misstime']
        obj.misser = User.objects.get(userid=userid)
        obj.misspart = User.objects.get(userid=userid).ubelongpart
        obj.description = data['description']
        if 'missqy' in data:
            if data['missqy']:
                obj.missqy = Area.objects.get(id=data['missqy'])
        if 'prevent' in data:
            obj.prevent = data['prevent']
        if 'lesson' in data:
            obj.lesson = data['lesson']
        obj.missnum = 'WS'+time.strftime('%Y%m%d%H%M%S')
        obj.usecomp = Partment.objects.get(partid=companyid)
        if 'missimg' in data:
            obj.missimg = '?'.join(data['missimg'])
        obj.save()
        yjjs_ws.delay(companyid)
        return JsonResponse({"code": 1})
    elif a == 'listall':
        startnum, endnum = fenye(req)
        a = Miss.objects.filter(usecomp=Partment.objects.get(
            partid=companyid), deletemark=1)
        if req.GET.get('missqy', None):
            a = a.filter(missqy__id=req.GET.get('missqy'))
        a = a.order_by('-misstime')
        total = a.count()
        startnum, endnum = fenye(req)
        a = a[startnum:endnum].values(
            'missid', 'missnum', 'missplace', 'description', 'misstime', 'misser__name', 'missimg')
        for i in a:
            if Missto.objects.filter(miss__missid=i['missid'], user__userid=userid).exists():
                i['read'] = 1
                i['readtime'] = Missto.objects.filter(
                    miss__missid=i['missid'], user__userid=userid)[0].submittime
            else:
                i['read'] = 0
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'listself':
        startnum, endnum = fenye(req)
        a = Miss.objects.filter(misser__userid=userid,
                                deletemark=1).order_by('-misstime')
        total = a.count()
        startnum, endnum = fenye(req)
        a = a[startnum:endnum].values(
            'missid', 'missnum', 'missplace', 'description', 'misstime', 'misser__name')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'detail':
        missid = req.GET.get('missid')
        a = Miss.objects.filter(missid=missid)
        x = a.values('missid', 'missnum', 'missplace', 'misstime', 'misser__name', 'description',
                     'prevent', 'misspart__partname', 'submittime', 'missimg', 'lesson')[0]
        if x['missimg']:
            x['missimg'] = x['missimg'].split('?')
        else:
            x['missimg'] = []
        for key in x:
            if x[key] == None:
                x[key] = ''
        Missto.objects.get_or_create(miss=a[0], user=User.objects.get(
            userid=req.session['userid']), defaults={'read': 1})
        return HttpResponse(json.dumps(x, cls=MyEncoder), content_type="application/json")
    elif a == 'del':
        missid = req.GET.get('missid')
        a = Miss.objects.get(missid=missid)
        if User.objects.get(userid=userid).issuper == 1:
            a.deletemark = 0
            a.save()
            yjjs_ws.delay(companyid)
            return JsonResponse({"code": 1})
        else:
            return JsonResponse({"code": 0})
    elif a == 'listsearch':
        startnum, endnum = fenye(req)
        a = Miss.objects.filter(usecomp=Partment.objects.get(
            partid=companyid), deletemark=1)
        if req.GET.get('fsbm'):
            parts = Partment.objects.filter(partlink__contains=','+req.GET.get(
                'fsbm')+',') | Partment.objects.filter(partid=req.GET.get('fsbm'))
            a = a.filter(misspart__in=parts)
        if req.GET.get('qssj'):
            a = a.filter(misstime__gte=req.GET.get('qssj'))
        if req.GET.get('jssj'):
            a = a.filter(misstime__lte=req.GET.get('jssj'))
        total = a.count()
        a = a.order_by('-misstime')[startnum:endnum].values('missid',
                                                            'missnum', 'missplace', 'description', 'misstime')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'exportexcel':
        a = Miss.objects.filter(usecomp=Partment.objects.get(
            partid=companyid), deletemark=1)
        if req.GET.get('fsbm'):
            parts = Partment.objects.filter(partlink__contains=','+req.GET.get(
                'fsbm')+',') | Partment.objects.filter(partid=req.GET.get('fsbm'))
            a = a.filter(misspart__in=parts)
        if req.GET.get('qssj'):
            a = a.filter(misstime__gte=req.GET.get('qssj'))
        if req.GET.get('jssj'):
            a = a.filter(misstime__lte=req.GET.get('jssj'))
        res = exportxlsx('ws', a)
        return res
    elif a == 'exportword':
        id = req.GET.get('id')
        res = exportdoc('ws', id)
        return res
    elif a == 'noreadnum':
        a = Miss.objects.filter(usecomp=Partment.objects.get(
            partid=companyid), deletemark=1).count()
        b = Missto.objects.filter(
            user__userid=userid, miss__deletemark=1).count()
        noread = a-b
        return JsonResponse({'noread': noread})


def apisocert(req):
    a = req.GET.get('a')
    if a == 'listall':
        userid = req.session['userid']
        companyid = getcompany(userid)
        startnum, endnum = fenye(req)
        a = Socertificate.objects.filter(user__usecomp__partid=companyid).order_by('id')  # 无deletemark
        total = a.count()
        startnum, endnum = fenye(req)
        if req.GET.get('sort'):
            a = a.order_by(req.GET.get('sort'))
        a = a[startnum:endnum].values('id', 'realname', 'gender', 'zylb', 'czxm',
                                      'fzjg', 'ccfzrq', 'yfsrq', 'yxqkssj', 'yxqjssj', 'sjfssj', 'zszt', 'url', 'cardnum', 'user__userprofile__realname', 'user__userprofile__gender', 'user__userprofile__cardnum')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'listself':
        userid = req.session['userid']
        userprofile = Userprofile.objects.filter(user__userid=userid)
        if userprofile.exists():
            cardnum = userprofile[0].cardnum
        else:
            return JsonResponse({'code':0,'msg':'信息不全'})
        a = Socertificate.objects.filter(
            cardnum=cardnum).order_by('id')  # 无deletemark
        total = a.count()
        if req.GET.get('sort'):
            a = a.order_by(req.GET.get('sort'))
        a = a.values('id', 'realname', 'gender', 'zylb', 'czxm', 'fzjg',
                     'ccfzrq', 'yfsrq', 'yxqkssj', 'yxqjssj', 'sjfssj', 'zszt', 'url',  'cardnum')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'add':
        postdata = json.loads(req.body.decode('utf-8'))
        obj = Socertificate()
        user = User.objects.get(userid = postdata['userid'])
        obj.user = User.objects.get(userid = postdata['userid'])
        obj.zylb = postdata['zylb']
        obj.fzjg = postdata['fzjg']
        obj.czxm = postdata['czxm']
        obj.ccfzrq = postdata['ccfzrq']
        obj.yfsrq = postdata['yfsrq']
        obj.yxqkssj = postdata['yxqkssj']
        obj.yxqjssj = postdata['yxqjssj']
        obj.zszt = guoqi(postdata['yfsrq'])
        obj.usecomp = user.usecomp
        obj.save()
        return JsonResponse({'code':1})
    elif a == 'edit':
        postdata = json.loads(req.body.decode('utf-8'))
        obj = Socertificate.objects.get(id=postdata['id'])
        obj.zylb = postdata['zylb']
        obj.fzjg = postdata['fzjg']
        obj.czxm = postdata['czxm']
        obj.ccfzrq = postdata['ccfzrq']
        obj.yfsrq = postdata['yfsrq']
        obj.yxqkssj = postdata['yxqkssj']
        obj.yxqjssj = postdata['yxqjssj']
        obj.zszt = guoqi(postdata['yfsrq'])
        obj.save()
        return JsonResponse({'code':1})
    # elif a == 'addspider':
    #     postdata = json.loads(req.body.decode('utf-8'))
    #     userid = postdata['userid']
    #     realname = postdata['realname']
    #     cardnum = postdata['cardnum']
    #     companyid = getcompany(userid)
    #     data = getTzzs(cardnum, realname)
    #     data1 = []
    #     gender = ''
    #     if data:
    #         for i in data:
    #             if i['操作项目'] not in data1:
    #                 updated_values = {
    #                     'user': User.objects.get(userid=userid),
    #                     'usecomp': Partment.objects.get(partid=companyid),
    #                     'realname': i['姓名'],
    #                     'gender': i['性别'],
    #                     'zylb': i['作业类别'],
    #                     'czxm': i['操作项目'],
    #                     'fzjg': i['发证机关'],
    #                     'ccfzrq': i['初次发证日期'] if i['初次发证日期'] else None,
    #                     'yfsrq': i['应复审日期'] if i['应复审日期'] else None,
    #                     'yxqkssj': i['有效期开始时间'] if i['有效期开始时间'] else None,
    #                     'yxqjssj': i['有效期结束时间'] if i['有效期结束时间'] else None,
    #                     'sjfssj': i['实际复审时间'] if i['实际复审时间'] else None,
    #                     'url': i['url'],
    #                 }
    #                 try:
    #                     updated_values['zszt'] = guoqi(i['应复审日期'])
    #                 except:
    #                     pass
    #                 obj, created = Socertificate.objects.update_or_create(
    #                     cardnum=cardnum, czxm=i['操作项目'], defaults=updated_values)
    #                 data1.append(i['操作项目'])
    #                 gender = i['性别']
    #             else:
    #                 obj = Socertificate.objects.get(
    #                     cardnum=cardnum, czxm=i['操作项目'])
    #                 if obj.yxqjssj.strftime('%Y-%m-%d') < i['有效期结束时间']:
    #                     obj.yfsrq = i['应复审日期'] if i['应复审日期'] else None
    #                     obj.yxqkssj = i['有效期开始时间'] if i['有效期开始时间'] else None
    #                     obj.yxqjssj = i['有效期结束时间'] if i['有效期结束时间'] else None
    #                     obj.sjfssj = i['实际复审时间'] if i['实际复审时间'] else None
    #                     try:
    #                         zsst = guoqi(i['应复审日期'])
    #                         obj.zszt = zsst
    #                     except:
    #                         pass
    #                     obj.save()
    #         try:
    #             obj = Userprofile.objects.get(user__userid=userid)
    #             obj.realname = realname
    #             obj.cardnum = cardnum
    #             obj.gender = gender
    #             obj.save()
    #         except Userprofile.DoesNotExist:
    #             obj = Userprofile(user=User.objects.get(
    #                 userid=userid), realname=realname, cardnum=cardnum, gender=gender)
    #             obj.save()
    #         return JsonResponse({"code": 1})
    #     else:
    #         return JsonResponse({"code": 0})
    # elif a == 'addspiderself':
    #     userid = req.session['userid']
    #     a = Userprofile.objects.get(user__userid=userid)
    #     realname = a.realname
    #     cardnum = a.cardnum
    #     companyid = getcompany(userid)
    #     data = getTzzs(cardnum, realname)
    #     data1 = []
    #     gender = ''
    #     if data:
    #         for i in data:
    #             if i['操作项目'] not in data1:
    #                 updated_values = {
    #                     'user': User.objects.get(userid=userid),
    #                     'usecomp': Partment.objects.get(partid=companyid),
    #                     'realname': i['姓名'],
    #                     'gender': i['性别'],
    #                     'zylb': i['作业类别'],
    #                     'czxm': i['操作项目'],
    #                     'fzjg': i['发证机关'],
    #                     'ccfzrq': i['初次发证日期'] if i['初次发证日期'] else None,
    #                     'yfsrq': i['应复审日期'] if i['应复审日期'] else None,
    #                     'yxqkssj': i['有效期开始时间'] if i['有效期开始时间'] else None,
    #                     'yxqjssj': i['有效期结束时间'] if i['有效期结束时间'] else None,
    #                     'sjfssj': i['实际复审时间'] if i['实际复审时间'] else None,
    #                     'url': i['url'],
    #                 }
    #                 try:
    #                     updated_values['zszt'] = guoqi(i['应复审日期'])
    #                 except:
    #                     pass
    #                 obj, created = Socertificate.objects.update_or_create(
    #                     cardnum=cardnum, czxm=i['操作项目'], defaults=updated_values)
    #                 data1.append(i['操作项目'])
    #                 gender = i['性别']
    #             else:
    #                 obj = Socertificate.objects.get(
    #                     cardnum=cardnum, czxm=i['操作项目'])
    #                 if obj.yxqjssj.strftime('%Y-%m-%d') < i['有效期结束时间']:
    #                     obj.yfsrq = i['应复审日期'] if i['应复审日期'] else None
    #                     obj.yxqkssj = i['有效期开始时间'] if i['有效期开始时间'] else None
    #                     obj.yxqjssj = i['有效期结束时间'] if i['有效期结束时间'] else None
    #                     obj.sjfssj = i['实际复审时间'] if i['实际复审时间'] else None
    #                     try:
    #                         zsst = guoqi(i['应复审日期'])
    #                         obj.zszt = zsst
    #                     except:
    #                         pass
    #                     obj.save()
    #     return JsonResponse({"code": 1})
    elif a == 'del':
        id = req.GET.get('id')
        userid = req.session['userid']
        a = Socertificate.objects.get(id=id)
        if User.objects.get(userid=userid).issuper == 1:
            a.delete()
            return JsonResponse({"code": 1})
        else:
            return JsonResponse({"code": 0})
    elif a == 'detail':
        id = req.GET.get('id')
        a = Socertificate.objects.filter(id=id).values(
            'id', 'realname', 'gender', 'zylb', 'czxm', 'fzjg', 'ccfzrq', 'yfsrq', 'yxqkssj', 'yxqjssj', 'sjfssj', 'user__userprofile__realname', 'user__userprofile__gender', 'user__userprofile__cardnum', 'user__name')
        return JsonResponse(a[0])
    elif a == 'getjson':
        cardnum = req.GET.get('cardnum')
        realname = req.GET.get('realname')
        return JsonResponse({"code": 1, "data": getTzzs(cardnum, realname)})
    elif a == 'updateTzzs':
        updateTzzs()

def apisocert_create(req):
    postdata = json.loads(req.body.decode('utf-8'))
    reqdata = {}
    reqdata['zylb'] = postdata['zylb']
    pass
    

def guoqi(x):
    now = datetime.now()
    now1 = datetime.now() + timedelta(days=180)
    if datetime.strptime(x, '%Y-%m-%d') > now1:
        return 1
    elif now1 > datetime.strptime(x, '%Y-%m-%d') > now:
        return 2
    else:
        return 3


def apisafecert(req):
    a = req.GET.get('a')
    if a == 'listall':
        userid = req.session['userid']
        companyid = getcompany(userid)
        startnum, endnum = fenye(req)
        a = Safecert.objects.filter(user__usecomp__partid=companyid).order_by('id')  # 无deletemark
        total = a.count()
        startnum, endnum = fenye(req)
        if req.GET.get('sort'):
            a = a.order_by(req.GET.get('sort'))
        a = a[startnum:endnum].values('id', 'realname', 'gender', 'zglx',
                                      'dwlx', 'fzjg', 'yfsrq', 'yxqkssj', 'yxqjssj', 'zszt', 'url', 'cardnum', 'user__userprofile__realname', 'user__userprofile__gender', 'user__userprofile__cardnum')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'listself':
        userid = req.session['userid']
        cardnum = Userprofile.objects.get(user__userid=userid).cardnum
        a = Safecert.objects.filter(
            cardnum=cardnum).order_by('id')  # 无deletemark
        total = a.count()
        if req.GET.get('sort'):
            a = a.order_by(req.GET.get('sort'))
        a = a.values('id', 'realname', 'gender', 'zglx', 'dwlx',
                     'fzjg', 'yfsrq', 'yxqkssj', 'yxqjssj', 'zszt', 'url', 'cardnum', 'user__userprofile__realname', 'user__userprofile__gender', 'user__userprofile__cardnum')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'add':
        postdata = json.loads(req.body.decode('utf-8'))
        obj = Safecert()
        user = User.objects.get(userid = postdata['userid'])
        obj.user = User.objects.get(userid = postdata['userid'])
        obj.zglx = postdata['zglx']
        obj.fzjg = postdata['fzjg']
        obj.dwlx = postdata['dwlx']
        obj.yfsrq = postdata['yfsrq']
        obj.yxqkssj = postdata['yxqkssj']
        obj.yxqjssj = postdata['yxqjssj']
        obj.zszt = guoqi(postdata['yfsrq'])
        obj.usecomp = user.usecomp
        obj.save()
        return JsonResponse({'code':1})
    elif a == 'edit':
        postdata = json.loads(req.body.decode('utf-8'))
        obj = Safecert.objects.get(id=postdata['id'])
        obj.zylb = postdata['zglx']
        obj.fzjg = postdata['fzjg']
        obj.czxm = postdata['dwlx']
        obj.yfsrq = postdata['yfsrq']
        obj.yxqkssj = postdata['yxqkssj']
        obj.yxqjssj = postdata['yxqjssj']
        obj.zszt = guoqi(postdata['yfsrq'])
        obj.save()
        return JsonResponse({'code':1})
    # elif a == 'addspider':
    #     postdata = json.loads(req.body.decode('utf-8'))
    #     userid = postdata['userid']
    #     realname = postdata['realname']
    #     cardnum = postdata['cardnum']
    #     companyid = getcompany(userid)
    #     data = getAqzs(cardnum, realname)
    #     data1 = []
    #     gender = ''
    #     if data:
    #         for i in data:
    #             if i['资格类型'] not in data1:
    #                 updated_values = {
    #                     'user': User.objects.get(userid=userid),
    #                     'usecomp': Partment.objects.get(partid=companyid),
    #                     'realname': i['姓名'],
    #                     'gender': i['性别'],
    #                     'zglx': i['资格类型'],
    #                     'dwlx': i['单位类型'],
    #                     'fzjg': i['发证机关'],
    #                     'yfsrq': i['应复审日期'] if i['应复审日期'] else None,
    #                     'yxqkssj': i['有效期开始时间'] if i['有效期开始时间'] else None,
    #                     'yxqjssj': i['有效期结束时间'] if i['有效期结束时间'] else None,
    #                     'url': i['url'],
    #                 }
    #                 try:
    #                     updated_values['zszt'] = guoqi(i['应复审日期'])
    #                 except:
    #                     pass
    #                 obj, created = Safecert.objects.update_or_create(
    #                     cardnum=cardnum, zglx=i['资格类型'], defaults=updated_values)
    #                 data1.append(i['资格类型'])
    #                 gender = i['性别']
    #             else:
    #                 obj = Safecert.objects.get(cardnum=cardnum, zglx=i['资格类型'])
    #                 if obj.yxqjssj.strftime('%Y-%m-%d') < i['有效期结束时间']:
    #                     obj.yfsrq = i['应复审日期'] if i['应复审日期'] else None
    #                     obj.yxqkssj = i['有效期开始时间'] if i['有效期开始时间'] else None
    #                     obj.yxqjssj = i['有效期结束时间'] if i['有效期结束时间'] else None
    #                     try:
    #                         zsst = guoqi(i['应复审日期'])
    #                         obj.zszt = zsst
    #                     except:
    #                         pass
    #                     obj.save()
    #         try:
    #             obj = Userprofile.objects.get(user__userid=userid)
    #             obj.realname = realname
    #             obj.cardnum = cardnum
    #             obj.gender = gender
    #             obj.save()
    #         except Userprofile.DoesNotExist:
    #             obj = Userprofile(user=User.objects.get(
    #                 userid=userid), realname=realname, cardnum=cardnum, gender=gender)
    #             obj.save()
    #         return JsonResponse({"code": 1})
    #     else:
    #         return JsonResponse({"code": 0})
    # elif a == 'addspiderself':
    #     userid = req.session['userid']
    #     a = Userprofile.objects.get(user__userid=userid)
    #     realname = a.realname
    #     cardnum = a.cardnum
    #     companyid = getcompany(userid)
    #     data = getAqzs(cardnum, realname)
    #     data1 = []
    #     gender = ''
    #     if data:
    #         for i in data:
    #             if i['资格类型'] not in data1:
    #                 updated_values = {
    #                     'user': User.objects.get(userid=userid),
    #                     'usecomp': Partment.objects.get(partid=companyid),
    #                     'realname': i['姓名'],
    #                     'gender': i['性别'],
    #                     'zglx': i['资格类型'],
    #                     'dwlx': i['单位类型'],
    #                     'fzjg': i['发证机关'],
    #                     'yfsrq': i['应复审日期'] if i['应复审日期'] else None,
    #                     'yxqkssj': i['有效期开始时间'] if i['有效期开始时间'] else None,
    #                     'yxqjssj': i['有效期结束时间'] if i['有效期结束时间'] else None,
    #                     'url': i['url'],
    #                 }
    #                 try:
    #                     updated_values['zszt'] = guoqi(i['应复审日期'])
    #                 except:
    #                     pass
    #                 obj, created = Safecert.objects.update_or_create(
    #                     cardnum=cardnum, zglx=i['资格类型'], defaults=updated_values)
    #                 data1.append(i['资格类型'])
    #                 gender = i['性别']
    #             else:
    #                 obj = Socertificate.objects.get(
    #                     cardnum=cardnum, czxm=i['资格类型'])
    #                 if obj.yxqjssj.strftime('%Y-%m-%d') < i['有效期结束时间']:
    #                     obj.yfsrq = i['应复审日期'] if i['应复审日期'] else None
    #                     obj.yxqkssj = i['有效期开始时间'] if i['有效期开始时间'] else None
    #                     obj.yxqjssj = i['有效期结束时间'] if i['有效期结束时间'] else None
    #                     try:
    #                         zsst = guoqi(i['应复审日期'])
    #                         obj.zszt = zsst
    #                     except:
    #                         pass
    #                     obj.save()
    #     return JsonResponse({"code": 1})
    elif a == 'del':
        id = req.GET.get('id')
        userid = req.session['userid']
        a = Safecert.objects.get(id=id)
        if User.objects.get(userid=userid).issuper == 1:
            a.delete()
            return JsonResponse({"code": 1})
        else:
            return JsonResponse({"code": 0})
    elif a == 'detail':
        id = req.GET.get('id')
        a = Safecert.objects.filter(id=id).values(
            'id', 'realname', 'gender', 'zglx', 'dwlx', 'fzjg', 'yfsrq', 'yxqkssj', 'yxqjssj', 'zszt', 'url', 'user__userprofile__realname', 'user__userprofile__gender', 'user__userprofile__cardnum', 'user__name')
        return JsonResponse(a[0])
    elif a == 'getjson':
        cardnum = req.GET.get('cardnum')
        realname = req.GET.get('realname')
        return JsonResponse({"code": 1, "data": getAqzs(cardnum, realname)})
    elif a == 'updateAqzs':
        updateAqzs()


def apipartuser(req):
    a = req.GET.get('a')
    if a == 'getall':
        userid = req.session['userid']
        if req.GET.get('parentid') == 'company':
            lst = []
            company = User.objects.get(userid=userid).usecomp
            partobjs = Partment.objects.filter(parentid=company, deletemark=1)
            for i in partobjs:
                lst.append({'id': i.partid, 'name': i.partname, 'parentId': 0,
                            'checked': False, 'isPeople': False, 'children': []})
            userobjs = User.objects.filter(
                ubelongpart=company, deletemark=1).exclude(issuper=1)
            for i in userobjs:
                lst.append({'id': i.userid, 'name': i.name, 'parentId': 0,
                            'checked': False, 'isPeople': True, 'children': []})
            return JsonResponse({"code": 1, "data": lst})
        else:
            lst = []
            partobjs = Partment.objects.filter(
                parentid=req.GET.get('parentid'), deletemark=1)
            for i in partobjs:
                lst.append({'id': i.partid, 'name': i.partname, 'parentId': 0,
                            'checked': False, 'isPeople': False, 'children': []})
            userobjs = User.objects.filter(ubelongpart=req.GET.get(
                'parentid'), deletemark=1).exclude(issuper=1)
            for i in userobjs:
                lst.append({'id': i.userid, 'name': i.name, 'parentId': 0,
                            'checked': False, 'isPeople': True, 'children': []})
            return JsonResponse({"code": 1, "data": lst})


def apiuser(req):
    a = req.GET.get('a')
    if a == 'detail':
        userid = req.GET.get('userid')
        companyid = getcompany(userid)
        companyname = Partment.objects.get(partid=companyid).partname
        userlist = User.objects.filter(userid=userid).values(
            'userid', 'username', 'name', 'userprofile__realname', 'userprofile__cardnum', 'ubelongpart__partname', 'userprofile__gender')
        userdict = userlist[0]
        userdict['companyname'] = companyname
        return HttpResponse(json.dumps(userdict, cls=MyEncoder), content_type="application/json")
    elif a == 'get_user_from_username':
        username = req.GET.get('username')
        if username:
            objs = User.objects.filter(username=username)
            if objs.exists():
                userdata = objs.values('name','username','ubelongpart__partname','usecomp__partname')
                return JsonResponse({"code": 1, "data": list(userdata)[0]})
        return JsonResponse({"code":0})
    elif a == 'detailself':
        userid = req.session['userid']
        companyid = getcompany(userid)
        companyname = Partment.objects.get(partid=companyid).partname
        userlist = User.objects.filter(userid=userid).values(
            'userid', 'username', 'name', 'userprofile__realname', 'userprofile__cardnum', 'ubelongpart__partname', 'userprofile__gender')
        userdict = userlist[0]
        userdict['companyname'] = companyname
        return HttpResponse(json.dumps(userdict, cls=MyEncoder), content_type="application/json")
    elif a == 'resetpass':
        userid = req.session['userid']
        nowuserid = req.GET.get('userid')
        a = User.objects.get(userid=userid)
        if a.issuper == 1:
            User.objects.filter(userid=nowuserid).update(
                password='0000', epassword=make_password('0000'))
            return JsonResponse({"code": 1})
        else:
            return JsonResponse({"code": 0})
    elif a == 'editself':
        userid = req.session['userid']
        cardnum = req.POST.get('cardnum')
        realname = req.POST.get('realname')
        gender = req.POST.get('gender')
        try:
            obj = Userprofile.objects.get(user__userid=userid)
            obj.realname = realname
            obj.cardnum = cardnum
            obj.gender = gender
            obj.save()
        except Userprofile.DoesNotExist:
            obj = Userprofile(user=User.objects.get(
                userid=userid), realname=realname, cardnum=cardnum, gender=gender)
            obj.save()
        return JsonResponse({"code": 1})
    elif a == 'checkaqy':
        userid = req.session['userid']
        if Partment.objects.filter(Q(aqy__contains=','+str(userid)+',') | Q(bmzg__contains=','+str(userid)+',') | Q(bsq__contains=','+str(userid)+',')).exists():
            return JsonResponse({"code": 1})
        else:
            return JsonResponse({"code": 0})
    elif a == 'uuserdatagrid':
        userid = req.session['userid']
        usecomp = User.objects.get(userid=userid).usecomp
        a = User.objects.filter(usecomp=usecomp, deletemark=0).exclude(issuper=1).order_by('userid').values(
            'userid', 'empid', 'name', 'ubelongpart__partname', 'ubelongpart__partid', 'username', 'openid')
        total = a.count()
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'recovery':
        ruserid = req.GET.get('userid')
        user = User.objects.get(userid=ruserid)
        user.deletemark=1
        user.save()
        Group.objects.get(usecomp=user.usecomp,grouptype=3).users.add(user)#授予基本权限
        return JsonResponse({"code": 1})
    elif a == 'updateHeadimg':
        userid = req.GET.get('userid')
        user = User.objects.get(userid=userid)
        data = json.loads(req.body.decode('utf-8'))
        if 'headimgurl' in data:
            user.headimgurl = data['headimgurl']
        if 'nickname' in data:
            user.nickname = data['nickname']
        user.save()
        return JsonResponse({'code':1})


def apiduibiao(req):
    text = req.POST.get('yhms')
    result = calsim.calsimTojson(text)
    return JsonResponse({'code': 1, 'data': result})


def apisuggest(req):
    a = req.GET.get('a')
    if a == 'add':
        userid = req.session['userid']
        oneuser = User.objects.get(userid=userid)
        obj = Suggest()
        data = json.loads(req.body.decode('utf-8'))
        obj.jylb = Dickey.objects.get(dickeyid=data['jylb'])
        obj.jyr = oneuser
        obj.jybm = oneuser.ubelongpart
        obj.jynr = data['jynr']
        obj.dqxz = data['dqxz']
        obj.qwxg = data['qwxg']
        obj.jynum = 'JY'+time.strftime('%Y%m%d%H%M%S')
        obj.usecomp = oneuser.usecomp
        if 'jyimg' in data:
            obj.jyimg = '?'.join(data['jyimg'])
        if 'jyqy' in data:
            if data['jyqy']:
                obj.jyqy = Area.objects.get(id=data['jyqy'])
        if 'jydd' in data:
            obj.jydd = data['jydd']
        obj.jyzt = 1
        todouser = getpgr2(userid, User.objects.get(userid=userid).ubelongpart)
        obj.todouser = todouser
        obj.pgr = todouser
        obj.save()
        Suggestflow.objects.create(suggest=obj, user=oneuser, action='提出新建议')
        return JsonResponse({"code": 1})
    elif a == 'listall':
        userid = req.session['userid']
        companyid = getcompany(userid)
        startnum, endnum = fenye(req)
        a = Suggest.objects.filter(usecomp=Partment.objects.get(
            partid=companyid)).order_by('-submittime')
        total = a.count()
        startnum, endnum = fenye(req)
        a = a[startnum:endnum].values('jyid', 'jylb__dickeyname', 'jyr__name', 'jybm__partname', 'dqxz', 'jynr',
                                      'jynum', 'jyzt', 'todouser__userid', 'todouser__name', 'jyqy__name', 'jydd', 'submittime', 'accept')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'listself':
        userid = req.session['userid']
        startnum, endnum = fenye(req)
        a = Suggest.objects.filter(jyr__userid=userid).order_by('-submittime')
        total = a.count()
        startnum, endnum = fenye(req)
        a = a[startnum:endnum].values('jyid', 'jylb__dickeyname', 'jyr__name', 'jybm__partname', 'dqxz', 'jynr',
                                      'jynum', 'jyzt', 'todouser__userid', 'todouser__name', 'jyqy__name', 'jydd', 'submittime', 'accept')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'listtodo':
        userid = req.session['userid']
        startnum, endnum = fenye(req)
        a = Suggest.objects.filter(
            todouser__userid=userid).order_by('-submittime')
        total = a.count()
        startnum, endnum = fenye(req)
        a = a[startnum:endnum].values('jyid', 'jylb__dickeyname', 'jyr__name', 'jybm__partname', 'dqxz', 'jynr',
                                      'jynum', 'jyzt', 'todouser__userid', 'todouser__name', 'jyqy__name', 'jydd', 'submittime', 'accept')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'todonum':
        userid = req.session['userid']
        a = Suggest.objects.filter(todouser__userid=userid).count()
        return JsonResponse({'code': 1, 'todonum': a})
    elif a == 'detail':
        jyid = req.GET.get('jyid')
        a = Suggest.objects.filter(jyid=jyid)
        x = a.values('jyid', 'jylb__dickeyname', 'jynum', 'submittime', 'jyr__name', 'dqxz', 'jynr', 'jybm__partname', 'jyimg',
                     'qwxg', 'jyqy__name', 'jydd', 'jyzt', 'clr__name', 'jyfk', 'clcs', 'pgr__name', 'clms', 'jyimg2', 'sjwcsj', 'accept')[0]
        if x['jyimg'] != '':
            x['jyimg'] = x['jyimg'].split('?')
        else:
            x['jyimg'] = []
        for key in x:
            if x[key] == None:
                x[key] = ''
        x['flow'] = []
        for i in Suggestflow.objects.filter(suggest=a[0]).order_by('submittime'):
            x['flow'].append(
                {'name': i.user.name, 'action': i.action, 'submittime': i.submittime})
        return HttpResponse(json.dumps(x, cls=MyEncoder), content_type="application/json")
    elif a == 'del':
        jyid = req.GET.get('jyid')
        userid = req.session['userid']
        a = Suggest.objects.get(jyid=jyid)
        if User.objects.get(userid=userid).issuper == 1:
            a.delete()
            return JsonResponse({"code": 1})
        else:
            return JsonResponse({"code": 0})
    elif a == 'listsearch':
        userid = req.session['userid']
        startnum, endnum = fenye(req)
        a = Suggest.objects.filter(
            usecomp=User.objects.get(userid=userid).usecomp)
        if req.GET.get('qssj'):
            a = a.filter(submittime__gte=req.GET.get('qssj'))
        if req.GET.get('jssj'):
            a = a.filter(submittime__lte=req.GET.get('jssj'))
        total = a.count()
        a = a.order_by('-submittime')[startnum:endnum].values('jyid', 'jylb__dickeyname', 'jyr__name', 'jybm__partname',
                                                              'dqxz', 'jynr', 'jynum', 'jyzt', 'todouser__userid', 'todouser__name', 'jyqy__name', 'jydd', 'submittime', 'accept')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'exportexcel':
        userid = req.session['userid']
        companyid = getcompany(userid)
        a = Suggest.objects.filter(
            usecomp=Partment.objects.get(partid=companyid))
        if req.GET.get('qssj'):
            a = a.filter(jyrq__gte=req.GET.get('qssj'))
        if req.GET.get('jssj'):
            a = a.filter(jyrq__lte=req.GET.get('jssj'))
        res = exportxlsx('jy', a)
        return res
    elif a == 'exportword':
        id = req.GET.get('id')
        res = exportdoc('jy', id)
        return res

    elif a == 'update':  # 评估
        userid = req.session['userid']
        data = json.loads(req.body.decode('utf-8'))
        obj = Suggest.objects.get(jyid=data['jyid'])
        if data['jyzt'] == 1:
            if data['apcl'] == True:
                obj.jyzt = 2  # 处理
                user = User.objects.get(userid=data['clr'])
                obj.todouser = user
                obj.clr = user
                obj.jyfk = data['jyfk']
                obj.clcs = data['clcs']
                obj.save()
                Suggestflow.objects.create(suggest=obj, user=User.objects.get(
                    userid=userid), action='指派'+user.name+'处理')
                return JsonResponse({"code": 1})
            elif data['zjtr'] == True:
                user = User.objects.get(userid=data['npgr'])
                obj.todouser = user
                obj.pgr = user
                if 'jyfk' in data:
                    if data['jyfk']:
                        obj.jyfk = data['jyfk']
                obj.save()
                Suggestflow.objects.create(suggest=obj, user=User.objects.get(
                    userid=userid), action='转交'+user.name+'评估')
                return JsonResponse({"code": 1})
            elif 'accept' in data:
                if data['accept'] == 'no':
                    obj.jyzt = 4
                    obj.todouser = None
                    obj.jyfk = data['jyfk']
                    obj.accept = 0
                    obj.save()
                    Suggestflow.objects.create(
                        suggest=obj, user=User.objects.get(userid=userid), action='未采纳该建议')
                    return JsonResponse({"code": 1})
            else:
                obj.jyzt = 4
                obj.todouser = None
                obj.jyfk = data['jyfk']
                obj.save()
                Suggestflow.objects.create(
                    suggest=obj, user=User.objects.get(userid=userid), action='完成建议反馈')
                return JsonResponse({"code": 1})
        elif data['jyzt'] == 2:
            obj.jyzt = 3
            if 'clms' in data:
                obj.clms = data['clms']
            if 'jyimg2' in data:
                if data['jyimg2']:
                    obj.jyimg2 = data['jyimg2']
            obj.todouser = obj.pgr
            obj.sjwcsj = datetime.now()
            obj.save()
            Suggestflow.objects.create(
                suggest=obj, user=User.objects.get(userid=userid), action='提交处理结果')
            return JsonResponse({"code": 1})
        elif data['jyzt'] == 3:
            if data['shresult'] != 'reject':
                obj.jyzt = 4
                obj.todouser = None
                obj.save()
                Suggestflow.objects.create(
                    suggest=obj, user=User.objects.get(userid=userid), action='确认处理结果')
                return JsonResponse({"code": 1})
            else:
                obj.jyzt = 2
                obj.todouser = obj.clr
                if 'shyj' in data:
                    if data['shyj']:
                        obj.shyj = data['shyj']
                obj.save()
                Suggestflow.objects.create(
                    suggest=obj, user=User.objects.get(userid=userid), action='驳回处理结果')
                return JsonResponse({"code": 1})


# 特别操作
def apitool(req):
    a = req.GET.get('a')
    if a == 'updatecompany':
        for i in User.objects.all():
            companyid = getcompany(i.userid)
            i.usecomp = Partment.objects.get(partid=companyid)
            i.save()
    elif a == 'correctcompany':
        objs = Partment.objects.filter(iscompany=1)
        clist = []
        for i in objs:
            users = User.objects.filter(usecomp=i)
            if users.exists():
                pass
            else:
                i.delete()
                clist.append({'id': i.partid, 'name': i.partname})
        return JsonResponse({'code': 1, 'clist': clist})
    elif a == 'correct_train_qr':
        for i in Train.objects.all():
            i.checkqr = makeqr_train(
                'https://safeyun.ctcshe.com/miniprogram/checktrain?trainid='+str(i.trainid))
            i.save()
        return JsonResponse({'code': 1})
    elif a == 'correct_teacher':
        for i in Train.objects.all():
            if i.lecturer != None:
                i.teacher = i.lecturer.name
                i.save()
        return JsonResponse({'code': 1})
    elif a == 'correct_riskact_qr':
        for i in RiskAct.objects.all():
            i.qrcode = makeqr_riskact(
                'https://safeyun.ctcshe.com/miniprogram/riskact?id='+str(i.id))
            i.save()
        return JsonResponse({'code': 1})
    elif a == 'correct_examtest_qr':
        for i in ExamTest.objects.all():
            i.qrcode = makeqr_examtest(
                'https://safeyun.ctcshe.com/miniprogram/examtest?id='+str(i.id))
            i.save()
        return JsonResponse({'code': 1})
    elif a == 'correct_area_qr':
        for i in Area.objects.all():
            i.qrcode = makeqr_area(
                'https://safeyun.ctcshe.com/miniprogram/area?id='+str(i.id))
            i.save()
        return JsonResponse({'code': 1})
    elif a == 'correct_risk':
        for i in Risk.objects.all():
            cal_riskact_level(i.riskact)
        return JsonResponse({'code': 1})
    elif a == 'correct_riskarea':
        for i in RiskAct.objects.all():
            cal_area_risk_level(i.area)
        return JsonResponse({'code': 1})
    elif a == 'addright':
        menu = req.GET.get('menu')
        objs = Group.objects.all()
        if req.GET.get('company'):
            objs = objs.filter(usecomp__partid=req.GET.get('company'))
        for i in objs:
            menulist = i.menulist
            menulist.append(menu)
            if menu == 30:
                company = Partment.objects.get(partid=req.GET.get('company'))
                objs = Map.objects.filter(usecomp=company)
                if objs.exists():
                    pass
                else:
                    Map.objects.create(
                        name='默认地图', pic='/static/safesite/mystatic/images/snc.jpg', usecomp=company, default=1)
            i.menulist = list(set(menulist))
            i.save()
        return JsonResponse({"code": 1})
    elif a == 'correction':
        for i in Yjyc.objects.all():
            if i.ycz < 0:
                i.ycz = 0
                i.save()
            if round(i.yjz, 2) != i.troublevalue+i.trainvalue+i.drillvalue:
                i.yjz = round(i.troublevalue+i.trainvalue+i.drillvalue, 2)
                i.save()
        return JsonResponse({"code": 1})
    elif a == 'servertime':
        return JsonResponse({"code": 1, "year": datetime.now().year, "month": datetime.now().month})
    elif a == 'transfer':
        newpart = req.GET.get('part')
        username = req.GET.get('username')
        user = User.objects.get(username=username)
        for i in Partment.objects.filter(Q(aqy__contains=','+str(user.userid)+',')|Q(bmzg__contains=','+str(user.userid)+',')|Q(bsq__contains=','+str(user.userid)+',')):
            i.aqy = i.aqy.replace(','+str(user.userid)+',',',')
            i.bmzg = i.bmzg.replace(','+str(user.userid)+',',',')
            i.bsq = i.bsq.replace(','+str(user.userid)+',',',')
            i.save()
        part = Partment.objects.get(partid=newpart)
        if part.iscompany == 1:
            usecomp = part
        else:
            usecomp = Partment.objects.get(partid=part.partlink.split(',')[1])
        user.ubelongpart = part
        user.usecomp = usecomp
        user.save()
        for i in Group.objects.filter(usecomp=usecomp):
            i.users.remove(user)
        groupobj = Group.objects.filter(usecomp=usecomp, grouptype=3).first()
        groupobj.users.add(user)
        return JsonResponse({"code": 1})
    elif a == 'correctionzs':
        objs = Socertificate.objects.all()
        for i in objs:
            try:
                i.zszt = guoqi(i.yfsrq.strftime("%Y-%m-%d"))
                i.save()
            except:
                pass
        return JsonResponse({"code": 1})
    elif a == 'correctriskact':
        objs = RiskAct.objects.all()
        for i in objs:
            if Risk.objects.filter(riskact=i).exists():
                i.group = Risk.objects.filter(riskact=i)[0].group
                i.gkcj = Risk.objects.filter(riskact=i)[0].gkcj
                i.zrbm = Risk.objects.filter(riskact=i)[0].zrbm
                i.zrr = Risk.objects.filter(riskact=i)[0].zrr
                i.save()
        return JsonResponse({"code": 1})
    elif a == 'correct_png':
        objs = Trouble.objects.filter(
            Q(yhtp__contains='#') | Q(zghtp__contains='#'))
        for i in objs:
            i.yhtp = i.yhtp.replace('#', '')
            i.zghtp = i.zghtp.replace('#', '')
            i.save()
        return JsonResponse({"code": 1})
    elif a == 'correct_yjyc':
        for i in Partment.objects.filter(iscompany=1, deletemark=1):
            yjjs(i.partid)
            yjjs_gc(i.partid)
            yjjs_px(i.partid)
            yjjs_ws(i.partid)
            yjjs_yl(i.partid)
        return JsonResponse({"code": 1})
    elif a == 'correct_company':
        m = []
        for i in Partment.objects.filter(iscompany=1, deletemark=1):
            if User.objects.filter(usecomp=i).exists():
                pass
            else:
                x = {}
                x['name'] = i.partname
                x['id'] = i.partid
                m.append(x)
        return JsonResponse({'wxgs': m})
    elif a == 'correct_spjd':
        for i in Operationspjd.objects.all():
            if i.spr:
                i.sprs = [i.spr.userid]
                i.save()
        return JsonResponse({"code": 1})
    elif a == 'supercompany':
        supergroup = g_models.Group.objects.get(groupname='supergroup')
        for i in Partment.objects.filter(iscompany=1, deletemark=1):
            obj, create = g_models.Groupmember.objects.get_or_create(
                group=supergroup, member=i, defaults={'group': supergroup, 'member': i})
            if create:
                print(i.partname+'---加入supergroup')
        return JsonResponse({"code": 1})
    elif a == 'correct_password':
        for i in User.objects.filter(epassword=None):
            i.epassword = make_password(i.password)
            i.save()
        return JsonResponse({"code": 1})
    elif a == 'correct_operation':
        for i in Operation.objects.all():
            if i.zyzt['zyzt'] == '待关闭' or i.zyzt['zyzt'] == '已关闭':
                if 'jdmc' in i.zyzt:
                    i.zyzt['jdmc'] = ''
                    i.save()
        return JsonResponse({"code": 1})
    elif a == 'correct_examtest':
        for i in ExamTest.objects.filter(Q(starttime=None) | Q(endtime=None)):
            if i.starttime:
                pass
            else:
                print(i.id, 'start')
                i.starttime = i.createtime
                i.save()
            if i.endtime:
                pass
            else:
                print(i.id, 'end')
                i.endtime = i.createtime + timedelta(days=1)
                i.save()
        return JsonResponse({"code": 1})
    elif a == 'correct_bmzg':
        for i in Partment.objects.filter(Q(bmzg__contains=',,') | Q(aqy__contains=',,')):
            print(i)
            if ',,' in i.bmzg:
                i.bmzg = i.bmzg.replace(',,', ',')
                i.save()
            if ',,' in i.aqy:
                i.aqy = i.aqy.replace(',,', ',')
                i.save()
        return JsonResponse({"code": 1})
    elif a == 'correct_question':
        objs = Question.objects.filter(usecomps=F('nousecomps'))
        objs.update(deletemark=0)
        return JsonResponse({"code": 1})
    elif a == 'correct_menulist':
        for i in Group.objects.all():
            if i.menulink:
                i.menulist = list(set(list(filter(None, i.menulink.split(',')))))
                i.save()
        return JsonResponse({"code": 1})
    elif a == 'correct_menuhas':
        buttons = Menu.objects.filter(type=2)
        for group in Group.objects.all():
            menulist = group.menulist
            for button in buttons:
                if button.parentid.menuid in menulist: #如果菜单在所拥有权限内
                    menulist.append(button.menuid)
            group.menulist = list(set(menulist))
            group.save()
        return JsonResponse({"code": 1})
    elif a == 'correct_user_delete': #删除用户
        for user in User.objects.filter(deletemark=0):
            bgroups = user.userg.all()#该用户所属用户组
            for i in bgroups:
                i.users.remove(user)
            for i in Partment.objects.filter(Q(aqy__contains=','+str(user.userid)+',')|Q(bmzg__contains=','+str(user.userid)+',')|Q(bsq__contains=','+str(user.userid)+',')):#从部门权限中移除
                i.aqy = i.aqy.replace(','+str(user.userid)+',',',')
                i.bmzg = i.bmzg.replace(','+str(user.userid)+',',',')
                i.bsq = i.bsq.replace(','+str(user.userid)+',',',')
                i.save()
        return JsonResponse({"code": 1})
    elif a == 'correct_company_role':
        for i in Partment.objects.filter(iscompany=1):
            i.role=Role.objects.get(id=1)
            i.save()
        return JsonResponse({"code": 1})
    elif a == 'correct_riskgroups':
        for i in Group.objects.filter(menulist__contains=[38]):
            menulist = i.menulist
            menulist.append(181)
            i.menulist = menulist
            i.save()
        return JsonResponse({"code": 1})
    elif a == 'correct_examtesttook':
        for i in ExamTestDetail.objects.exclude(starttime=None,endtime=None):
            i.took = (i.endtime-i.starttime).total_seconds()
            i.save()
        return JsonResponse({"code":1})
    elif a == 'correct_map':
        for i in Partment.objects.filter(iscompany=1):
            obj,created = Map.objects.get_or_create(usecomp=i,defaults={'name':'默认地图','pic':'/static/safesite/mystatic/images/snc.jpg','usecomp':i})
            if created:
                print(i.partname + '建立默认地图')
        return JsonResponse({"code":1})
    elif a == 'correct_tzzs':
        updateTzzs()
        return JsonResponse({"code":1})
    elif a == 'correct_ljzg':
        objs = Trouble.objects.filter(yhzt=6, deletemark=1, zgbm__isnull=True, zgr__isnull=True)
        # print(Trouble.objects.filter(deletemark=1).count(), objs.count())
        objs.update(zgbm=F('fxbm'), zgr=F('fxr'))
        return JsonResponse({"code":1})
    elif a == 'correct_userprofile':
        print(Userprofile.objects.filter(user__isnull=True).count())
        # Userprofile.objects.filter(gender='null').update(gender='男')
        # Userprofile.objects.filter(realname='null').update(realname='')
        # Userprofile.objects.filter(cardnum='null').update(cardnum='')
        return JsonResponse({"code":1})
    elif a == 'correct_questioncat':
        # print(Questioncat.objects.filter(usecomp__partid=2184).delete())
        print(Question.objects.filter(questioncat__name='冬季四防安全生产知识').count())
        # Questioncat.objects.filter(usecomp__partname='广安厂').update(parent=None, link=',', deletemark=1)
        # print(Questioncat.objects.filter(name='冬季四防安全生产知识').values('usecomp__partname'))
        return JsonResponse({"code":1})
            
                    





def apinotice(req):
    a = req.GET.get('a')
    if a == 'add':
        userid = req.session['userid']
        oneuser = User.objects.get(userid=userid)
        obj = Notice()
        data = json.loads(req.body.decode('utf-8'))
        obj.title = data['title']
        obj.content = data['content']
        obj.pubuser = oneuser
        obj.pubpart = oneuser.ubelongpart
        obj.usecomps = ',' + str(oneuser.usecomp.partid)+','
        if data['tzfile']:
            obj.material = '?'.join(data['tzfile'])
        obj.save()
        if data['tousers']:
            obj.isgg = 0
            obj.save()
            ulist = data['tousers'].split(',')
            b = []
            for i in ulist:
                x = User.objects.get(userid=i)
                m = Noticeto(noticeid=obj, receiver=x)
                m.save()
                b.append(x.openid)
            postdict = {
                'touser': '',
                'template_id': 'lOuwSE67vZC3ZVFYPZvz2eb7JdFxqx7ysMFkXrYmYh0',
                "miniprogram": {"appid": "wx5c39b569f01c27db"},
                'data': {
                    'first': {
                        'value': '公司通知:'
                    },
                    'keyword1': {
                        'value': obj.title
                    },
                    'keyword2': {
                        'value': obj.submittime
                    },
                    'keyword3': {
                        'value': oneuser.name
                    },
                    'remark': {
                        'value': '请及时查看阅读'
                    }
                }
            }
            send_wechatmsgs.delay(postdict, b)
        return JsonResponse({"code": 1})
    elif a == 'edit':
        data = json.loads(req.body.decode('utf-8'))
        obj = Notice.objects.get(id=data['id'])
        obj.title = data['title']
        obj.content = data['content']
        if data['tzfile']:
            obj.material = '?'.join(data['tzfile'])
        obj.modifytime = datetime.now()
        obj.save()
        return JsonResponse({"code": 1})
    elif a == 'listall':
        userid = req.session['userid']
        usecomp = User.objects.get(userid=userid).usecomp
        a = (Notice.objects.filter(usecomps__contains=',' + str(usecomp.partid)+',', deletemark=1) |
             Notice.objects.filter(usecomps__contains=',1,', deletemark=1, isgg=1)).distinct().order_by('-submittime')
        total = a.count()
        startnum, endnum = fenye(req)
        a = a[startnum:endnum].values('id', 'title', 'pubpart__partname', 'pubuser__name',
                                      'pubuser__userid', 'submittime', 'modifytime', 'reads', 'isgg')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'listpublic':
        userid = req.session['userid']
        usecomp = User.objects.get(userid=userid).usecomp
        a = (Notice.objects.filter(usecomps__contains=',' + str(usecomp.partid)+',', deletemark=1, isgg=1) |
             Notice.objects.filter(usecomps__contains=',1,', deletemark=1, isgg=1)).distinct().order_by('-submittime')
        total = a.count()
        startnum, endnum = fenye(req)
        a = a[startnum:endnum].values('id', 'title', 'pubpart__partname', 'pubuser__name',
                                      'pubuser__userid', 'submittime', 'modifytime', 'reads', 'isgg')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'listdata':
        userid = req.session['userid']
        usecomp = User.objects.get(userid=userid).usecomp
        a = (Notice.objects.filter(usecomps__contains=',' + str(usecomp.partid)+',', deletemark=1, isgg=1) |
             Notice.objects.filter(usecomps__contains=',1,', deletemark=1, isgg=1))
        if req.GET.get('search'):
            a = a.filter(title__contains=req.GET.get('search'))
        a = a.distinct().order_by('-submittime')
        total = a.count()
        startnum, endnum = fenye(req)
        a = a[startnum:endnum].values('id', 'title', 'pubpart__partname', 'pubuser__name',
                                      'pubuser__userid', 'submittime', 'modifytime', 'reads', 'isgg')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'listtodomain':
        userid = req.session['userid']
        a = Noticeto.objects.filter(receiver=User.objects.get(userid=userid)).values(
            'noticeid').annotate(num=Sum('read')).order_by('-noticeid__submittime')
        total = a.count()
        startnum, endnum = fenye(req)
        a = a[startnum:endnum].values('noticeid__id', 'noticeid__title', 'num',
                                      'noticeid__submittime', 'noticeid__pubpart__partname', 'noticeid__pubuser__name')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'listtome':
        userid = req.session['userid']
        b = Noticeto.objects.filter(receiver=User.objects.get(
            userid=userid), noticeid__deletemark=1)
        a = b.order_by('-noticeid__submittime')
        total = a.count()
        noread = b.filter(read=0).count()
        startnum, endnum = fenye(req)
        a = a[startnum:endnum].values('noticeid__id', 'noticeid__title', 'read',
                                      'noticeid__submittime', 'noticeid__pubpart__partname', 'noticeid__pubuser__name')
        return HttpResponse(json.dumps({'total': total, 'rows': list(a), 'noread': noread, 'code': 1}, cls=MyEncoder), content_type="application/json")
    elif a == 'noreadnum':
        userid = req.session['userid']
        b = Noticeto.objects.filter(receiver=User.objects.get(
            userid=userid), noticeid__deletemark=1)
        noread = b.filter(read=0).count()
        return JsonResponse({'noread': noread})
    elif a == 'listtodo':
        userid = req.session['userid']
        userobj = User.objects.get(userid=userid)
        usecomp = userobj.usecomp
        a = (Notice.objects.filter(tousers=userobj, deletemark=1) | Notice.objects.filter(usecomps__contains=',' + str(usecomp.partid) +
                                                                                          ',', deletemark=1) | Notice.objects.filter(usecomps__contains=',1,', deletemark=1, isgg=1)).distinct().order_by('-submittime')
        total = a.count()
        startnum, endnum = fenye(req)
        a = a[startnum:endnum].values(
            'id', 'title', 'pubpart__partname', 'pubuser__name', 'submittime', 'reads')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'listself':
        userid = req.session['userid']
        userobj = User.objects.get(userid=userid)
        a = Notice.objects.filter(
            pubuser=userobj, deletemark=1).order_by('-submittime')
        total = a.count()
        startnum, endnum = fenye(req)
        a = a[startnum:endnum].values(
            'id', 'title', 'pubpart__partname', 'pubuser__name', 'submittime', 'reads')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'detail':
        id = req.GET.get('id')
        userid = req.session['userid']
        a = Notice.objects.filter(id=id)
        aobj = a[0]
        aobj.reads = int(aobj.reads) + 1
        aobj.save()
        x = a.values('id', 'title', 'pubpart__partname', 'pubuser__name',
                     'submittime', 'modifytime', 'material', 'content', 'isgg', 'reads')[0]
        if x['material']:
            x['material'] = x['material'].split('?')
        else:
            x['material'] = []
        for key in x:
            if x[key] == None:
                x[key] = ''
        data = {}
        data['notice'] = x
        readobj = Noticeto.objects.filter(noticeid__in=a)
        reads = readobj.values('receiver__name', 'read')
        data['reads'] = list(reads)
        data['readpeople'] = readobj.exclude(read=0).count()
        data['readsnum'] = readobj.aggregate(num=Sum('read')).get('num') or 0

        try:
            toobj = Noticeto.objects.get(
                noticeid__id=id, receiver__userid=userid)
            toobj.read = int(toobj.read) + 1
            toobj.save()
        except:
            pass
        return JsonResponse(data)
    elif a == 'del':
        id = req.GET.get('id')
        userid = req.session['userid']
        a = Notice.objects.get(id=id)
        if a.usecomps != ',1,' and User.objects.get(userid=userid).issuper == 1:
            a.deletemark = 0
            a.save()
            return JsonResponse({"code": 1})
        elif userid == 8:
            a.deletemark = 0
            a.save()
            return JsonResponse({"code": 1})
        else:
            return JsonResponse({"code": 0})
    elif a == 'listsearch':
        userid = req.session['userid']
        startnum, endnum = fenye(req)
        a = Notice.objects.filter(
            usecomp=User.objects.get(userid=userid).usecomp)
        # if req.GET.get('fsbm'):
        #     parts = Partment.objects.filter(partlink__contains=','+req.GET.get('fsbm')+',')|Partment.objects.filter(partid=req.GET.get('fsbm'))
        #     a = a.filter(misspart__in = parts)
        if req.GET.get('qssj'):
            a = a.filter(submittime__gte=req.GET.get('qssj'))
        if req.GET.get('jssj'):
            a = a.filter(submittime__lte=req.GET.get('jssj'))
        total = a.count()
        a = a.order_by('-submittime')[startnum:endnum].values('id',
                                                              'title', 'pubpart__partname', 'pubuser__name', 'submittime')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'exportexcel':
        userid = req.session['userid']
        companyid = getcompany(userid)
        a = Miss.objects.filter(usecomp=Partment.objects.get(
            partid=companyid), deletemark=1)
        if req.GET.get('fsbm'):
            parts = Partment.objects.filter(partlink__contains=','+req.GET.get(
                'fsbm')+',') | Partment.objects.filter(partid=req.GET.get('fsbm'))
            a = a.filter(misspart__in=parts)
        if req.GET.get('qssj'):
            a = a.filter(misstime__gte=req.GET.get('qssj'))
        if req.GET.get('jssj'):
            a = a.filter(misstime__lte=req.GET.get('jssj'))
        v = exportxlsx('ws', a)
        return JsonResponse({"code": 1, 'downloadurl': v})


def apioperation(req):
    a = req.GET.get('a')
    userid = req.session['userid']
    if a == 'add':
        userid = req.session['userid']
        oneuser = User.objects.get(userid=userid)
        obj = Operation()
        data = json.loads(req.body.decode('utf-8'))
        obj.zydd = data['zydd']
        obj.zynr = data['zynr']
        obj.kssj = data['kssj']
        obj.jssj = data['jssj']
        if 'zyqy' in data:
            obj.zyqy = Area.objects.get(
                id=data['zyqy']) if data['zyqy'] else None
        obj.zylx = Dickey.objects.get(dickeyid=data['zylx'])
        obj.zybm = oneuser.ubelongpart
        if 'zybm' in data:
            obj.zybm = Partment.objects.get(partid=data['zybm'])
        obj.sdbm = Partment.objects.get(partid=data['sdbm'])
        obj.zyfzr = oneuser
        if 'zyfzr' in data:
            obj.zyfzr = User.objects.get(userid=data['zyfzr'])
        obj.zynum = 'ZY'+time.strftime('%Y%m%d%H%M%S')
        obj.usecomp = oneuser.usecomp
        if 'splc' in data:
            if data['splc']==0:#无审批
                obj.zyzt = {'zyzt':'待关闭','index':0,'splc':0}
                obj.save()
                for i in data['zyry']:
                    Operzyry.objects.create(oper=obj, operzyry=User.objects.get(userid=i), checked=1)
                return JsonResponse({"code": 1})
        if 'zyimg' in data:
            obj.zyimg = '?'.join(data['zyimg'])
        obj.fxcs = '?'.join(map(str, data['fxcs']))
        obj.zyzt = {'zyzt': '确认中', 'index': 0}
        splc = []
        if 'spr1s' in data:
            spr1s = [data['spr1s']]
        else:
            spr1s = getsprs(userid, obj.zybm)
        if 'spr2s' in data:
            spr2s = [data['spr2s']]
        else:
            spr2s = getsprs(userid, obj.sdbm)
        splc.append({'jdmc': '作业负责人审批', 'sprs': [userid]})
        splc.append({'jdmc': '作业部门审批', 'sprs': spr1s})
        splc.append({'jdmc': '属地部门审批', 'sprs': spr2s})
        for i in Operationspjd.objects.filter(zylx=obj.zylx, usecomp=Partment.objects.get(partid=getcompany(userid))).order_by('id'):
            splc.append({'jdmc': i.jdmc, 'sprs': i.sprs})
        obj.zyzt['splc'] = splc
        obj.save()
        # Operspxq.objects.create(oper=obj,jdmc='作业负责人审批',spr=obj.zyfzr,checked=1,spbm=obj.zyfzr.ubelongpart)
        b = []  # 发送通知
        for i in data['zyry']:
            x = User.objects.get(userid=i)
            if int(userid) == int(i):  # 申请人包含作业人直接确认
                Operzyry.objects.create(oper=obj, operzyry=x, checked=1)
            else:
                Operzyry.objects.create(oper=obj, operzyry=x)
                b.append(x.openid)
        if b:
            pass
        else:  # 工作人员全部确认
            obj.zyzt['zyzt'] = '审批中'
            obj.zyzt['index'] = 0
            index = obj.zyzt['index']
            sprs = []  # 初始化审批人列表
            if 'sprs' in obj.zyzt['splc'][index]:
                sprs = obj.zyzt['splc'][index]['sprs']
            else:
                sprs = [obj.zyzt['splc'][index]['spr']]
            jdmc = obj.zyzt['splc'][index]['jdmc']
            obj.zyzt['jdmc'] = jdmc
            obj.todousers = sprs
            obj.save()
            postdict = {
                'touser': '',
                'template_id': 'lOuwSE67vZC3ZVFYPZvz2eb7JdFxqx7ysMFkXrYmYh0',
                'miniprogram': {'appid': 'wx5c39b569f01c27db'},
                'data': {
                    'first': {
                        'value': obj.zylx.dickeyname + '作业审批,审批节点:' + obj.zyzt['jdmc']
                    },
                    'keyword1': {
                        'value': obj.zynr
                    },
                    'keyword2': {
                        'value': obj.kssj
                    },
                    'keyword3': {
                        'value': obj.zydd
                    },
                    'remark': {
                        'value': '请您及时完成审批!'
                    }
                }
            }
            tolist = list(User.objects.filter(
                userid__in=sprs).values_list('openid', flat=True))
            send_wechatmsgs.delay(postdict, tolist)
            return JsonResponse({"code": 1})
        postdict = {
            'touser': '',
            'template_id': 'lOuwSE67vZC3ZVFYPZvz2eb7JdFxqx7ysMFkXrYmYh0',
            "miniprogram": {"appid": "wx5c39b569f01c27db"},
            'data': {
                'first': {
                    'value': obj.zylx.dickeyname + '作业通知:'
                },
                'keyword1': {
                    'value': obj.zynr
                },
                'keyword2': {
                    'value': obj.kssj
                },
                'keyword3': {
                    'value': obj.zydd
                },
                'remark': {
                    'value': obj.zyfzr.name+'为作业负责人,请确认参与作业'
                }
            }
        }
        send_wechatmsgs.delay(postdict, b)
        return JsonResponse({"code": 1})
    elif a == 'listall':
        userid = req.session['userid']
        usecomp = User.objects.get(userid=userid).usecomp
        a = Operation.objects.filter(
            usecomp=usecomp, deletemark=1).order_by('-submittime')
        if req.GET.get('zyqy', False):
            a = a.filter(zyqy__id=req.GET.get('zyqy'))
        if req.GET.get('qssj', None):
            a = a.filter(kssj__gte=req.GET.get('qssj'))
        if req.GET.get('jssj', None):
            a = a.filter(jssj__lte=req.GET.get('jssj'))
        total = a.count()
        startnum, endnum = fenye(req)
        a = a[startnum:endnum].values('zyid', 'zylx__dickeyname', 'zynum',
                                      'zyfzr__name', 'zynr', 'zyzt', 'submittime', 'todouser__name','zyqy__name')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'liston':
        userid = req.session['userid']
        usecomp = User.objects.get(userid=userid).usecomp
        objs = Operation.objects.filter(
            usecomp=usecomp, deletemark=1).exclude(zyzt__zyzt='已关闭')
        total = objs.count()
        objs = objs.values('zyid', 'zylx__dickeyname', 'zynum','zyfzr__name', 'zynr','zyqy__name','zyqy__id','zybm__partname','kssj').annotate(num=Count('zyry'))
        return HttpResponse(transjson(total, objs), content_type="application/json")
    elif a == 'exportexcel':
        userid = req.session['userid']
        usecomp = User.objects.get(userid=userid).usecomp
        a = Operation.objects.filter(
            usecomp=usecomp, deletemark=1)
        if req.GET.get('qssj', None):
            a = a.filter(kssj__gte=req.GET.get('qssj'))
        if req.GET.get('jssj', None):
            a = a.filter(jssj__lte=req.GET.get('jssj'))
        a = a.order_by('-submittime')
        res = exportxlsx('zy', a)
        return res
    elif a == 'listtodo':
        userid = req.session['userid']
        usecomp = User.objects.get(userid=userid).usecomp
        i = []
        b = Operzyry.objects.filter(operzyry__userid=userid, checked=0)
        for x in b:
            i.append(x.oper.zyid)
        a = Operation.objects.filter(Q(usecomp=usecomp), Q(deletemark=1), Q(zyid__in=i)|Q(todouser__userid=userid)|Q(todousers__contains=[userid])).order_by('-submittime')
        total = a.count()
        startnum, endnum = fenye(req)
        a = a[startnum:endnum].values(
            'zyid', 'zylx__dickeyname', 'zynum', 'zyfzr__name', 'zynr', 'zyzt', 'submittime','zyqy__name')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'listself':
        userid = req.session['userid']
        usecomp = User.objects.get(userid=userid).usecomp
        a = Operation.objects.filter(
            usecomp=usecomp, deletemark=1, zyfzr__userid=userid).order_by('-submittime')
        total = a.count()
        startnum, endnum = fenye(req)
        a = a[startnum:endnum].values('zyid', 'zylx__dickeyname', 'zynum',
                                      'zyfzr__name', 'zynr', 'zyzt', 'submittime', 'todouser__name','zyqy__name')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'detail':
        zyid = req.GET.get('zyid')
        a = Operation.objects.filter(zyid=zyid)
        x = a.values('zyid', 'zydd', 'zylx__dickeyname', 'zynum', 'zyfzr__name', 'zynr', 'zyzt', 'zyimg',
                     'submittime', 'zybm__partname', 'sdbm__partname', 'kssj', 'jssj', 'fxcs', 'zyimg2','zyqy__name')[0]
        if x['zyzt']['splc']:
            for i in x['zyzt']['splc']:
                i['sprs'] = ','.join(list(User.objects.filter(
                    userid__in=i['sprs']).values_list('name', flat=True)))
            if x['zyimg'] != '':
                x['zyimg'] = x['zyimg'].split('?')
            else:
                x['zyimg'] = []
            if x['zyimg2'] != '':
                x['zyimg2'] = x['zyimg2'].split('?')
            else:
                x['zyimg2'] = []
            x['fxcs'] = list(Fxcs.objects.filter(
                id__in=x['fxcs'].split('?')).values('id', 'fxfx', 'aqcs', 'cslx'))
            # 确认详情
            qrxqobjs = Operzyry.objects.filter(
                oper=Operation.objects.get(zyid=zyid))
            qrxq = qrxqobjs.values('operzyry__name', 'checked')
            x['qrxq'] = list(qrxq)
            x['zyry'] = ','.join(
                list(qrxqobjs.values_list('operzyry__name', flat=True)))
            # 审批详情
            spxq = Operspxq.objects.filter(oper=Operation.objects.get(zyid=zyid)).order_by(
                'submittime').values('jdmc', 'spbm__partname', 'spr__name', 'submittime', 'checked')
            x['spxq'] = list(spxq)
            return HttpResponse(json.dumps(x, cls=MyEncoder), content_type="application/json")
        else:
            return HttpResponse(json.dumps(x, cls=MyEncoder), content_type="application/json")
    elif a == 'exportword':
        zyid = req.GET.get('id')
        res = exportdoc('zy', zyid)
        return res
    elif a == 'qrzy':
        userid = req.session['userid']
        data = json.loads(req.body.decode('utf-8'))
        zyid = data['zyid']
        obj = Operation.objects.get(zyid=zyid)
        Operzyry.objects.filter(
            oper__zyid=zyid, operzyry__userid=userid).update(checked=1)
        if Operzyry.objects.filter(oper__zyid=zyid, checked=0).exists():
            pass
        else:  # 工作人员全部确认
            nowzt = obj.zyzt
            obj.zyzt['zyzt'] = '审批中'
            obj.zyzt['index'] = 0
            index = obj.zyzt['index']
            spruser = User.objects.get(userid=userid)
            sprs = []  # 初始化审批人列表
            if 'sprs' in obj.zyzt['splc'][index]:
                sprs = obj.zyzt['splc'][index]['sprs']
            else:
                sprs = [obj.zyzt['splc'][index]['spr']]
            jdmc = obj.zyzt['splc'][index]['jdmc']
            obj.zyzt['jdmc'] = jdmc
            obj.todousers = sprs
            obj.save()
            postdict = {
                'touser': '',
                'template_id': 'lOuwSE67vZC3ZVFYPZvz2eb7JdFxqx7ysMFkXrYmYh0',
                'miniprogram': {'appid': 'wx5c39b569f01c27db'},
                'data': {
                    'first': {
                        'value': obj.zylx.dickeyname + '作业审批,审批节点:' + obj.zyzt['jdmc']
                    },
                    'keyword1': {
                        'value': obj.zynr
                    },
                    'keyword2': {
                        'value': obj.kssj
                    },
                    'keyword3': {
                        'value': obj.zydd
                    },
                    'remark': {
                        'value': '请您及时完成审批!'
                    }
                }
            }
            tolist = list(User.objects.filter(
                userid__in=sprs).values_list('openid', flat=True))
            send_wechatmsgs.delay(postdict, tolist)
            return JsonResponse({"code": 1})
    elif a == 'spzy':
        data = json.loads(req.body.decode('utf-8'))
        zyid = data['zyid']
        obj = Operation.objects.get(zyid=zyid)
        oldtodo = obj.todousers
        oldjdmc = obj.zyzt['jdmc']
        oldindex = obj.zyzt['index']
        nextindex = obj.zyzt['index']+1
        spruser = User.objects.get(userid=userid)
        if oldindex == 0:
            spr1 = data['spr1'] if 'spr1' in data else None
            spr2 = data['spr2'] if 'spr2' in data else None
            if spr1:
                obj.zyzt['splc'][1]['sprs'] = [spr1]  # 作业部门审批人
            if spr2:
                obj.zyzt['splc'][2]['sprs'] = [spr2]  # 属地部门审批人
        Operspxq.objects.create(
            oper=obj, jdmc=obj.zyzt['splc'][oldindex]['jdmc'], spr=spruser, checked=1, spbm=spruser.ubelongpart)  # 审批该步
        while nextindex < len(obj.zyzt['splc']):
            nextsplc = obj.zyzt['splc'][nextindex]
            if userid in nextsplc['sprs']:  # 本人可审批直接跳过下一步
                Operspxq.objects.create(
                    oper=obj, jdmc=nextsplc['jdmc'], spr=spruser, checked=1, spbm=spruser.ubelongpart)
            else:
                obj.zyzt['zyzt'] = '审批中'
                obj.zyzt['index'] = nextindex
                obj.zyzt['jdmc'] = nextsplc['jdmc']
                obj.todousers = nextsplc['sprs']
                obj.save()
                tolist = list(User.objects.filter(
                    userid__in=nextsplc['sprs']).values_list('openid', flat=True))
                toliststr = ','.join(list(User.objects.filter(
                    userid__in=nextsplc['sprs']).values_list('name', flat=True)))
                postdict = {
                    'touser': '',
                    'template_id': 'lOuwSE67vZC3ZVFYPZvz2eb7JdFxqx7ysMFkXrYmYh0',
                    'miniprogram': {'appid': 'wx5c39b569f01c27db'},
                    'data': {
                        'first': {
                            'value': obj.zylx.dickeyname + '作业审批,审批节点:' + obj.zyzt['jdmc']
                        },
                        'keyword1': {
                            'value': obj.zynr
                        },
                        'keyword2': {
                            'value': obj.kssj
                        },
                        'keyword3': {
                            'value': obj.zydd
                        },
                        'remark': {
                            'value': '请您及时完成审批!可审批人:'+toliststr
                        }
                    }
                }
                send_wechatmsgs.delay(postdict, tolist)
                return JsonResponse({"code": 1})
            nextindex = nextindex + 1
        if 'zjsp' in data:  # 转交上级审批
            if spruser.ubelongpart.parentid:
                newsprs = getsprs(userid, spruser.ubelongpart.parentid)
            else:
                newsprs = getsprs(userid, spruser.usecomp)
            # newsprs = data['newsprs']#新审批人
            obj.zyzt['jdmc'] = '上级审批'
            obj.zyzt['index'] = nextindex
            obj.todousers = newsprs
            obj.zyzt['splc'].insert(
                nextindex, {'jdmc': '上级审批', 'sprs': newsprs})
            obj.save()
            tolist = list(User.objects.filter(
                userid__in=newsprs).values_list('openid', flat=True))
            toliststr = ','.join(list(User.objects.filter(
                userid__in=newsprs).values_list('name', flat=True)))
            postdict = {
                'touser': '',
                'template_id': 'lOuwSE67vZC3ZVFYPZvz2eb7JdFxqx7ysMFkXrYmYh0',
                'miniprogram': {'appid': 'wx5c39b569f01c27db'},
                'data': {
                    'first': {
                        'value': obj.zylx.dickeyname + '作业审批,审批节点:' + obj.zyzt['jdmc']
                    },
                    'keyword1': {
                        'value': obj.zynr
                    },
                    'keyword2': {
                        'value': obj.kssj
                    },
                    'keyword3': {
                        'value': obj.zydd
                    },
                    'remark': {
                        'value': '请您及时完成审批!可审批人:'+toliststr
                    }
                }
            }
            send_wechatmsgs.delay(postdict, tolist)
            Operspxq.objects.create(
                oper=obj, jdmc=obj.zyzt['splc'][nextindex-1]['jdmc'], spr=spruser, checked=2, spbm=spruser.ubelongpart)
            return JsonResponse({"code": 1})
        obj.zyzt['zyzt'] = '待关闭'
        obj.zyzt['jdmc'] = ''
        obj.zyzt['index'] = nextindex
        obj.todouser = None
        obj.todousers = [obj.zyfzr.userid]
        obj.save()
        postdict = {
            'touser': obj.zyfzr.openid,
            'template_id': 'lOuwSE67vZC3ZVFYPZvz2eb7JdFxqx7ysMFkXrYmYh0',
            'miniprogram': {'appid': 'wx5c39b569f01c27db'},
            'data': {
                'first': {
                    'value': obj.zylx.dickeyname + '作业审批通过:'
                },
                'keyword1': {
                    'value': obj.zynr
                },
                'keyword2': {
                    'value': obj.kssj
                },
                'keyword3': {
                    'value': obj.zydd
                },
                'remark': {
                    'value': '你是作业负责人,可以开始作业,作业完成请及时关闭!'
                }
            }
        }
        # Operspxq.objects.create(oper=obj,jdmc=obj.zyzt['splc'][nextindex-1]['jdmc'],spr=spruser,checked=1,spbm=spruser.ubelongpart)
        send_wechatmsg.delay(postdict)
        return JsonResponse({"code": 1})
    elif a == 'gbzy':  # 关闭作业
        data = json.loads(req.body.decode('utf-8'))
        # print(data)
        user = User.objects.get(userid=userid)
        zyid = data['zyid']
        obj = Operation.objects.get(zyid=zyid)
        if obj.zyfzr == user:
            if 'zyimg2' in data:
                zyimg2 = data['zyimg2']
                obj.zyimg2 = '?'.join(zyimg2)
            obj.zyzt['zyzt'] = '已关闭'
            obj.zyzt['jdmc'] = ''
            obj.todouser = None
            obj.todousers = None
            obj.save()
        else:
            return JsonResponse({"code": 0,"msg":'非作业负责人不可关闭'})
        return JsonResponse({"code": 1})
    elif a == 'todonum':
        userid = req.session['userid']
        i = []
        b = Operzyry.objects.filter(operzyry__userid=userid, checked=0)
        c = Operation.objects.filter(Q(todouser__userid=userid) | Q(todousers__contains=[userid]),Q(deletemark=1))
        for x in b:
            i.append(x.oper.zyid)
        for x in c:
            i.append(x.zyid)
        i = list(set(i))
        return JsonResponse({"code": 1, "todonum": len(i)})
    elif a == 'del':
        zyid = req.GET.get('zyid')
        userid = req.session['userid']
        a = Operation.objects.get(zyid=zyid)
        if User.objects.get(userid=userid).issuper == 1:
            a.deletemark = 0
            a.save()
            return JsonResponse({"code": 1})
        else:
            return JsonResponse({"code": 0})
    elif a == 'getspr12':
        zybm = User.objects.get(userid=userid).ubelongpart  # 作业部门
        sdbm = Partment.objects.get(
            partid=json.loads(req.body.decode('utf-8'))['sdbm'])
        spr1 = getsprs2(userid, zybm)
        spr2 = getsprs2(userid, sdbm)
        spr1Array = User.objects.filter(userid__in=spr1).annotate(
            value=F('userid'), text=F('name')).values('value', 'text')
        spr2Array = User.objects.filter(userid__in=spr2).annotate(
            value=F('userid'), text=F('name')).values('value', 'text')
        return JsonResponse({"code": 1, "data": {'spr1Array': list(spr1Array), 'spr2Array': list(spr2Array)}})



def apifxcs(req):
    a = req.GET.get('a')
    if a == 'listall':
        if req.GET.get('zylx'):
            zylx = req.GET.get('zylx')
            userid = req.session['userid']
            companyid = getcompany(userid)
            a = Fxcs.objects.filter(
                zylx=Dickey.objects.get(dickeyid=zylx), deletemark=1)
            a = (a.filter(usecomps__contains=',1,') | a.filter(
                usecomps__contains=','+companyid+',')).exclude(nousecomps__contains=','+companyid+',')
            total = a.count()
            a = a.values('id', 'fxfx', 'aqcs', 'cslx')
            return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'detail':
        fxid = req.GET.get('fxid')
        obj = Fxcs.objects.filter(id=fxid).values('id','fxfx', 'aqcs', 'cslx')[0]
        return JsonResponse({"code": 1, "data":obj})
    elif a == 'add':
        data = json.loads(req.body.decode('utf-8'))
        userid = req.session['userid']
        companyid = getcompany(userid)
        if data['zylx']:
            zylx = data['zylx']
            fxfx = data['fxfx']
            aqcs = data['aqcs']
            cslx = data['cslx']
            Fxcs.objects.create(zylx=Dickey.objects.get(
                dickeyid=zylx), fxfx=fxfx, aqcs=aqcs, cslx=cslx, usecomps=','+companyid+',')
            return JsonResponse({"code": 1})
    elif a == 'edit':
        data = json.loads(req.body.decode('utf-8'))
        fxid = data['id']
        userid = req.session['userid']
        companyid = getcompany(userid)
        if Fxcs.objects.get(id=fxid).usecomps == ','+ companyid +',':
            obj = Fxcs.objects.get(id=fxid)
            obj.fxfx = data['fxfx']
            obj.aqcs = data['aqcs']
            obj.cslx = data['cslx']
            obj.save()
            return JsonResponse({"code": 1})
        else:
            return JsonResponse({"code": 0})
    elif a == 'del':
        userid = req.session['userid']
        companyid = getcompany(userid)
        fxid = req.GET.get('id')
        if User.objects.get(userid=userid).issuper == 1:
            a = Fxcs.objects.get(id=fxid)
            nl = a.nousecomps.split(',')
            nl.append(companyid)
            nl = ','+','.join(list(filter(None, nl)))+','
            a.nousecomps = nl
            a.save()
            return JsonResponse({"code": 1})
        else:
            return JsonResponse({"code": 0})


def apioperationspjd(req):
    a = req.GET.get('a')
    if a == 'add':
        data = json.loads(req.body.decode('utf-8'))
        userid = req.session['userid']
        companyid = getcompany(userid)
        if data['zylx']:
            zylx = Dickey.objects.get(dickeyid=data['zylx'])
            jdmc = data['jdmc']
            spbm = Partment.objects.get(partid=data['spbm'])
            #spr = User.objects.get(userid=data['spr'])
            sprs = data['spr']
            Operationspjd.objects.create(
                jdmc=jdmc, zylx=zylx, spbm=spbm, sprs=sprs, usecomp=Partment.objects.get(partid=companyid))
            return JsonResponse({"code": 1})
    elif a == 'listall':
        if req.GET.get('zylx'):
            zylx = req.GET.get('zylx')
            userid = req.session['userid']
            companyid = getcompany(userid)
            a = Operationspjd.objects.filter(zylx=Dickey.objects.get(
                dickeyid=zylx), usecomp=Partment.objects.get(partid=companyid)).order_by('id')
            total = a.count()
            a = a.values('id', 'jdmc', 'spbm__partname', 'sprs')
            for i in a:
                i['sprnames'] = list(User.objects.filter(
                    userid__in=i['sprs']).values_list('name', flat=True))
            return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'del':
        id = req.GET.get('id')
        userid = req.session['userid']
        if User.objects.get(userid=userid).issuper == 1:
            Operationspjd.objects.get(id=id).delete()
            return JsonResponse({"code": 1})
        else:
            return JsonResponse({"code": 0})


def apiquestion(req):
    a = req.GET.get('a')
    userid = req.session['userid']
    companyid = getcompany(userid)
    if a == 'listall':
        objs = Question.objects.filter(deletemark=1).exclude(nousecomps__contains=','+companyid+',')
        if not req.GET.get('all', None):
            if req.GET.get('tmlx', None):
                pass
            else:
                objs = objs.filter(Q(usecomps__contains=',1,') | Q(usecomps__contains=','+companyid+','))
        else:
            objs = objs.filter(parent__isnull=True)
        if req.GET.get('type', None):
            objs = objs.filter(type=req.GET.get('type'))
        if req.GET.get('title', None):
            objs = objs.filter(Q(title__contains=req.GET.get('title'))|Q(questioncat__name__contains=req.GET.get('title')))
        if req.GET.get('tmlx', None):
            tmlx = req.GET.get('tmlx')
            objs = objs.filter(Q(questioncat__link__contains=',' +
                         str(tmlx)+',') | Q(questioncat__id=tmlx))
        if req.GET.get('gwlx', None):
            gwlx = req.GET.get('gwlx')
            objs = objs.filter(station=Group.objects.get(groupid=gwlx))
        total = objs.count()
        startnum, endnum = fenye(req)
        objsdata = objs.order_by('-id')[startnum:endnum].values('id', 'title', 'type', 'level', 'questioncat__id',
                                                      'questioncat__name', 'mark', 'createuser__name', 'answer', 'right', 'resolution','usecomps')
        return HttpResponse(transjson(total, objsdata), content_type="application/json")
    elif a == 'search':
        data = json.loads(req.body.decode('utf-8'))
        tmfls = data['tmfls']
        a = Question.objects.filter(deletemark=1, questioncat__id__in=tmfls)
        if 'repeat' in data and data['repeat'] == 'no':
            excludequestions = ExamTest.objects.filter(usecomps__contains=','+companyid +
                     ',').exclude(nousecomps__contains=','+companyid+',').values_list('exampaper__question__id',flat=True).distinct()
            a = a.exclude(id__in=excludequestions)
        dxnum = a.filter(type=1).count()
        duoxnum = a.filter(type=2).count()
        pdnum = a.filter(type=3).count()
        return JsonResponse({'dxnum': dxnum, 'duoxnum': duoxnum, 'pdnum': pdnum})
    elif a == 'add' or a == 'edit':
        data = json.loads(req.body.decode('utf-8'))
        userid = req.session['userid']
        companyid = getcompany(userid)
        type = data['type']
        level = data['level']
        title = data['title']
        if a == 'add':
            obj = Question()
        else:
            obj = Question.objects.get(id=data['id'])
        obj.type = type
        obj.level = level
        obj.title = title
        if 'cate' in data:
            obj.questioncat = Questioncat.objects.get(id=data['cate'])
        if 'station' in data:  # 岗位
            if data['station']:
                obj.station = Group.objects.get(groupid=data['station'])
        answer = {}
        if 'A' in data:
            answer['A'] = data['A']
        if 'B' in data:
            answer['B'] = data['B']
        if 'C' in data:
            answer['C'] = data['C']
        if 'D' in data:
            answer['D'] = data['D']
        if 'E' in data:
            answer['E'] = data['E']
        if 'F' in data:
            answer['F'] = data['F']
        obj.answer = answer
        obj.right = data['right']
        if 'resolution' in data:
            obj.resolution = data['resolution']
        if 'label' in data:
            obj.label = data['label']
        obj.usecomps = ','+companyid+','
        obj.createuser = User.objects.get(userid=userid)
        obj.save()
        return JsonResponse({"code": 1})
    elif a == 'del':
        id = req.GET.get('id')
        user = User.objects.get(userid=userid)
        a = Question.objects.get(id=id)
        if user.issuper == 1 or a.createuser == user:
            if a.usecomps == ',' + companyid + ',':
                a.deletemark = 0
                a.save()
            else:
                nl = a.nousecomps.split(',')
                nl.append(companyid)
                nl = ','+','.join(list(set(list(filter(None, nl)))))+','
                a.nousecomps = nl
                a.save()
            return JsonResponse({"code": 1})
        else:
            return JsonResponse({"code": 0})
    elif a == 'dels':
        data = json.loads(req.body.decode('utf-8'))
        ids = data['ids']
        user = User.objects.get(userid=userid)
        objs = Question.objects.filter(id__in=ids)
        if user.issuper == 1:
            for i in objs:
                if i.usecomps == ',' + companyid + ',':
                    i.deletemark = 0
                    i.save()
                else:
                    nl = i.nousecomps.split(',')
                    nl.append(companyid)
                    nl = ','+','.join(list(set(list(filter(None, nl)))))+','
                    i.nousecomps = nl
                    i.save()
            return JsonResponse({"code": 1})
        else:
            return JsonResponse({"code": 0})
    elif a == 'detail':
        id = req.GET.get('id')
        a = Question.objects.filter(id=id).values(
            'id', 'title', 'type', 'level', 'questioncat__id', 'station__groupid', 'right', 'answer', 'resolution')
        return JsonResponse(a[0])
    elif a == 'canedit':
        id = req.GET.get('id')
        a = Question.objects.get(id=id)
        if a.usecomps == ','+companyid+',' or int(companyid) == 1:
            return JsonResponse({'code': 1})
        else:
            return JsonResponse({"code": 0})
    elif a == 'exercise':
        data = json.loads(req.body.decode('utf-8'))
        x = Question.objects.filter(deletemark=1)
        #a = (x.filter(usecomps__contains=',1,')|x.filter(usecomps__contains=','+companyid+',')).exclude(nousecomps__contains=','+companyid+',')
        a = x.exclude(nousecomps__contains=','+companyid+',')
        tmlxs = data['tmlx']
        ydtms = data['ydtms']
        a = x.filter(questioncat__id__in=tmlxs).exclude(id__in=ydtms)
        total = a.count()
        a = a[:10].values('id', 'title', 'type', 'level', 'questioncat__id',
                          'questioncat__name', 'mark', 'createuser__name', 'answer', 'right', 'resolution')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'copy':
        data = json.loads(req.body.decode('utf-8'))
        ids = data['ids']
        questioncat = data['questioncat']
        for i in ids:
            question = Question.objects.get(pk=i)
            question.parent = Question.objects.get(pk=i)
            question.usecomps = ','+str(companyid)+','
            question.nousecomps = ''
            question.questioncat = Questioncat.objects.get(pk=questioncat)
            question.pk=None
            question.save()
        return JsonResponse({"code": 1})
            


def apiexampaper(req):
    a = req.GET.get('a')
    userid = req.session['userid']
    companyid = getcompany(userid)
    if a == 'listall':
        a = ExamPaper.objects.filter(deletemark=1)
        a = a.filter(usecomps__contains=','+companyid +
                     ',').exclude(nousecomps__contains=','+companyid+',').order_by('-id')
        total = a.count()
        startnum, endnum = fenye(req)
        a = a[startnum:endnum].values('id', 'num', 'name', 'state', 'total')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'listok':
        a = ExamPaper.objects.filter(deletemark=1, state=1)
        a = a.filter(usecomps__contains=','+companyid +
                     ',').exclude(nousecomps__contains=','+companyid+',').order_by('-id')
        total = a.count()
        startnum, endnum = fenye(req)
        a = a[startnum:endnum].values('id', 'num', 'name', 'state', 'total')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'add':
        data = json.loads(req.body.decode('utf-8'))
        totalnum = data['totalnum']
        dxnum = data['dxnum']
        dxs = data['dxs']  # 单选得分
        duoxnum = data['duoxnum']
        duoxs = data['duoxs']
        pdnum = data['pdnum']
        pds = data['pds']
        name = data['name']
        tms = data['tms']
        totalscore = int(dxs)*int(dxnum)+int(duoxs) * \
            int(duoxnum)+int(pds)*int(pdnum)
        obj = ExamPaper()
        obj.num = 'SJ'+time.strftime('%Y%m%d%H%M%S')
        obj.name = name
        obj.usecomps = ','+str(companyid)+','
        obj.total = {'total': {'num': totalnum, 'score': totalscore}, 'dx': {'num': dxnum, 'score': dxs}, 'duox': {
            'num': duoxnum, 'score': duoxs}, 'pd': {'num': pdnum, 'score': pds}}
        obj.save()
        for i in tms:
            if int(i['type']) == 1:
                ExamPaperDetail.objects.create(
                    exampaper=obj, question=Question.objects.get(id=i['id']), score=int(dxs))
            elif int(i['type']) == 2:
                ExamPaperDetail.objects.create(
                    exampaper=obj, question=Question.objects.get(id=i['id']), score=int(duoxs))
            elif int(i['type']) == 3:
                ExamPaperDetail.objects.create(
                    exampaper=obj, question=Question.objects.get(id=i['id']), score=int(pds))
        return JsonResponse({"code": 1})
    elif a == 'del':
        id = req.GET.get('id')
        user = User.objects.get(userid=userid)
        a = ExamPaper.objects.get(id=id)
        if user.issuper == 1:
            nl = a.nousecomps.split(',')
            nl.append(companyid)
            nl = ','+','.join(list(filter(None, nl)))+','
            a.nousecomps = nl
            a.save()
            return JsonResponse({"code": 1})
        else:
            return JsonResponse({"code": 0})
    elif a == 'stop':
        userid = req.session['userid']
        companyid = getcompany(userid)
        id = req.GET.get('id')
        user = User.objects.get(userid=userid)
        a = ExamPaper.objects.get(id=id)
        if user.issuper == 1:
            a.state = 0
            a.save()
            return JsonResponse({"code": 1})
        else:
            return JsonResponse({"code": 0})
    elif a == 'detail':
        id = req.GET.get('id')
        obj = ExamPaper.objects.get(id=id)
        return JsonResponse(obj.total)
    elif a == 'detailtms':
        id = req.GET.get('id')
        obj = ExamPaper.objects.filter(id=id)
        data = obj.values('name', 'total')[0]
        tms = ExamPaperDetail.objects.filter(exampaper__id=id).values(
            'question__id', 'question__title', 'question__answer', 'question__right', 'question__type', 'question__resolution')
        data['tms'] = list(tms)
        return JsonResponse(data)
    elif a == 'exportword':
        id = req.GET.get('id')
        res = exportdoc('exampaper', id)
        return res
    elif a == 'edit':
        data = json.loads(req.body.decode('utf-8'))
        id = data['id']
        totalnum = data['totalnum']
        dxnum = data['dxnum']
        dxs = data['dxs']  # 单选得分
        duoxnum = data['duoxnum']
        duoxs = data['duoxs']
        pdnum = data['pdnum']
        pds = data['pds']
        name = data['name']
        tms = data['tms']
        totalscore = int(dxs)*int(dxnum)+int(duoxs) * \
            int(duoxnum)+int(pds)*int(pdnum)
        obj = ExamPaper.objects.get(id=id)
        obj.name = name
        obj.usecomps = ','+str(companyid)+','
        obj.total = {'total': {'num': totalnum, 'score': totalscore}, 'dx': {'num': dxnum, 'score': dxs}, 'duox': {
            'num': duoxnum, 'score': duoxs}, 'pd': {'num': pdnum, 'score': pds}}
        obj.save()
        ExamPaperDetail.objects.filter(exampaper=obj).delete()
        for i in tms:
            if int(i['type']) == 1:
                ExamPaperDetail.objects.create(
                    exampaper=obj, question=Question.objects.get(id=i['id']), score=int(dxs))
            elif int(i['type']) == 2:
                ExamPaperDetail.objects.create(
                    exampaper=obj, question=Question.objects.get(id=i['id']), score=int(duoxs))
            elif int(i['type']) == 3:
                ExamPaperDetail.objects.create(
                    exampaper=obj, question=Question.objects.get(id=i['id']), score=int(pds))
        return JsonResponse({"code": 1})


def apitrainplan(req):
    a = req.GET.get('a')
    userid = req.session['userid']
    companyid = getcompany(userid)
    if a == 'listall':
        objs = TrainPlan.objects.filter(usecomp__partid=companyid,deletemark=1)
        if req.GET.get('search', None):
            objs = objs.filter(purpose__contains=req.GET.get('search'))
        if req.GET.get('year', None):
            objs = objs.filter(year=req.GET.get('year'))
        total = objs.count()
        startnum, endnum = fenye(req)
        objs = objs[startnum:endnum].values('id', 'purpose', 'year', 'month', 'manager__name', 'group__groupname', 'period')
        return HttpResponse(transjson(total, objs), content_type="application/json")
    elif a == 'add':
        data = json.loads(req.body.decode('utf-8'))
        vdata = {}
        vdata['year'] = data['year']
        vdata['month'] = data['month']
        vdata['purpose'] = data.get('purpose', None)
        vdata['group'] = Group.objects.get(groupid = data['group'])
        vdata['period'] = data['period']
        vdata['manager'] = User.objects.get(userid = data['manager'])
        vdata['usecomp'] = Partment.objects.get(partid=companyid)
        vdata['createby'] = User.objects.get(userid=userid)
        TrainPlan.objects.create(**vdata)
        return JsonResponse({"code": 1})
    elif a == 'edit':
        data = json.loads(req.body.decode('utf-8'))
        id = data['id']
        obj = TrainPlan.objects.filter(id=id)
        vdata = {}
        vdata['year'] = data['year']
        vdata['month'] = data['month']
        vdata['purpose'] = data.get('purpose', None)
        vdata['group'] = Group.objects.get(groupid = data['group'])
        vdata['period'] = data['period']
        vdata['manager'] = User.objects.get(userid = data['manager'])
        vdata['updateby'] = User.objects.get(userid=userid)
        obj.update(**vdata)
        return JsonResponse({"code": 1})
    elif a == 'detail':
        id = req.GET.get('id')
        obj = TrainPlan.objects.filter(id=id).values('id', 'purpose', 'year', 'month', 'manager__name', 'group__groupname', 'period', 'manager', 'group')[0]
        return HttpResponse(json.dumps(obj, cls=MyEncoder), content_type="application/json")
    elif a == 'del':
        id = req.GET.get('id')
        obj = TrainPlan.objects.get(id=id)
        if User.objects.get(userid=userid).issuper == 1 or userid == obj.createby :
            TrainPlan.objects.get(id=id).delete()
            return JsonResponse({"code": 1})
        else:
            return JsonResponse({"code": 0, "msg":'无权限删除'})



def apiexamtest(req):
    a = req.GET.get('a')
    userid = req.session['userid']
    companyid = getcompany(userid)
    if a == 'listall':
        a = ExamTest.objects
        a = a.filter(usecomps__contains=','+companyid +
                     ',').exclude(nousecomps__contains=','+companyid+',')
        state = req.GET.get('state',None)
        owner = req.GET.get('owner',None)
        search = req.GET.get('search', None)
        starttime1 = req.GET.get('starttime1', None)
        starttime2 = req.GET.get('starttime2', None)
        if search:
            a = a.filter(Q(name__contains=search)|Q(exampaper__name=search))
        if starttime1:
            a = a.filter(starttime__gte=starttime1)
        if starttime2:
            a = a.filter(starttime__lte=starttime2)
        if state == 'open':
            a = a.filter(state=1)
        if state == 'close':
            a = a.filter(state=0)
        if owner == 'yes':
            ownerlist = ExamTestDetail.objects.filter(user__userid=userid, examtest__state=1,testnum=0).values_list('examtest__id',flat=True)
            a = a.filter(Q(id__in=ownerlist)|Q(ispublic=1))
        a = a.order_by('-id')
        total = a.count()
        startnum, endnum = fenye(req)
        a = a[startnum:endnum].values('id', 'num', 'name', 'state', 'type', 'exampaper__id',
                                      'exampaper__name', 'starttime', 'endtime', 'duration', 'createuser__name', 'createtime','passscore')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'listok':
        a = ExamTest.objects
        a = a.filter(usecomps__contains=','+companyid +
                     ',').exclude(nousecomps__contains=','+companyid+',').order_by('-id')
        total = a.count()
        startnum, endnum = fenye(req)
        a = a[startnum:endnum].values('id', 'num', 'name', 'state', 'type', 'exampaper__id',
                                      'exampaper__name', 'starttime', 'endtime', 'duration', 'createuser__name', 'createtime')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'listtrain':
        a = ExamTest.objects
        a = a.filter(usecomps__contains=','+companyid +
                     ',').exclude(nousecomps__contains=','+companyid+',').order_by('-id')
        a = a[:10].values('id', 'name')
        return HttpResponse(transstr(a, 'id', 'name'), content_type="application/json")
    elif a == 'add':
        data = json.loads(req.body.decode('utf-8'))
        obj = ExamTest()
        obj.num = 'KS'+time.strftime('%Y%m%d%H%M%S')
        obj.name = data['name']
        obj.usecomps = ','+str(companyid)+','
        expaper = ExamPaper.objects.get(id=data['exampaper'])
        obj.exampaper = expaper
        if 'starttime' in data:
            if data['starttime']:
                obj.starttime = data['starttime']
        if 'endtime' in data:
            if data['endtime']:
                obj.endtime = data['endtime']
        if 'ispublic' in data:
            if data['ispublic'] == 'yes':
                obj.ispublic = 1
            else:
                obj.ispublic = 0
        obj.totalscore = expaper.total['total']['score']
        obj.passscore = data['passscore']
        obj.duration = data['duration']
        obj.createuser = User.objects.get(userid=userid)
        if 'testnum' in data and data['testnum']:
            obj.testnum = data['testnum']
        obj.save()
        obj.qrcode = makeqr_examtest(
            'https://safeyun.ctcshe.com/miniprogram/examtest?id='+str(obj.id))
        obj.save()
        if 'participant' in data and data['participant']:
            ksry = data['participant'].split(',')
            b = []
            for i in ksry:
                uobj = User.objects.get(userid=i)
                ExamTestDetail.objects.create(examtest=obj, user=uobj, remainnum = obj.testnum)
                b.append(uobj.openid)
            postdict = {
                'touser': '',
                'template_id': 'lOuwSE67vZC3ZVFYPZvz2eb7JdFxqx7ysMFkXrYmYh0',
                "miniprogram": {"appid": "wx5c39b569f01c27db", "path": "pages/examtest/index"},
                'data': {
                    'first': {
                        'value': '小程序考试通知:'
                    },
                    'keyword1': {
                        'value': data['name']
                    },
                    'keyword2': {
                        'value': '满分' + str(obj.totalscore)
                    },
                    'remark': {
                        'value': '用时限制为'+data['duration']+'分钟,注意把握时间'
                    }
                }
            }
            send_wechatmsgs.delay(postdict, b)
        return JsonResponse({"code": 1})
    elif a == 'add2':
        data = json.loads(req.body.decode('utf-8'))
        # print(data)
        obj = ExamTest()
        obj.num = 'KS'+time.strftime('%Y%m%d%H%M%S')
        obj.name = data['name']
        obj.usecomps = ','+str(companyid)+','
        # 创建随机试卷
        dxnum = int(data['dxnum'])
        dxs = int(data['dxs'])  # 单选得分
        duoxnum = int(data['duoxnum'])
        duoxs = int(data['duoxs'])
        pdnum = int(data['pdnum'])
        pds = int(data['pds'])
        totalnum = dxnum+duoxnum+pdnum
        name = 'CTSJ'+time.strftime('%Y%m%d%H%M%S')
        totalscore = int(dxs)*int(dxnum)+int(duoxs) * \
            int(duoxnum)+int(pds)*int(pdnum)
        objpaper = ExamPaper()
        objpaper.deletemark = 0
        objpaper.num = name
        objpaper.name = '自动抽题试卷'
        objpaper.usecomps = ','+str(companyid)+','
        objpaper.total = {'total': {'num': totalnum, 'score': totalscore}, 'dx': {
            'num': dxnum, 'score': dxs}, 'duox': {'num': duoxnum, 'score': duoxs}, 'pd': {'num': pdnum, 'score': pds}}
        objpaper.save()
        questionobjs = Question.objects.filter(questioncat__id__in=data['tmfls'], deletemark=1)
        if 'repeat' in data and data['repeat'] == 'no':
            excludequestions = ExamTest.objects.filter(usecomps__contains=','+companyid +
                     ',').exclude(nousecomps__contains=','+companyid+',').values_list('exampaper__question__id',flat=True).distinct()
            questionobjs = questionobjs.exclude(id__in=excludequestions)
        if dxnum > 0:
            qobjs = questionobjs.filter(type=1).order_by('?')[:dxnum]
            for i in qobjs:
                ExamPaperDetail.objects.create(
                    exampaper=objpaper, question=i, score=dxs)
        if duoxnum > 0:
            qobjs = questionobjs.filter(type=2).order_by('?')[:duoxnum]
            for i in qobjs:
                ExamPaperDetail.objects.create(
                    exampaper=objpaper, question=i, score=duoxs)
        if pdnum > 0:
            qobjs = questionobjs.filter(type=3).order_by('?')[:pdnum]
            for i in qobjs:
                ExamPaperDetail.objects.create(
                    exampaper=objpaper, question=i, score=pds)
        # 结束
        obj.exampaper = objpaper
        if 'starttime' in data:
            if data['starttime']:
                obj.starttime = data['starttime']
        if 'endtime' in data:
            if data['endtime']:
                obj.endtime = data['endtime']
        obj.totalscore = totalscore
        obj.passscore = data['passscore']
        obj.duration = data['duration']
        obj.createuser = User.objects.get(userid=userid)
        if 'ispublic' in data:
            if data['ispublic'] == 'yes':
                obj.ispublic = 1
            else:
                obj.ispublic = 0
        if 'testnum' in data and data['testnum']:
            obj.testnum = data['testnum']
        obj.save()
        obj.qrcode = makeqr_examtest(
            'https://safeyun.ctcshe.com/miniprogram/examtest?id='+str(obj.id))
        obj.save()
        if 'participant' in data and data['participant']:
            ksry = data['participant'].split(',')
            b = []
            for i in ksry:
                uobj = User.objects.get(userid=i)
                ExamTestDetail.objects.create(examtest=obj, user=uobj, remainnum = obj.testnum)
                b.append(uobj.openid)
            postdict = {
                'touser': '',
                'template_id': 'lOuwSE67vZC3ZVFYPZvz2eb7JdFxqx7ysMFkXrYmYh0',
                "miniprogram": {"appid": "wx5c39b569f01c27db", "path": "pages/examtest/index"},
                'data': {
                    'first': {
                        'value': '小程序考试通知:'
                    },
                    'keyword1': {
                        'value': data['name']
                    },
                    'keyword2': {
                        'value': '满分' + str(obj.totalscore)
                    },
                    'remark': {
                        'value': '用时限制为'+data['duration']+'分钟,注意把握时间'
                    }
                }
            }
            send_wechatmsgs.delay(postdict, b)
        return JsonResponse({"code": 1})
    elif a == 'del':
        id = req.GET.get('id')
        user = User.objects.get(userid=userid)
        a = ExamTest.objects.get(id=id)
        if user.issuper == 1 or a.createuser == user:
            nl = a.nousecomps.split(',')
            nl.append(companyid)
            nl = ','+','.join(list(filter(None, nl)))+','
            a.nousecomps = nl
            a.save()
            return JsonResponse({"code": 1})
        else:
            return JsonResponse({"code": 0})
    elif a == 'close':
        id = req.GET.get('id')
        user = User.objects.get(userid=userid)
        a = ExamTest.objects.get(id=id)
        if user.issuper == 1 or a.createuser == user:
            a.state = 0
            a.save()
            return JsonResponse({"code": 1})
        else:
            return JsonResponse({"code": 0})
    elif a == 'detail2':
        id = req.GET.get('id')
        a = ExamTest.objects.filter(id=id).values('id', 'num', 'name', 'starttime', 'endtime', 'duration', 'totalscore',
                                                  'passscore', 'exampaper__total', 'createtime', 'state', 'exampaper__name', 'createuser__name', 'type', 'qrcode', 'testnum')[0]
        a['notinTime'] = 0
        if a['starttime'] > datetime.now():
            a['notinTime'] = 1
        if 'endtime' in a and a['endtime'] < datetime.now():
            a['notinTime'] = 1
        objs = ExamTestDetail.objects.filter(examtest__id=id).order_by('-score','took').values(
            'id', 'user__name', 'user__ubelongpart__partname', 'took', 'score', 'remainnum', 'passcode','starttime', 'testnum')
        a['cjrydetail'] = list(objs)
        return HttpResponse(json.dumps(a, cls=MyEncoder), content_type="application/json")
    elif a == 'detail':
        id = req.GET.get('id')
        a = ExamTest.objects.filter(id=id).values('id', 'num', 'name', 'starttime', 'endtime', 'duration', 'totalscore',
                                                  'passscore', 'exampaper__total', 'createtime', 'state', 'exampaper__name', 'createuser__name', 'type', 'qrcode', 'testnum', 'ispublic')[0]
        a['notinTime'] = 0
        if a['starttime'] > datetime.now():
            a['notinTime'] = 1
        if 'endtime' in a and a['endtime'] < datetime.now():
            a['notinTime'] = 1
        a['remainnum'] = 0
        a['testnum'] = 0
        a['canks'] = 0 # 本人是否可参加
        if a['ispublic'] == 1:
            a['canks'] = 1
        queryset = ExamTestDetail.objects.filter(examtest__id=id,user__userid=userid)
        if queryset.exists():
            a['canks'] = 1
            a['remainnum'] = queryset[0].remainnum
            a['testnum'] = queryset[0].testnum
        return HttpResponse(json.dumps(a, cls=MyEncoder), content_type="application/json")
    elif a == 'detailtm':
        id = req.GET.get('id')
        test = ExamTest.objects.get(id=id)
        objs = ExamPaperDetail.objects.filter(exampaper=test.exampaper).order_by('question__type','?').values(
            'id', 'question__id', 'score', 'question__title', 'question__type', 'question__answer', 'question__resolution')
        duration = test.duration
        data = {'duration': duration, 'tms': list(objs), 'starttime':datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
        return JsonResponse(data)
    elif a == 'exportword':
        data = json.loads(req.body.decode('utf-8'))
        url = exportdoc2('ks', data)
        return JsonResponse({"code": 1, "downloadurl": url})
    elif a == 'dknum':#未参加且还未关闭的考试
        a = ExamTest.objects
        a = a.filter(usecomps__contains=','+companyid + #未关闭的考试
                     ',').exclude(nousecomps__contains=','+companyid+',').filter(state=1,endtime__gte=datetime.now())
        ownerlist = ExamTestDetail.objects.filter(user__userid=userid, examtest__state=1,testnum=0).values_list('examtest__id',flat=True)
        dknum = a.filter(Q(id__in=ownerlist)|Q(ispublic=1)).count()
        return JsonResponse({"code":1, "dknum":dknum})



def apiexamtestdetail(req):
    a = req.GET.get('a')
    userid = req.session['userid']
    companyid = getcompany(userid)
    if a == 'dknum':
        a = ExamTestDetail.objects
        a = a.filter(user__userid=userid, examtest__state=1, testnum=0 , examtest__endtime__gte=datetime.now())
        dknum = a.count()
        return JsonResponse({"code": 1, "dknum": dknum})
    elif a == 'listdk':
        a = ExamTestDetail.objects
        a = a.filter(user__userid=userid, examtest__state=1,
                     testnum=0).order_by('-id')
        total = a.count()
        startnum, endnum = fenye(req)
        a = a[startnum:endnum].values('id', 'examtest__id', 'examtest__name', 'examtest__starttime',
                                      'examtest__endtime', 'examtest__passscore', 'examtest__state', 'examtest__duration')
        for i in a:
            if i['examtest__endtime']:
                if i['examtest__endtime'] > datetime.now():
                    i['isActive'] = True
                else:
                    i['isActive'] = False
            else:
                i['isActive'] = True
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'listyk':
        a = ExamTestDetail.objects
        a = a.filter(user__userid=userid).exclude(testnum=0)
        total = a.count()
        startnum, endnum = fenye(req)
        a = a.order_by('-starttime')[startnum:endnum].values('id', 'examtest__id', 'examtest__name', 'starttime', 'examtest__passscore',
                                      'examtest__state', 'testnum', 'examtest__duration', 'took', 'score', 'passcode', 'remainnum')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'handtest':
        data = json.loads(req.body.decode('utf-8'))
        testid = data['testid']
        examtestobj = ExamTest.objects.get(id=testid)
        obj,created = ExamTestDetail.objects.get_or_create(examtest = examtestobj, user__userid=userid,
                defaults={'examtest': examtestobj,'user':User.objects.get(userid=userid), 'remainnum':examtestobj.testnum})
        starttime = data['starttime']
        endtime = datetime.now()
        took = (endtime - datetime.strptime(starttime, '%Y-%m-%d %H:%M:%S')).total_seconds() #计算相差多少秒
        testdetail = data['sheet']
        obj.testdetail = testdetail
        obj.save()
        score = 0
        rights = 0
        tms = []
        wrongs = []
        answers = ExamPaperDetail.objects.filter(exampaper=examtestobj.exampaper).values('id', 'question__right')
        answersdict = {}
        for i in answers:
            answersdict['paperdetail' + str(i['id'])] = i['question__right']
        for i in testdetail:  # 判卷
            iscore = 0
            i['question__right'] = answersdict['paperdetail'+str(i['id'])]
            if i['question__type'] == 2:
                if 'userchecked' in i:
                    if i['userchecked']:
                        if set(i['userchecked']) == set(i['question__right']):
                            iscore = i['score']
                            rights = rights + 1
                        else:
                            miniscore = i['score']/len(i['question__right'])
                            wrongs.append(str(i['question__id']))
                            for x in i['userchecked']:
                                if x in i['question__right']:
                                    iscore = iscore + miniscore
                                else:
                                    iscore = 0
                                    break
            else:
                if 'userchecked' in i:
                    if i['userchecked']:
                        if i['userchecked'] == i['question__right']:
                            iscore = i['score']
                            rights = rights + 1
                        else:
                            wrongs.append(str(i['question__id']))
            i['iscore'] = iscore
            score = score + iscore
            tms.append(str(i['question__id']))
        obj.testnum = obj.testnum + 1
        obj.remainnum = obj.remainnum - 1 if obj.remainnum >= 1 else 0
        obj.starttime = starttime
        obj.endtime = endtime
        obj.took = took
        obj.rights = rights
        score = round(score,1)
        obj.score = score
        examtestobj = obj.examtest
        totalscore = examtestobj.totalscore
        passscore = examtestobj.passscore
        if score >= passscore:
            passcode = 1
        else:
            passcode = 0
        obj.passcode = passcode
        if tms:
            obj.tms = ','+','.join(tms)+','
        if wrongs:
            obj.wrongs = ','+','.join(wrongs)+','
        obj.save()
        tmnum = len(testdetail)
        # objs = ExamTestDetail.objects.filter(examtest__id=testid, passcode=0) 必须得手动关闭考试
        # if objs.exists():
        #     pass
        # else:
        #     ExamTest.objects.filter(id=testid).update(state=0)
        return JsonResponse({'code': 1, 'data': {'passcode': passcode, 'score': score, 'totalscore': totalscore, 'rights': rights, 'tmnum': tmnum, 'examtestdetailid': obj.id, 'examtestid':obj.examtest.id}})
    elif a == 'detail':
        id = req.GET.get('id')
        obj = ExamTestDetail.objects.filter(id=id)
        data = obj.values('id', 'starttime', 'took', 'score', 'passcode',
                          'testdetail', 'examtest__name', 'user__headimgurl', 'user__name')[0]
        return JsonResponse(data)
    elif a=='updateison':
         id = req.GET.get('id')
         examdlid = req.GET.get('examdlid')
         user = User.objects.get(userid=userid)
         a = ExamTest.objects.get(id=id)
         if a.createuser==user:
             objss = ExamTestDetail.objects.get(id=examdlid)
             objss.remainnum= objss.remainnum + 1
             objss.save()
             return JsonResponse({"code":1,"msg":"发布成功!"})
         else:
             return JsonResponse({"code":2,"msg":"您没有发布权限!"})
    elif a == 'rate':
        examtestid = req.GET.get('examtestid')
        examtestobj = ExamTest.objects.get(id=examtestid)
        objs = ExamTestDetail.objects.filter(examtest=examtestobj)
        objs = objs.order_by('-score','took')
        total = objs.count()
        startnum, endnum = fenye(req)
        objsdata = objs[startnum:endnum].values('id','took', 'score', 'user__name', 'user__ubelongpart__partname', 'user__headimgurl')
        return JsonResponse({'total':total,'rows':list(objsdata),'examtestname':examtestobj.name})
    elif a == 'totalrate':
        startnum, endnum = fenye(req)
        with open('ratedata.dat','rb') as f:
            data = pickle.load(f)
            rows = data['rows']
            if req.GET.get('search',None):
                rows=[]
                for i in data['rows']:
                    search = req.GET.get('search')
                    if search in i['user__name'] or search in i['user__ubelongpart__partname']:
                        rows.append(i)
            data['rows'] = rows[startnum:endnum]
            return JsonResponse(data)


def apiexamtestrate(req):
    '''
    公司活动总排名
    '''
    companyid = req.GET.get('companyid')
    alltest = ExamTest.objects.filter(usecomps__contains=','+str(companyid)+',').exclude(nousecomps__contains=','+str(companyid)+',')
    allexamtestdetail = ExamTestDetail.objects.filter(examtest__in=alltest,testnum__gte=1)
    objs = allexamtestdetail.values('user__userid','user__name','user__headimgurl','user__ubelongpart__partname').annotate(totalscore=Sum('score'),totaltook=Sum('took'),testnum=Count('user__userid')).order_by('-totalscore','totaltook')
    total = objs.count()
    objslist = list(objs)
    for i in objslist:
        i['rate'] = objslist.index(i) + 1
        i['avgscore'] = round(i['totalscore']/i['testnum'],1)
    orgsCal = allexamtestdetail.filter(score__gt=0,testnum__gte=1).values('user__ubelongpart__partid','user__ubelongpart__partname').annotate(totaltest=Count('user__ubelongpart__partid'),avgscore=Avg('score')).order_by('-totaltest','-avgscore')
    allattenduser = allexamtestdetail.values_list('user__userid', flat=True)
    orgsCallist = list(orgsCal)
    for i in orgsCallist:
        users = User.objects.filter(ubelongpart__partid=i['user__ubelongpart__partid'])
        usersattend = users.filter(userid__in=allattenduser)
        i['totaluser'] = usersattend.count()
        i['avgscore'] = round(i['avgscore'],1)
    with open('ratedata.dat','wb') as f:
        pickle.dump({'total':total,'rows':objslist,'rows2':orgsCallist,'updatetime':datetime.now().strftime('%Y-%m-%d %H:%M')},f)
    from openpyxl import Workbook, load_workbook
    wb = load_workbook('e:/个人总排名.xlsx')
    sheet = wb.active
    for i in objslist:
        num = str(objslist.index(i)+3)
        sheet['a'+num] = i['user__name']
        sheet['b'+num] = i['user__ubelongpart__partname']
        sheet['c'+num] = i['testnum']
        sheet['d'+num] = i['totalscore']
        sheet['e'+num] = convertseconds(i['totaltook'])
    nowtime = datetime.now().strftime('%Y%m%d') 
    sheet['b1'] = nowtime
    filename = '个人总排名' + nowtime
    filepath = 'e:/' + filename +'.xlsx'
    wb.save(filepath)

    wb2 = load_workbook('e:/机构总排名.xlsx')
    sheet = wb2.active
    for i in orgsCallist:
        num = str(orgsCallist.index(i)+3)
        sheet['a'+num] = i['user__ubelongpart__partname']
        sheet['b'+num] = i['totaluser']
        sheet['c'+num] = i['totaltest']
        sheet['d'+num] = i['avgscore']
    nowtime = datetime.now().strftime('%Y%m%d') 
    sheet['b1'] = nowtime
    filename = '机构总排名' + nowtime
    filepath = 'e:/' + filename +'.xlsx'
    wb2.save(filepath)

    return JsonResponse({"code": 1})

def convertseconds(seconds):
    m, s = divmod(seconds, 60)
    h, m = divmod(m, 60)
    return ("%02d:%02d:%02d" % (h, m, s))

def apitrain(req):
    if req.GET.get('a') == 'listjoin':
        userid = req.session['userid']
        objs = Trainuser.objects.filter(train__deletemark=1)
        if req.GET.get('sry'):
            objs = objs.filter(participant__userid=req.GET.get('sry'))
        else:
            objs = objs.filter(participant__userid=userid)
        total = objs.count()
        startnum, endnum = fenye(req)
        objs = objs[startnum:endnum].values('train__trainnum', 'train__trainid', 'train__state', 'train__trainplace', 'train__starttime', 'train__trainname',
                                            'train__teacher', 'train__lecturer__name', 'participant__name', 'participant__name', 'checked', 'train__duration', 'examtestdetail')
        return HttpResponse(transjson(total, objs), content_type="application/json")
    elif req.GET.get('a') == 'listall':
        userid = req.session['userid']
        companyid = getcompany(userid)
        objs = Trainuser.objects.filter(train__deletemark=1,participant__usecomp__partid=companyid)
       
        total = objs.count()
        startnum, endnum = fenye(req)
        objs = objs[startnum:endnum].values('train__trainnum', 'train__trainid', 'train__state', 'train__trainplace', 'train__starttime', 'train__trainname',
                                            'train__teacher', 'train__lecturer__name', 'participant__name', 'participant__name', 'checked', 'train__duration', 'examtestdetail')
        return HttpResponse(transjson(total, objs), content_type="application/json")
    elif req.GET.get('a') == 'exportexcel':
        userid = req.session['userid']
        companyid = getcompany(userid)
        a = Trainuser.objects.filter(train__deletemark=1)
        if req.GET.get('sry'):
            a = a.filter(participant__userid=req.GET.get('sry'))
        else:
            a = a.filter(participant__userid=userid)

        
        res = exportxlsx('grpxjl', a)
        return res



def apiquestioncat(req):
    a = req.GET.get('a')
    userid = req.session['userid']
    companyid = getcompany(userid)
    if a == 'tree1':
        list_items = (Questioncat.objects.filter(usecomp__partid=1, deletemark=1)).annotate(
            parentId=F('parent__id')).values('id', 'parentId', 'name', 'isopen')
        return HttpResponse(json.dumps(list(list_items)), content_type="application/json")
    elif a == 'tree2':
        list_items = (Questioncat.objects.filter(usecomp__partid=companyid, deletemark=1)).annotate(
            parentId=F('parent__id')).values('id', 'parentId', 'name', 'isopen')
        return HttpResponse(json.dumps(list(list_items)), content_type="application/json")
    elif a == 'tree3':
        # 共享分类
        groups = g_models.Groupmember.objects.filter(member__partid=companyid).values_list('group__id', flat=True)
        companys = g_models.Groupmember.objects.filter(group__id__in=groups).values_list('member__partid', flat=True).distinct()
        if companys:
            pass
        else:
            companys = Partment.objects.filter(partid=companyid).values_list('partid', flat=True)
        list_items = Questioncat.objects.filter(usecomp__in=companys, deletemark=1, isopen=1).annotate(
            parentId=F('parent__id')).values('id', 'parentId', 'name', 'isopen')
        return HttpResponse(json.dumps(list(list_items)), content_type="application/json")
    elif a == 'tree4':
        # 自建+共享分类
        groups = g_models.Groupmember.objects.filter(member__partid=companyid).values_list('group__id', flat=True)
        companys = g_models.Groupmember.objects.filter(group__id__in=groups).values_list('member__partid', flat=True).distinct()
        if companys:
            pass
        else:
            companys = Partment.objects.filter(partid=companyid).values_list('partid', flat=True)
        list_items = (Questioncat.objects.filter(usecomp__in=companys, deletemark=1, isopen=1)| Questioncat.objects.filter(
            usecomp__partid__in=[companyid,1], deletemark=1)).distinct().annotate(
            parentId=F('parent__id')).values('id', 'parentId', 'name', 'isopen')
        return HttpResponse(json.dumps(list(list_items)), content_type="application/json")
    elif a == 'tree':
        list_items = (Questioncat.objects.filter(usecomp__partid=1, deletemark=1) | Questioncat.objects.filter(
            usecomp__partid=companyid, deletemark=1)).annotate(parentId=F('parent__id')).values('id', 'parentId', 'name', 'isopen')
        return HttpResponse(json.dumps(list(list_items)), content_type="application/json")
    elif a == 'add':
        data = json.loads(req.body.decode('utf-8'))
        obj = Questioncat()
        name = data['name']
        obj.name = name
        if 'isopen' in data:
            obj.isopen = 1
        if 'parent' in data:
            if data['parent']:
                parent = data['parent']
                parentobj = Questioncat.objects.get(id=parent)
                obj.parent = parentobj
                obj.link = parentobj.link + str(data['parent']) + ','
        obj.usecomp = Partment.objects.get(partid=companyid)
        obj.save()
        return JsonResponse({"code": 1})
    elif a == 'del':
        id = req.GET.get('id')
        user = User.objects.get(userid=userid)
        a = Questioncat.objects.get(id=id)
        if user.issuper == 1 or a.usecomp.partid == companyid:
            Questioncat.objects.filter(id=id).update(deletemark=0)
            return JsonResponse({"code": 1})
        else:
            return JsonResponse({"code": 0})
    elif a == 'detail':
        id = req.GET.get('id')
        a = Questioncat.objects.filter(id=id).values(
            'id', 'name', 'parent__id', 'isopen')[0]
        return JsonResponse(a)
    elif a == 'edit':
        data = json.loads(req.body.decode('utf-8'))
        id = data['id']
        a = Questioncat.objects.get(id=id)
        a.name = data['name']
        a.isopen = 0
        if 'isopen' in data:
            a.isopen = 1
        if 'parent' in data:
            if data['parent']:
                parent = Questioncat.objects.get(id=data['parent'])
                a.parent = parent
                oldlink = a.link
                a.link = parent.link + str(parent.id) + ','
                Questioncat.objects.filter(
                    link__contains=oldlink + str(id) + ',').update(link=a.link + str(id) + ',')
        a.save()
        return JsonResponse({"code": 1})


def apimap(req):
    a = req.GET.get('a')
    userid = req.session['userid']
    companyid = getcompany(userid)
    if a == 'tree':
        list_items = (Map.objects.filter(usecomp__partid=companyid, deletemark=1)).annotate(
            parentId=F('parent__id')).values('id', 'parentId', 'name', 'pic')
        return HttpResponse(json.dumps(list(list_items)), content_type="application/json")
    elif a == 'default':
        obj = Map.objects.filter(
            usecomp__partid=companyid, deletemark=1, default=1).values('id', 'name', 'pic')
        return JsonResponse(obj[0])
    elif a == 'update':
        id = req.POST.get('id')
        Map.objects.filter(id=id).update(pic=req.POST.get('pic'))
        return JsonResponse({"code": 1})


def apiarea(req):
    a = req.GET.get('a')
    userid = req.session['userid']
    companyid = getcompany(userid)
    if a == 'listall':
        a = Area.objects.filter(deletemark=1, belongmap__id=req.GET.get('map'))
        total = a.count()
        a = a.order_by('order').values(
            'id', 'name', 'polygon', 'order', 'belongmap__id')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'bind':
        data = json.loads(req.body.decode('utf-8'))
        Area.objects.filter(id=data['id']).update(polygon=data['polygon'])
        return JsonResponse({"code": 1})
    elif a == 'tree':
        mapobj = Map.objects.filter(usecomp__partid=companyid, deletemark=1)
        if mapobj.count() == 1:
            objs = Area.objects.filter(belongmap=mapobj[0], deletemark=1).order_by(
                'order').annotate(parentId=F('parent__id')).values('id', 'parentId', 'name')
            return HttpResponse(json.dumps(list(objs)), content_type="application/json")
    elif a == 'add':
        data = json.loads(req.body.decode('utf-8'))
        name = data['name']
        if Area.objects.filter(usecomp__partid=companyid, name=name, deletemark=1).exists():
            return JsonResponse({"code": 0})
        map = data['map']
        order = data['order']
        obj = Area.objects.create(name=name, order=order, belongmap=Map.objects.get(
            id=map), usecomp=Partment.objects.get(partid=companyid))
        makeqr_area(
            'https://safeyun.ctcshe.com/miniprogram/area?id='+str(obj.id))
        return JsonResponse({"code": 1})
    elif a == 'del':
        if User.objects.get(userid=userid).issuper == 1:
            Area.objects.filter(id=req.GET.get('id')).update(deletemark=0)
            return JsonResponse({"code": 1})
        else:
            return JsonResponse({"code": 0})
    elif a == 'detail':
        obj = Area.objects.filter(deletemark=1, id=req.GET.get('id')).values(
            'id', 'name', 'polygon', 'order', 'qrcode')[0]
        return JsonResponse(obj)
    elif a == 'edit':
        data = json.loads(req.body.decode('utf-8'))
        name = data['name']
        order = data['order']
        Area.objects.filter(id=data['id']).update(name=name, order=order)
        return JsonResponse({"code": 1})

@apicheck_login
def apimapshow(req):
    a = req.GET.get('a')
    userid = req.session['userid']
    companyid = getcompany(userid)
    if a == 'trouble':
        objs = Trouble.objects.filter(usecomp__partid=companyid, deletemark=1).exclude(yhzt=6).exclude(yhqy=None).exclude(
            yhqy__deletemark=0).values('yhqy__id', 'yhqy__name', 'yhqy__polygon').annotate(num=Count('yhqy'))
        return HttpResponse(json.dumps(list(objs)), content_type="application/json")
    elif a == 'miss':
        date1 = datetime.now() - timedelta(days=30)
        objs = Miss.objects.filter(usecomp__partid=companyid, deletemark=1, submittime__gte=date1).exclude(
            missqy=None).values('missqy__id', 'missqy__name', 'missqy__polygon').annotate(num=Count('missqy'))
        return HttpResponse(json.dumps(list(objs)), content_type="application/json")
    elif a == 'risk':
        objs = Area.objects.filter(usecomp__partid=companyid, deletemark=1).exclude(
            risklevel=None).values('id', 'name', 'polygon', 'risklevel')  # 缺少deletemark
        return HttpResponse(json.dumps(list(objs)), content_type="application/json")
    elif a == 'operation':
        objs = Operation.objects.filter(usecomp__partid=companyid, deletemark=1).exclude(
            zyqy=None).exclude(zyzt__zyzt='已关闭')
        objs1 = objs.values('zyqy__id', 'zyqy__name',
                           'zyqy__polygon').annotate(num=Count('zyqy'))
        for i in objs1:
            i['zylist'] = list(objs.filter(zyqy__id=i['zyqy__id']).values('zyid','zylx__dickeyname','zyfzr__name',
                            'zybm__partname').annotate(num=Count('zyry')))
        return HttpResponse(json.dumps(list(objs1)), content_type="application/json")
    elif a == 'all':
        date1 = datetime.now() - timedelta(days=30)
        yh = Trouble.objects.filter(usecomp__partid=companyid, deletemark=1).exclude(yhzt=6).exclude(yhqy=None).exclude(
            yhqy__deletemark=0).values('yhqy__id', 'yhqy__name', 'yhqy__polygon').annotate(num=Count('yhqy'))
        ws = Miss.objects.filter(usecomp__partid=companyid, deletemark=1, submittime__gte=date1).exclude(
            missqy=None).values('missqy__id', 'missqy__name', 'missqy__polygon').annotate(num=Count('missqy'))
        zy = Operation.objects.filter(usecomp__partid=companyid, deletemark=1).exclude(zyqy=None).exclude(
            zyzt__zyzt='已关闭').values('zyqy__id', 'zyqy__name', 'zyqy__polygon').annotate(num=Count('zyqy'))
        fx = Area.objects.filter(usecomp__partid=companyid).exclude(
            risklevel=None).values('id', 'name', 'polygon', 'risklevel')
        return JsonResponse({'code': 1, 'data': {'yh': list(yh), 'ws': list(ws), 'zy': list(zy), 'fx': list(fx)}})


def apiequipment(req):
    a = req.GET.get('a')
    userid = req.session['userid']
    companyid = getcompany(userid)
    if a == 'listall':
        objs = Equipment.objects.filter(
            deletemark=1, usecomp__partid=companyid)
        if req.GET.get('area', False):
            objs = objs.filter(area__id=req.GET.get('area'))
        if req.GET.get('cate'):
            objs = objs.filter(cate__dickeyid=req.GET.get('cate'))
        if req.GET.get('state'):
            objs = objs.filter(state=req.GET.get('state'))
        if req.GET.get('name'):
            objs = objs.filter(name__contains=req.GET.get('name'))
        if req.GET.get('b', None) == 'exportexcel':
            res = exportxlsx('equipment', objs)  # 导出设备列表
            return res
        total = objs.count()
        startnum, endnum = fenye(req)
        objs = objs.order_by('num')[startnum:endnum].values(
            'id', 'num', 'name', 'type', 'oem', 'udate', 'place', 'istz', 'iskey', 'state', 'cate__dickeyname', 'area__name','checkform__name')
        return HttpResponse(transjson(total, objs), content_type="application/json")
    elif a == 'update':
        data = json.loads(req.body.decode('utf-8'))
        id = data['id']
        if id:
            obj = Equipment.objects.get(id=id)
        else:
            obj = Equipment()
        obj.num = data['num']
        obj.name = data['name']
        obj.cate = Dickey.objects.get(dickeyid=data['cate'])
        obj.area = Area.objects.get(id=data['area'])
        obj.type = data['type']
        obj.oem = data['oem']
        obj.fnum = data['fnum']
        obj.istz = 1 if 'istz' in data else 0
        obj.iskey = 1 if 'iskey' in data else 0
        if data['fdate']:
            obj.fdate = data['fdate']
        if data['udate']:
            obj.udate = data['udate']
        obj.place = data['place']
        if data['zrbm']:
            obj.zrbm = Partment.objects.get(partid=data['zrbm'])
        if data['zrr']:
            obj.zrr = User.objects.get(userid=data['zrr'])
        if data['riskact']:
            obj.riskact = RiskAct.objects.get(id=data['riskact'])
        obj.parameter = data['parameter']
        obj.usecomp = Partment.objects.get(partid=companyid)
        obj.save()
        obj.qrcode = makeqr(
            'https://safeyun.ctcshe.com/miniprogram/equipment?id='+str(obj.id))
        obj.save()
        return JsonResponse({"code": 1})
    elif a == 'del':
        user = User.objects.get(userid=userid)
        if user.issuper == 1:
            ids = json.loads(req.body.decode('utf-8'))['ids']
            Equipment.objects.filter(id__in=ids).delete()
            return JsonResponse({"code": 1})
        else:
            return JsonResponse({"code": 0})
    elif a == 'detail':
        id = req.GET.get('id')
        a = Equipment.objects.filter(id=id).values('id', 'num', 'name', 'type', 'oem', 'udate', 'fdate', 'fnum', 'place', 'istz', 'iskey', 'state', 'cate__dickeyname',
                                                   'cate__dickeyid', 'parameter', 'img', 'area__name', 'area__id', 'zrbm__partid', 'zrr__userid', 'zrbm__partname', 'zrr__name', 'qrcode', 'riskact__name', 'riskact__id', 'checkform')
        return JsonResponse(a[0])
    elif a == 'bindjcb':
        data = json.loads(req.body.decode('utf-8'))
        ids = data['ids']
        form = EquipmentCheckForm.objects.get(id=data['form'])
        Equipment.objects.filter(id__in=ids).update(checkform=form)
        return JsonResponse({"code": 1})


def apiinspect(req):
    a = req.GET.get('a')
    userid = req.session['userid']
    companyid = getcompany(userid)
    if a == 'listall':
        a = Inspect.objects.filter(usecomp__partid=companyid)
        total = a.count()
        startnum, endnum = fenye(req)
        a = a.order_by('-id')[startnum:endnum].values('id', 'state', 'content', 'creattime', 'equipment__num', 'equipment__name',
                                                      'equipment__area__name', 'user__name', 'user__ubelongpart__partname', 'trouble__yhzt', 'trouble__yhnum', 'trouble__yhms', 'type__dickeyname')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'listself':
        a = Inspect.objects.filter(
            usecomp__partid=companyid, user__userid=userid)
        total = a.count()
        startnum, endnum = fenye(req)
        a = a.order_by('-id')[startnum:endnum].values('id', 'state', 'content', 'creattime', 'equipment__num', 'equipment__name',
                                                      'equipment__area__name', 'user__name', 'user__ubelongpart__partname', 'trouble__yhzt', 'trouble__yhnum', 'trouble__yhms', 'type__dickeyname')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'listsearch':
        a = Inspect.objects.filter(usecomp__partid=companyid)
        qssj = req.GET.get('qssj')
        jssj = req.GET.get('jssj')
        xjbm = req.GET.get('xjbm')
        xjr = req.GET.get('xjr')
        state = req.GET.get('state')
        if xjbm or xjr:
            if xjr:
                a = a.filter(user__userid=xjr)
            else:
                parts = Partment.objects.filter(partid=xjbm) | Partment.objects.filter(
                    partlink__contains=','+xjbm+',')
                a = a.filter(user__ubelongpart__in=parts)
        if qssj:
            a = a.filter(creattime__gte=qssj)
        if jssj:
            a = a.filter(creattime__lte=jssj)
        if state:
            a = a.filter(state=state)
        if req.GET.get('num', None):
            a = a.filter(equipment__num__contains = req.GET.get('num'))
        total = a.count()
        startnum, endnum = fenye(req)
        a = a.order_by('-creattime')[startnum:endnum].values('id', 'state', 'content', 'creattime', 'equipment__num', 'equipment__name',
                                                             'equipment__area__name', 'user__name', 'user__ubelongpart__partname', 'trouble__yhzt', 'trouble__yhnum', 'trouble__yhms', 'type__dickeyname')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'exportexcel':
        objs = Inspect.objects.filter(usecomp__partid=companyid)
        qssj = req.GET.get('qssj')
        jssj = req.GET.get('jssj')
        xjbm = req.GET.get('xjbm')
        xjr = req.GET.get('xjr')
        state = req.GET.get('state')
        if xjbm or xjr:
            if xjr:
                objs = objs.filter(user__userid=xjr)
            else:
                parts = Partment.objects.filter(partid=xjbm) | Partment.objects.filter(
                    partlink__contains=','+xjbm+',')
                objs = objs.filter(user__ubelongpart__in=parts)
        if qssj:
            objs = objs.filter(creattime__gte=qssj)
        if jssj:
            objs = objs.filter(creattime__lte=jssj)
        if state:
            objs = objs.filter(state=state)
        res = exportxlsx('xj', objs)
        return res
    elif a == 'add':
        data = json.loads(req.body.decode('utf-8'))
        a = Inspect()
        equipment = data['equipment']
        state = data['state']
        if 'type' in data:
            a.type = Dickey.objects.get(dickeyid=data['type'])
        if 'content' in data:
            if data['content']:
                content = data['content']
                a.content = content
        if 'trouble' in data:
            if data['trouble']:
                a.trouble = Trouble.objects.get(troubleid=data['trouble'])
        x = Equipment.objects.get(id=equipment)
        a.equipment = x
        a.state = state
        x.state = state
        x.save()
        a.usecomp = Partment.objects.get(partid=companyid)
        a.user = User.objects.get(userid=userid)
        a.save()
        return JsonResponse({"code": 1,"inspect":a.pk})
    elif a == 'del':
        id = req.GET.get('id')
        user = User.objects.get(userid=userid)
        obj = Inspect.objects.get(id=id)
        if user.issuper == 1 or obj.user == user:
            obj.delete()
            return JsonResponse({"code": 1})
        else:
            return JsonResponse({"code": 0})
    elif a == 'detail':
        id = req.GET.get('id')
        a = Inspect.objects.filter(id=id).values('id', 'state', 'content', 'creattime', 'equipment__num', 'equipment__id', 'equipment__name',
                                                 'equipment__area__name', 'user__name', 'user__ubelongpart__partname', 'trouble__yhzt', 'trouble__yhnum', 'trouble__yhms', 'trouble__troubleid', 'type__dickeyname')
        return HttpResponse(json.dumps(a[0], cls=MyEncoder), content_type="application/json")

def apiinspectitem(req):
    a = req.GET.get('a')
    userid = req.session['userid']
    companyid = getcompany(userid)
    if a == 'adds':
        data = json.loads(req.body.decode('utf-8'))
        for i in data['items']:
            if 'checked' in i and i['checked']:
                obj = InspectItem()
                obj.checked = True if 'checked' in i else False
                if 'state' in i:
                    obj.state = i['state']
                    if i['state'] == '异常待处理':
                        obj.todouser = getpgr2(userid, User.objects.get(userid=userid).ubelongpart)
                obj.checkitem = EquipmentCheckItem.objects.get(pk=i['id']) 
                obj.inspect = Inspect.objects.get(pk=data['inspect']) 
                if 'desc' in i:
                    obj.desc = i['desc']
                if 'img' in i:
                    obj.img = i['img']
                obj.save()
                if obj.state == '异常待处理':
                    postdict = {
                    'touser': obj.todouser.openid,
                    'template_id': 'lOuwSE67vZC3ZVFYPZvz2eb7JdFxqx7ysMFkXrYmYh0',
                    'miniprogram': {'appid': 'wx5c39b569f01c27db'},
                    'data': {
                        'first': {
                            'value': obj.inspect.equipment.name + '-设备异常待处理:'
                        },
                        'keyword1': {
                            'value': obj.desc
                        },
                        'keyword2': {
                            'value': obj.inspect.creattime.strftime("%Y-%m-%d %H:%M")
                        },
                        'keyword3': {
                            'value': ''
                        },
                        'remark': {
                            'value': '请及时处理设备异常!'
                        }
                        }
                    }
                    send_wechatmsg.delay(postdict)
        return JsonResponse({"code": 1})
    elif a == 'listmyyc':#我发现的异常记录
        objs = InspectItem.objects.filter(inspect__usecomp__partid=companyid, inspect__user__userid=userid).exclude(state='正常')
        total = objs.count()
        startnum, endnum = fenye(req)
        objs = objs.order_by('-id')[startnum:endnum].values('id', 'state', 'inspect', 'checkitem', 'inspect__equipment__name', 'checkitem__name','inspect__user__name', 'inspect__creattime', 'inspect__equipment__num', 'inspect__type__dickeyname')
        return HttpResponse(transjson(total, objs), content_type="application/json")
    elif a == 'listtodo':#我待办的异常
        objs = InspectItem.objects.filter(inspect__usecomp__partid=companyid, todouser__userid=userid, state='异常待处理')
        total = objs.count()
        startnum, endnum = fenye(req)
        objs = objs.order_by('-id')[startnum:endnum].values('id', 'state', 'inspect', 'checkitem', 'inspect__equipment__name', 'checkitem__name','inspect__user__name', 'inspect__creattime', 'inspect__equipment__num', 'inspect__type__dickeyname')
        return HttpResponse(transjson(total, objs), content_type="application/json")
    elif a == 'listdone':#我已处理的异常
        objs = InspectItem.objects.filter(inspect__usecomp__partid=companyid, todouser__userid=userid, state='异常已处理')
        total = objs.count()
        startnum, endnum = fenye(req)
        objs = objs.order_by('-id')[startnum:endnum].values('id', 'state', 'inspect', 'checkitem', 'inspect__equipment__name', 'checkitem__name','inspect__user__name', 'inspect__creattime', 'inspect__equipment__num', 'inspect__type__dickeyname','todouser__name')
        return HttpResponse(transjson(total, objs), content_type="application/json")
    elif a == 'listyc':#全部异常
        objs = InspectItem.objects.filter(inspect__usecomp__partid=companyid).exclude(state='正常')
        total = objs.count()
        startnum, endnum = fenye(req)
        objs = objs.order_by('-id')[startnum:endnum].values('id', 'state', 'inspect', 'checkitem', 'inspect__equipment__name', 'checkitem__name','inspect__user__name', 'inspect__creattime', 'inspect__equipment__num', 'inspect__type__dickeyname','todouser__name')
        return HttpResponse(transjson(total, objs), content_type="application/json")
    elif a == 'listall':#全部
        objs = InspectItem.objects
        if req.GET.get('inspect'):
            objs = objs.filter(inspect__id=req.GET.get('inspect'))
        total = objs.count()
        if req.GET.get('pageoff'):
            objs = objs.order_by('-id')
        else:
            startnum, endnum = fenye(req)
            objs = objs.order_by('-id')[startnum:endnum]
        objs = objs.values('id', 'state', 'inspect', 'checkitem', 'inspect__equipment__name', 'checkitem__name','checkitem__content','inspect__user__name', 'inspect__creattime', 'inspect__equipment__num', 'inspect__type__dickeyname','todouser__name', 'desc', 'desc2', 'img', 'img2')
        return HttpResponse(transjson(total, objs), content_type="application/json")
    elif a == 'detail':
        id = req.GET.get('id')
        a = InspectItem.objects.filter(id=id).values('id', 'state', 'inspect', 'checkitem', 'inspect__equipment__name', 'inspect__equipment__id', 'checkitem__name', 'checkitem__content','inspect__user__name', 'inspect__creattime', 'inspect__equipment__num', 'inspect__type__dickeyname',
                                                            'img', 'desc', 'img2', 'desc2', 'todouser__name', 'handletime')
        return HttpResponse(json.dumps(a[0], cls=MyEncoder), content_type="application/json")
    elif a == 'handle':
        data = json.loads(req.body.decode('utf-8'))
        obj = InspectItem.objects.get(id=data['id'])
        obj.desc2 = data['desc2'] if ('desc2' in data and data['desc2']) else None
        obj.img2 = data['img2'] if ('img2' in data and data['img2']) else None
        obj.handletime = datetime.now()
        obj.state = '异常已处理'
        if InspectItem.objects.filter(inspect__equipment=obj.inspect.equipment,state='异常待处理').exists():
            obj.inspect.equipment.state = 0
            obj.inspect.equipment.save()
        else:
            obj.inspect.equipment.state = 1
            obj.inspect.equipment.save()
        obj.save()
        return JsonResponse({'code': 1})
        



def apiriskact(req):
    a = req.GET.get('a')
    userid = req.session['userid']
    companyid = getcompany(userid)
    if a == 'listall':
        a = RiskAct.objects.filter(usecomp__partid=companyid)
        if req.GET.get('area', None):
            a = a.filter(area__id=req.GET.get('area'))
        if req.GET.get('type', None):
            a = a.filter(type__dickeyid=req.GET.get('type'))
        if req.GET.get('kind', None):
            a = a.filter(kind=req.GET.get('kind'))
        total = a.count()
        startnum, endnum = fenye(req)
        a = a.order_by('area')[startnum:endnum].values('id', 'area__name', 'type__dickeyname',
                                                       'name', 'level', 'qrcode', 'group__groupname', 'zrbm__partname', 'zrr__name', 'gkcj')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'listall2':
        a = RiskAct.objects
        if req.GET.get('area'):
            a = a.filter(area__id=req.GET.get('area'))
        total = a.count()
        a = a.values('id', 'area__name', 'type__dickeyname', 'name', 'level',
                     'qrcode', 'group__groupname', 'zrbm__partname', 'zrr__name', 'gkcj')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'listself':
        groups = Group.objects.filter(users=User.objects.get(userid=userid))
        objs = RiskAct.objects.filter(group__in=groups)
        if req.GET.get('area'):
            objs = objs.filter(area__id=req.GET.get('area'))
        if req.GET.get('type'):
            objs = objs.filter(type__dickeyid=req.GET.get('type'))
        total = objs.count()
        startnum, endnum = fenye(req)
        objs = objs.order_by('area')[startnum:endnum].values('id', 'area__name', 'type__dickeyname',
                                                             'name', 'level', 'qrcode', 'group__groupname', 'zrbm__partname', 'zrr__name', 'gkcj')
        return HttpResponse(transjson(total, objs), content_type="application/json")
    elif a == 'add':
        data = json.loads(req.body.decode('utf-8'))
        obj = RiskAct()
        if 'area' in data and data['area']:
            obj.area = Area.objects.get(id=data['area'])
        obj.type = Dickey.objects.get(dickeyid=data['type'])
        obj.name = data['name']
        obj.place = data['place'] if data['place'] else None
        obj.usecomp = Partment.objects.get(partid=companyid)
        obj.gkcj = data['gkcj']
        obj.zrbm = Partment.objects.get(partid=data['zrbm'])
        obj.zrr = User.objects.get(userid=data['zrr'])
        obj.group = Group.objects.get(groupid=data['group'])
        if 'kind' in data and data['kind']:
            obj.kind = data['kind']
        obj.save()
        obj.qrcode = makeqr_riskact(
            'https://safeyun.ctcshe.com/miniprogram/riskact?id='+str(obj.id))
        obj.save()
        return JsonResponse({'code': 1})
    elif a == 'edit':
        data = json.loads(req.body.decode('utf-8'))
        obj = RiskAct.objects.get(id=data['id'])
        obj.area = Area.objects.get(id=data['area'])
        obj.type = Dickey.objects.get(dickeyid=data['type'])
        obj.name = data['name']
        obj.place = data['place'] if data['place'] else None
        obj.usecomp = Partment.objects.get(partid=companyid)
        obj.gkcj = data['gkcj']
        obj.zrbm = Partment.objects.get(partid=data['zrbm'])
        obj.zrr = User.objects.get(userid=data['zrr'])
        obj.group = Group.objects.get(groupid=data['group'])
        obj.save()
        return JsonResponse({'code': 1})
    elif a == 'detail':
        obj = RiskAct.objects.filter(id=req.GET.get('id'))
        num = Risk.objects.filter(riskact=obj[0]).count()
        obj = obj.values('id', 'area__id', 'place', 'type__dickeyid', 'name', 'type__dickeyname', 'area__name', 'level', 'qrcode',
                         'gkcj', 'group__groupid', 'zrbm__partid', 'zrr__userid', 'group__groupname', 'zrbm__partname', 'zrr__name')[0]
        obj['num'] = num
        return JsonResponse({'code': 1, 'data': obj})
    elif a == 'del':
        id = req.GET.get('id')
        user = User.objects.get(userid=userid)
        if user.issuper == 1:
            obj = RiskAct.objects.get(id=id)
            obj.delete()
            try:
                cal_area_risk_level(obj.area)
            except:
                pass
            return JsonResponse({"code": 1})
        else:
            return JsonResponse({"code": 0})
    elif a == 'listalltask':
        a = RiskAct.objects.filter(
            usecomp__partid=companyid, type__dickeyid=396)
        total = a.count()
        startnum, endnum = fenye(req)
        a = a.order_by('-tasktype', 'group')[startnum:endnum].values('group__groupname',
                                                                     'area__name', 'type__dickeyname', 'id', 'group__groupid', 'name', 'tasktype', 'tasktime')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'updatetask':
        tasktype = int(req.POST.get('tasktype'))
        riskacts = json.loads(req.POST.get('riskacts'))
        firsttime = req.POST.get('firsttime')
        if firsttime:
            firsttime = datetime.strptime(str(firsttime), '%Y-%m-%d %H:%M')
        tasktime = datetime.now()  # 任务开始时间
        if firsttime:
            tasktime = firsttime
        for x in riskacts:
            obj = RiskAct.objects.get(id=x['id'])
            obj.tasktype = tasktype
            obj.tasktime = tasktime
            obj.save()
            RiskActTask.objects.filter(
                riskact=obj, usable=1, istask=1).update(usable=2)
            if tasktype == 1:
                RiskActTask.objects.create(
                    riskact=obj, taskadd=tasktime, taskexpire=tasktime + timedelta(hours=8), istask=1)
            elif tasktype == 2:
                RiskActTask.objects.create(
                    riskact=obj, taskadd=tasktime, taskexpire=tasktime + timedelta(days=1), istask=1)
            elif tasktype == 3:
                RiskActTask.objects.create(
                    riskact=obj, taskadd=tasktime, taskexpire=tasktime + timedelta(days=7), istask=1)
        return JsonResponse({"code": 1})

def apimyschedule(req):
    a = req.GET.get('a')
    userid = req.session['userid']
    companyid = getcompany(userid)
    if a == 'listcombobox':
        objs = MySchedule.objects.filter(usecomp__partid=companyid)
        objsdata = objs.values('id','name')
        keystr = transstr(objsdata, 'id', 'name')
        return HttpResponse(keystr, content_type="application/json")
    elif a == 'listall':
        objs = MySchedule.objects.filter(usecomp__partid=companyid)
        total = objs.count()
        startnum, endnum = fenye(req)
        objdata = objs.order_by('-pk')[startnum:endnum].values('id', 'name')
        return HttpResponse(transjson(total, objdata), content_type="application/json")
    elif a == 'add':
        data = json.loads(req.body.decode('utf-8'))
        if data['set'] == 'interval':
            iobj, b = IntervalSchedule.objects.get_or_create(every=data['every'], period=data['period'], defaults={'every':data['every'], 'period':data['period']})
            MySchedule.objects.create(name=data['name'], typeset=data['set'], interval=iobj, usecomp=Partment.objects.get(partid=companyid))
        elif data['set'] == 'crontab':
            cron = {
                'minute' : data['minute'],
                'hour': data['hour'],
                'day_of_week': data['day_of_week'],
                'day_of_month': data['day_of_month'],
                'month_of_year': data['month_of_year'],
                'timezone': 'Asia/Shanghai'
            }
            iobj, b = CrontabSchedule.objects.get_or_create(**cron, defaults=cron)
            MySchedule.objects.create(name=data['name'], typeset=data['set'], crontab=iobj, usecomp=Partment.objects.get(partid=companyid))
        return JsonResponse({'code': 1})
    elif a == 'del':
        user = User.objects.get(userid=userid)
        if user.issuper == 1:
            MySchedule.objects.get(id=req.GET.get('id')).delete()
            return JsonResponse({'code': 1})
        else:
            return JsonResponse({'code': 0})
def apigridtaskset(req):
    a = req.GET.get('a')
    userid = req.session['userid']
    companyid = getcompany(userid)
    if a == 'listall':
        objs = GridTaskSet.objects.filter(riskact__usecomp__partid=companyid)
        if req.GET.get('riskact', None):
            objs = objs.filter(riskact__id=req.GET.get('riskact'))
        total = objs.count()
        startnum, endnum = fenye(req)
        objs = objs.order_by('-pk')[startnum:endnum].values('id', 'gridlevel__dickeyname', 'user__name',
                                                       'myschedule__name', 'note', 'periodictask__enabled','last_run_at','count')
        return HttpResponse(transjson(total, objs), content_type="application/json")
    elif a == 'add':
        data = json.loads(req.body.decode('utf-8'))
        if 'myschedule' in data and data['myschedule']:
            schobj = MySchedule.objects.get(id=data['myschedule'])
            pobj = PeriodicTask()
            pobj.name = 'gridtask_' + time.strftime('%Y%m%d%H%M%S')
            pobj.task = 'safesite.tasks.sendGridtask2'
            pobj.interval = schobj.interval if schobj.interval else None
            pobj.crontab = schobj.crontab if schobj.crontab else None
            pobj.save()
            obj = GridTaskSet()
            obj.riskact = RiskAct.objects.get(id=data['riskact'])
            obj.user = User.objects.get(userid=data['user'])
            obj.gridlevel = Dickey.objects.get(dickeyid=data['gridlevel'])
            obj.note = data['note'] if 'note' in data and data['note'] else None
            obj.expire = data['expire'] if 'expire' in data and data['expire'] else None
            obj.periodictask = pobj
            obj.myschedule = schobj
            obj.save()
            pobj.kwargs=json.dumps({'gridtaskset':obj.id})
            pobj.save()
        return JsonResponse({'code': 1})
    elif a == 'detail':
        objs = GridTaskSet.objects.filter(id=req.GET.get('id'))
        objdata = objs.values('id', 'gridlevel__dickeyname', 'user__name','user__userid','gridlevel__dickeyid','myschedule__id',
                                                       'myschedule__name', 'note')[0]
        xx = {'code':1, 'data':objdata}
        return HttpResponse(json.dumps(xx, cls=MyEncoder), content_type="application/json")
    elif a == 'del':
        id = req.GET.get('id')
        obj = GridTaskSet.objects.get(id=id)
        obj.delete()
        obj.periodictask.delete()
        return JsonResponse({"code": 1})
    elif a == 'edit':
        data = json.loads(req.body.decode('utf-8'))
        obj = GridTaskSet.objects.get(id=data['id'])
        obj.user = User.objects.get(userid=data['user'])
        obj.gridlevel = Dickey.objects.get(dickeyid=data['gridlevel'])
        obj.note = data['note'] if 'note' in data and data['note'] else None
        obj.expire = data['expire'] if 'expire' in data and data['expire'] else None
        pobj = obj.periodictask
        if 'myschedule' in data and data['myschedule']:
            schobj = MySchedule.objects.get(id=data['myschedule'])
            pobj.interval = schobj.interval if schobj.interval else None
            pobj.crontab = schobj.crontab if schobj.crontab else None
            pobj.save()
            obj.myschedule = schobj
        obj.save()
        # from .tasks import shifttime
        # print(shifttime(10, 'seconds', datetime.now()))
        return JsonResponse({'code': 1})
    elif a == 'toggle':
        obj = GridTaskSet.objects.get(id=req.GET.get('id'))
        if obj.periodictask.enabled:
            obj.periodictask.enabled = False
            obj.periodictask.save()
        else:
            obj.periodictask.enabled = True
            obj.periodictask.save()
        return JsonResponse({'code': 1})

def apirisk(req):
    a = req.GET.get('a')
    userid = req.session['userid']
    companyid = getcompany(userid)
    if a == 'listall':
        a = Risk.objects.filter(usecomp__partid=companyid)
        if req.GET.get('riskact'):
            a = a.filter(riskact__id=req.GET.get('riskact'))
            total = a.count()
        else:
            if req.GET.get('kind', None):
                a = a.filter(riskact__kind=req.GET.get('kind'))
            startnum, endnum = fenye(req)
            total = a.count()
            a = a[startnum:endnum]
        a = a.values('id', 'step', 'hazard', 'result', 'level', 'riskl', 'riske', 'riskc', 'riskd', 'measure1', 'measure2',
                     'measure3', 'measure4', 'measure5', 'riskact__name', 'riskact__area__name', 'riskact__area__id', 'riskact__place')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'listall2':  # 按风险点聚合
        a = Risk.objects.filter(usecomp__partid=companyid,
                                riskact__type__dickeyid=396)  # 设备设施类
        total = a.count()
        startnum, endnum = fenye(req)
        a = a.order_by('-tasktype', 'group__groupid')[startnum:endnum].values('group__groupname', 'riskact__area__name',
                                                                              'riskact__type__dickeyname', 'riskact__id', 'group__groupid', 'riskact__name', 'tasktype', 'tasktime').annotate(num=Count('group'))
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'listself':
        groups = Group.objects.filter(users=User.objects.get(userid=userid))
        a = Risk.objects.filter(group__in=groups).values('id', 'step', 'level', 'riskact__id',
                                                         'riskact__name', 'riskact__area__name', 'riskact__area__id').order_by('riskact__id', 'id')
        total = a.count()
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'detail':
        obj = Risk.objects.filter(id=req.GET.get('id'))
        data = obj.values('id', 'riskact__name', 'riskact__area__name', 'riskact__type__dickeyname', 'step', 'hazard', 'level', 'result', 'measure1', 'measure2', 'measure3',
                          'measure4', 'measure5', 'riskl', 'riske', 'riskc', 'riskd', 'riskact__group__groupname', 'riskact__zrbm__partname', 'riskact__zrr__name', 'riskact__gkcj')
        return JsonResponse(data[0])
    elif a == 'steps':
        data = json.loads(req.body.decode('utf-8'))
        if req.GET.get('type') == 'equipment':
            areaid = data['areaid']
            equipmentid = data['id']
            equipmentname = data['name']
            objs = Risk.objects.filter(usecomp__partid=companyid)
            equipment = Equipment.objects.get(id=equipmentid)
            if equipment.riskact:  # 如果该设备存在绑定的风险
                objs = objs.filter(riskact=equipment.riskact)
            else:
                objs = objs.filter(riskact__area__id=areaid,
                                   riskact__name__contains=equipmentname)
            if objs.exists():
                return JsonResponse({'code': 1, 'steps': list(objs.values('id', 'step', 'hazard', 'result', 'level', 'riskact__group__groupname', 'riskact__zrbm__partname', 'riskact__zrr__name'))})
            else:
                return JsonResponse({'code': 0})
    
  
    elif a == 'del':
        id = req.GET.get('id')
        user = User.objects.get(userid=userid)
        obj = Risk.objects.get(id=id)
        obj.delete()
        try:
            cal_riskact_level(obj.riskact)
        except:
            pass
        return JsonResponse({"code": 1})
    elif a == 'add':
        data = json.loads(req.body.decode('utf-8'))
        obj = Risk()
        obj.step = data['step']
        obj.hazard = data['hazard']
        obj.result = data['result']
        obj.measure1 = data['measure1'] if data['measure1'] else None
        obj.measure2 = data['measure2'] if data['measure2'] else None
        obj.measure3 = data['measure3'] if data['measure3'] else None
        obj.measure4 = data['measure4'] if data['measure4'] else None
        obj.measure5 = data['measure5'] if data['measure5'] else None
        obj.riskact = RiskAct.objects.get(id=data['riskact'])
        obj.createuser = User.objects.get(userid=userid)
        obj.riskl = data['riskl']
        obj.riske = data['riske']
        obj.riskc = data['riskc']
        riskd = float(data['riskl'])*float(data['riske'])*float(data['riskc'])
        obj.riskd = riskd
        if riskd >= 320:
            obj.level = '重大风险'
        elif 320 > riskd >= 160:
            obj.level = '较大风险'
        elif 160 > riskd >= 70:
            obj.level = '一般风险'
        else:
            obj.level = '低风险'
        obj.usecomp = Partment.objects.get(partid=companyid)
        obj.save()
        try:
            cal_riskact_level(obj.riskact)
        except:
            pass
        return JsonResponse({"code": 1})
    elif a == 'update':
        data = json.loads(req.body.decode('utf-8'))
        obj = Risk.objects.get(id=data['id'])
        obj.step = data['step']
        obj.hazard = data['hazard']
        obj.result = data['result']
        obj.measure1 = data['measure1'] if data['measure1'] else None
        obj.measure2 = data['measure2'] if data['measure2'] else None
        obj.measure3 = data['measure3'] if data['measure3'] else None
        obj.measure4 = data['measure4'] if data['measure4'] else None
        obj.measure5 = data['measure5'] if data['measure5'] else None
        obj.createuser = User.objects.get(userid=userid)
        obj.riskl = data['riskl']
        obj.riske = data['riske']
        obj.riskc = data['riskc']
        riskd = float(data['riskl'])*float(data['riske'])*float(data['riskc'])
        obj.riskd = riskd
        if riskd >= 320:
            obj.level = '重大风险'
        elif 320 > riskd >= 160:
            obj.level = '较大风险'
        elif 160 > riskd >= 70:
            obj.level = '一般风险'
        else:
            obj.level = '低风险'
        obj.usecomp = Partment.objects.get(partid=companyid)
        obj.save()
        try:
            cal_riskact_level(obj.riskact)
        except:
            pass
        return JsonResponse({"code": 1})
    elif a == 'update':
        data = json.loads(req.body.decode('utf-8'))
        obj = Risk.objects.get(id=data['id'])
        obj.step = data['step']
        obj.hazard = data['hazard']
        obj.result = data['result']
        obj.measure1 = data['measure1'] if data['measure1'] else None
        obj.measure2 = data['measure2'] if data['measure2'] else None
        obj.measure3 = data['measure3'] if data['measure3'] else None
        obj.measure4 = data['measure4'] if data['measure4'] else None
        obj.measure5 = data['measure5'] if data['measure5'] else None
        obj.createuser = User.objects.get(userid=userid)
        obj.riskl = data['riskl']
        obj.riske = data['riske']
        obj.riskc = data['riskc']
        riskd = float(data['riskl'])*float(data['riske'])*float(data['riskc'])
        obj.riskd = riskd
        if riskd >= 320:
            obj.level = '重大风险'
        elif 320 > riskd >= 160:
            obj.level = '较大风险'
        elif 160 > riskd >= 70:
            obj.level = '一般风险'
        else:
            obj.level = '低风险'
        obj.usecomp = Partment.objects.get(partid=companyid)
        obj.save()
        try:
            cal_riskact_level(obj.riskact)
        except:
            pass
        return JsonResponse({"code": 1})


def apirisktask(req):
    a = req.GET.get('a')
    userid = req.session['userid']
    companyid = getcompany(userid)
    if a == 'updates':
        tasktype = int(req.POST.get('tasktype'))
        risks = json.loads(req.POST.get('risks'))
        firsttime = req.POST.get('firsttime')
        if firsttime:
            firsttime = datetime.strptime(str(firsttime), '%Y-%m-%d %H:%M')
        for i in risks:
            objs = Risk.objects.filter(
                riskact__id=i['riskact__id'], group__groupid=i['group__groupid'])
            tasktime = datetime.now()  # 任务开始时间
            if firsttime:
                tasktime = firsttime
                # if tasktype == 1:#每班
                #     tasktime = firsttime + timedelta(hours=8)
                # elif tasktype == 2:#每天
                #     tasktime = firsttime + timedelta(days=1)
                # elif tasktype == 3:#每周
                #     tasktime = firsttime + timedelta(weeks=1)
                # elif tasktype == 4:#每月
                #     tasktime = firsttime - timedelta(weeks=4)
            objs.update(tasktype=tasktype, tasktime=tasktime)
            for x in objs:
                Risktask.objects.filter(risk=x, usable=1).update(usable=2)
                if tasktype == 1:
                    Risktask.objects.create(
                        risk=x, group=x.group, taskadd=tasktime, taskexpire=tasktime + timedelta(hours=8))
                elif tasktype == 2:
                    Risktask.objects.create(
                        risk=x, group=x.group, taskadd=tasktime, taskexpire=tasktime + timedelta(days=1))
                elif tasktype == 3:
                    Risktask.objects.create(
                        risk=x, group=x.group, taskadd=tasktime, taskexpire=tasktime + timedelta(days=7))
        return JsonResponse({"code": 1})
    elif a == 'list2todo':
        groups = Group.objects.filter(users__userid=userid)
        objs = Risktask.objects.filter(group__in=groups, usable=1).values('risk__group__groupname', 'risk__riskact__area__name', 'risk__riskact__type__dickeyname', 'risk__riskact__id',
                                                                          'risk__group__groupid', 'risk__riskact__name', 'risk__riskact__level', 'risk__tasktype', 'taskadd', 'taskexpire', 'user__userid').annotate(num=Count('risk__group'))
        total = objs.count()
        startnum, endnum = fenye(req)
        objs = objs[startnum:endnum]
        return HttpResponse(transjson(total, objs), content_type="application/json")
    elif a == 'todonum':
        groups = Group.objects.filter(users__userid=userid)
        objs = Risktask.objects.filter(
            group__in=groups, usable=1, user=None).annotate(num=Count('risk__group'))
        total = objs.count()
        return JsonResponse({"code": 1, "todonum": total})
    elif a == 'list2done':
        groups = Group.objects.filter(users__userid=userid)
        objs = Risktask.objects.filter(Q(group__in=groups) | Q(user__userid=userid), usable__in=[0, 2]).values(
            'risk__group__groupname', 'risk__riskact__area__name', 'risk__riskact__type__dickeyname', 'risk__riskact__id', 'risk__tasktype', 'taskadd', 'taskexpire', 'user__userid', 'usable').annotate(num=Count('risk__group'))
        total = objs.count()
        startnum, endnum = fenye(req)
        objs = objs[startnum:endnum]
        return HttpResponse(transjson(total, objs), content_type="application/json")
    elif a == 'listalltodo':  # 全厂待办
        groups = Group.objects.filter(usecomp__partid=companyid)
        objs = Risktask.objects.filter(group__in=groups, usable=1).values('risk__group__groupname', 'risk__riskact__area__name', 'risk__riskact__type__dickeyname', 'risk__riskact__id',
                                                                          'risk__group__groupid', 'risk__riskact__name', 'risk__riskact__level', 'risk__tasktype', 'taskadd', 'taskexpire', 'user__userid').annotate(num=Count('risk__group'))
        total = objs.count()
        startnum, endnum = fenye(req)
        objs = objs[startnum:endnum]
        return HttpResponse(transjson(total, objs), content_type="application/json")
    elif a == 'listall':  # 全厂任务聚合
        groups = Group.objects.filter(usecomp__partid=companyid)
        objs = Risktask.objects.filter(group__in=groups).order_by('-usable', 'risk__group__groupid').values('risk__group__groupname', 'risk__riskact__area__name', 'risk__riskact__type__dickeyname',
                                                                                                            'risk__riskact__id', 'risk__group__groupid', 'risk__riskact__name', 'risk__riskact__level', 'risk__tasktype', 'taskadd', 'taskexpire', 'user__userid', 'usable').annotate(num=Count('risk__group'))
        total = objs.count()
        startnum, endnum = fenye(req)
        objs = objs[startnum:endnum]
        return HttpResponse(transjson(total, objs), content_type="application/json")
    elif a == 'listtask':
        objs = Risktask.objects.filter(
            usable=1, risk__riskact__usecomp__partid=companyid)
        if req.GET.get('riskact'):
            objs = objs.filter(risk__riskact__id=req.GET.get('riskact'))
        if req.GET.get('group'):
            objs = objs.filter(group__groupid=req.GET.get('group'))
        total = objs.count()
        startnum, endnum = fenye(req)
        objs = objs[startnum:endnum].values('id', 'risk__id', 'risk__step', 'risk__hazard', 'risk__level', 'risk__result', 'risk__measure1', 'risk__measure2', 'risk__measure3', 'risk__measure4',
                                            'risk__measure5', 'risk__riskact__area__name', 'risk__riskact__area__id', 'risk__riskact__place', 'trouble__yhnum', 'user__userid', 'user__name', 'user__ubelongpart__partname', 'taskdo')
        return HttpResponse(transjson(total, objs), content_type="application/json")
    elif a == 'checktrouble':  # 发现隐患
        data = json.loads(req.body.decode('utf-8'))
        trouble = data['trouble']
        risktask = data['risktask']
        Risktask.objects.filter(id=risktask).update(
            trouble=Trouble.objects.get(troubleid=trouble))
        obj = Risktask.objects.get(id=risktask)
        Riskcheck.objects.create(risk=obj.risk, user=User.objects.get(
            userid=userid), risktask=obj, trouble=Trouble.objects.get(troubleid=trouble))
        return JsonResponse({'code': 1})
    elif a == 'update':  # 风险点检查更新
        data = json.loads(req.body.decode('utf-8'))
        nowtime = datetime.now()
        Risktask.objects.filter(id__in=data['tasks']).update(
            user=User.objects.get(userid=userid), taskdo=nowtime)
        for i in data['tasks']:
            objs = Riskcheck.objects.filter(risktask__id=i)
            if objs.exists():
                objs.update(dotime=nowtime)
            else:
                obj = Risktask.objects.get(id=i)
                Riskcheck.objects.create(risk=obj.risk, user=User.objects.get(
                    userid=userid), risktask=obj, dotime=nowtime)
        return JsonResponse({'code': 1})


def apiriskacttask(req):
    a = req.GET.get('a')
    userid = req.session['userid']
    companyid = getcompany(userid)
    if a == 'listalltask':  # 全厂任务
        objs = RiskActTask.objects.filter(riskact__usecomp__partid=companyid, istask=1).order_by('-pk','-usable', 'riskact__group__groupid').values('riskact__group__groupname', 'riskact__area__name',
                                                                                                                                              'riskact__type__dickeyname', 'riskact__id', 'riskact__group__groupid', 'riskact__name', 'riskact__level', 'riskact__tasktype', 'taskadd', 'taskexpire', 'user__userid', 'usable', 'taskdo', 'user__name')
        total = objs.count()
        startnum, endnum = fenye(req)
        objs = objs[startnum:endnum]
        return HttpResponse(transjson(total, objs), content_type="application/json")
    elif a == 'listall':  # 全厂排查记录
        objs = RiskActTask.objects.filter(riskact__usecomp__partid=companyid).exclude(taskdo=None)
        if req.GET.get('pcbm'):
            parts = getparts(req.GET.get('pcbm'))
            objs = objs.filter(user__ubelongpart__in=parts)
        if req.GET.get('qssj'):
            objs = objs.filter(taskdo_gte=req.GET.get('qssj'))
        if req.GET.get('jssj'):
            objs = objs.filter(taskdo__lte=req.GET.get('jssj'))
        total = objs.count()
        startnum, endnum = fenye(req)
        objs = objs.order_by('-taskdo')[startnum:endnum].values('id', 'riskact__name', 'riskact__area__name', 'riskact__place',
                                            'taskdo', 'state', 'user__ubelongpart__partname', 'user__name', 'taskdo', 'istask')
        return HttpResponse(transjson(total, objs), content_type="application/json")
    elif a == 'listalltodo':  # 全厂待办任务
        objs = RiskActTask.objects.filter(istask=1, taskdo=None, usable=1)
        total = objs.count()
        startnum, endnum = fenye(req)
        objs = objs[startnum:endnum].values('id', 'riskact__group__groupname', 'riskact__area__name', 'riskact__type__dickeyname', 'riskact__id',
                                            'riskact__group__groupid', 'riskact__name', 'riskact__level', 'riskact__tasktype', 'taskadd', 'taskexpire', 'user__userid', 'usable', 'user__name')
        return HttpResponse(transjson(total, objs), content_type="application/json")
    elif a == 'listself':  # 排查记录
        a = RiskActTask.objects.filter(user__userid=userid)
        total = a.count()
        startnum, endnum = fenye(req)
        a = a.order_by('-id')[startnum:endnum].values('id', 'riskact__level', 'riskact__name', 'riskact__area__name', 'riskact__place',
                                                      'taskdo', 'state', 'usable', 'riskact__group__groupname', 'taskadd', 'taskexpire', 'user__userid', 'riskact__id', 'user__name')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'listmytodo':  # 待办
        groups = Group.objects.filter(users__userid=userid)
        objs = RiskActTask.objects.filter(
            riskact__group__in=groups, usable=1, istask=1, user=None)
        total = objs.count()
        startnum, endnum = fenye(req)
        objs = objs[startnum:endnum].values('id', 'riskact__group__groupname', 'riskact__area__name', 'riskact__type__dickeyname', 'riskact__id',
                                            'riskact__group__groupid', 'riskact__name', 'riskact__level', 'riskact__tasktype', 'taskadd', 'taskexpire', 'user__userid', 'user__name')
        return HttpResponse(transjson(total, objs), content_type="application/json")
    elif a == 'listmytodo2':  # 我的待办
        objs = RiskActTask.objects.filter(usable=1, istask=1, user__userid=userid)
        total = objs.count()
        startnum, endnum = fenye(req)
        objs = objs.order_by('-id')[startnum:endnum].values('id', 'riskact__group__groupname', 'riskact__area__name', 'riskact__type__dickeyname', 'riskact__id',
                                            'riskact__group__groupid', 'riskact__name', 'riskact__level', 'riskact__tasktype', 'taskadd', 'taskexpire', 'user__userid', 'user__name')
        return HttpResponse(transjson(total, objs), content_type="application/json")
    elif a == 'todonum':
        groups = Group.objects.filter(users__userid=userid)
        objs = RiskActTask.objects.filter(
            riskact__group__in=groups, usable=1, user=None)
        total = objs.count()
        return JsonResponse({"code": 1, "todonum": total})
    elif a == 'todonum2': # 我的待办统计
        objs = RiskActTask.objects.filter(usable=1, user__userid=userid,taskdo=None)
        total = objs.count()
        return JsonResponse({"code": 1, "todonum": total})
    elif a == 'detail':
        obj = RiskActTask.objects.filter(pk=req.GET.get('id'))
        return JsonResponse({'code':1, 'data':obj.values('id', 'tasknote', 'note')[0]})
    # elif a == 'listmydone':
    #     groups = Group.objects.filter(users__userid=userid)
    #     objs = Risktask.objects.filter(Q(group__in=groups)|Q(user__userid=userid),usable__in=[0,2]).values('risk__group__groupname','risk__riskact__area__name','risk__riskact__type__dickeyname','risk__riskact__id','risk__tasktype','taskadd','taskexpire','user__userid','usable').annotate(num = Count('risk__group'))
    #     total = objs.count()
    #     startnum,endnum=fenye(req)
    #     objs = objs[startnum:endnum]
    #     return HttpResponse(transjson(total,objs),content_type="application/json")


def apiriskcheck2(req):
    a = req.GET.get('a')
    userid = req.session['userid']
    companyid = getcompany(userid)
    if a == 'add':
        nowtime = datetime.now()
        data = json.loads(req.body.decode('utf-8'))
        checkrisks = data['checks']
        user = User.objects.get(userid=userid)
        # objs = RiskActTask.objects.filter(
        #     riskact__id=data['riskact'], usable=1, user=None, istask=1)  # 匹配未处理的任务
        objs = RiskActTask.objects.filter(
            riskact__id=data['riskact'], usable=1, user=user, istask=1)  # 匹配最近本人未处理的任务
        if objs.exists():
            obj = objs.last()
            obj.user = user
            obj.taskdo = nowtime
            obj.usable = 0
            obj.note = data['note'] if 'note' in data else None 
            obj.save()
        else:
            obj = RiskActTask()
            obj.riskact = RiskAct.objects.get(id=data['riskact'])
            obj.user = user
            obj.istask = 0
            obj.taskdo = nowtime
            obj.note = data['note'] if 'note' in data else None 
            obj.save()
        for i in checkrisks:
            risk = Risk.objects.get(id=i['id'])
            if 'trouble' in i:
                Riskcheck2.objects.create(risk=risk, riskacttask=obj, trouble=Trouble.objects.get(
                    troubleid=i['trouble']), dotime=nowtime)
                obj.state = 0
                obj.save()
            else:
                Riskcheck2.objects.create(
                    risk=risk, riskacttask=obj, dotime=nowtime)
        return JsonResponse({'code': 1})
    elif a == 'listall':
        objs = Riskcheck2.objects.filter(risk__usecomp__partid=companyid)
        if req.GET.get('riskacttask'):
            objs = objs.filter(riskacttask__id=req.GET.get('riskacttask'))
        total = objs.count()
        startnum, endnum = fenye(req)
        objs = objs.order_by('trouble')[startnum:endnum].values('id','risk', 'risk__step', 'risk__level','trouble', 'trouble__yhnum', 'risk__hazard',
                                                            'risk__result', 'risk__measure1', 'risk__measure2', 'risk__measure3', 'risk__measure4', 'risk__measure5', 'riskacttask', 'riskacttask__taskdo')
        return HttpResponse(transjson(total, objs), content_type="application/json")


def apiriskcheck(req):
    a = req.GET.get('a')
    userid = req.session['userid']
    companyid = getcompany(userid)
    if a == 'add':
        nowtime = datetime.now()
        data = json.loads(req.body.decode('utf-8'))['checks']
        for i in data:
            risk = Risk.objects.get(id=i['id'])
            if 'trouble' in i:
                Riskcheck.objects.create(risk=risk, user=User.objects.get(
                    userid=userid), trouble=Trouble.objects.get(troubleid=i['trouble']), dotime=nowtime)
                objs = Risktask.objects.filter(risk=risk, usable=1, user=None)
                if objs.exists():
                    objs.update(user=User.objects.get(userid=userid), taskdo=nowtime,
                                trouble=Trouble.objects.get(troubleid=i['trouble']))
            else:
                Riskcheck.objects.create(
                    risk=risk, dotime=nowtime, user=User.objects.get(userid=userid))
                objs = Risktask.objects.filter(risk=risk, usable=1, user=None)
                if objs.exists():
                    objs.update(user=User.objects.get(
                        userid=userid), taskdo=nowtime)
        return JsonResponse({'code': 1})
    elif a == 'listself':
        a = Riskcheck.objects.filter(user__userid=userid)
        total = a.count()
        startnum, endnum = fenye(req)
        a = a.order_by('-id')[startnum:endnum].values('id', 'risk__step', 'risk__level', 'risk__riskact__name',
                                                      'risk__riskact__area__name', 'risk__riskact__place', 'dotime', 'trouble__yhnum')
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'listall':
        objs = Riskcheck.objects.filter(user__usecomp__partid=companyid)
        if req.GET.get('pcbm'):
            parts = getparts(req.GET.get('pcbm'))
            objs = objs.filter(user__ubelongpart__in=parts)
        if req.GET.get('qssj'):
            objs = objs.filter(dotime_gte=req.GET.get('qssj'))
        if req.GET.get('jssj'):
            objs = objs.filter(dotime__lte=req.GET.get('jssj'))
        total = objs.count()
        startnum, endnum = fenye(req)
        objs = objs.order_by('-id')[startnum:endnum].values('id', 'risk__step', 'risk__level', 'risk__riskact__name',
                                                            'risk__riskact__area__name', 'risk__riskact__place', 'dotime', 'trouble__yhnum', 'user__ubelongpart__partname', 'user__name')
        return HttpResponse(transjson(total, objs), content_type="application/json")


def apireport(req):
    a = req.GET.get('a')
    userid = req.session['userid']
    if a == 'detail':
        year = req.GET.get('year')
        month = req.GET.get('month')
        part = req.GET.get('part')
        objs = Report.objects.filter(year=year, month=month)
        if part and part != 'undefined':
            objs = objs.filter(part__partid=part)
        else:
            objs = objs.filter(part=User.objects.get(userid=userid).usecomp)
        if objs.exists():
            return JsonResponse({'code': 1, 'data': objs.values('id', 'cause', 'suggest')[0]})
        else:
            return JsonResponse({'code': 0, 'data': ''})
    elif a == 'add':
        data = json.loads(req.body.decode('utf-8'))
        year = req.GET.get('year')
        month = req.GET.get('month')
        part = req.GET.get('part')
        if part:
            objs = Report.objects.filter(
                year=year, month=month, part__partid=part)
        else:
            objs = Report.objects.filter(
                year=year, month=month, part=User.objects.get(userid=userid).usecomp)
        if objs.exists():
            obj = objs[0]
        else:
            obj = Report()
            obj.year = year
            obj.month = month
            if part:
                obj.part = Partment.objects.get(partid=part)
            else:
                obj.part = User.objects.get(userid=userid).usecomp
        obj.cause = data['cause']
        obj.suggest = data['suggest']
        obj.save()
        return JsonResponse({'code': 1})


# 公司信息展示
def companyinfo(req):
    message = ''
    try:
        user = User.objects.filter(pk=req.session['userid'])
        companyid = getcompany(req.session['userid'])
        companyname = Partment.objects.get(partid=companyid).partname
        # 生成CompanyInof的model对象
        companyinfo = CompanyInfo.objects.get_or_create(
            partment_id=companyid)[0]
    except Exception as e:
        raise
        # message='操作错误'
        # return render( req, 'companyinfo.html',{'message': message})

    if req.method == 'POST':
        companyinfo_form = forms.CompanyInfoForm(req.POST)
        if companyinfo_form.is_valid():
            companyinfo.name = companyinfo_form.cleaned_data.get('name')
            companyinfo.address = companyinfo_form.cleaned_data.get('address')
            companyinfo.nature = companyinfo_form.cleaned_data.get('nature')
            companyinfo.fixed_assets = companyinfo_form.cleaned_data.get(
                'fixed_assets')
            companyinfo.introduce = companyinfo_form.cleaned_data.get(
                'introduce')
            companyinfo.legalperson = companyinfo_form.cleaned_data.get(
                'legalperson')
            companyinfo.legalperson_phone = companyinfo_form.cleaned_data.get(
                'legalperson_phone')
            companyinfo.liaison = companyinfo_form.cleaned_data.get('liaison')
            companyinfo.liaison_fax = companyinfo_form.cleaned_data.get(
                'liaison_fax')
            companyinfo.liaison_phone = companyinfo_form.cleaned_data.get(
                'liaison_phone')
            companyinfo.peoplenum = companyinfo_form.cleaned_data.get(
                'peoplenum')
            companyinfo.website = companyinfo_form.cleaned_data.get('website')
            companyinfo.save()
            #html = 'companyinfo.html'
            # return redirect('/withmenu/', html="companyinfo.html")
            # return HttpResponseRedirect("/withmenu/?html=companyinfo.html")
            return JsonResponse({'code': 1})
    companyinfo_form = forms.CompanyInfoForm(model_to_dict(companyinfo))
    return render(req, 'companyinfo.html',
                  {'companyinfo': companyinfo_form})


def refresh_captcha(request):
    hashkey = CaptchaStore.generate_key()
    image_url = captcha_image_url(hashkey)
    return HttpResponse(json.dumps({'key': hashkey, 'image_url': image_url}), content_type='application/json')


def dump(obj):
    print('\n'.join(['%s:%s' % item for item in obj.__dict__.items()]))

# 教育培训统计图


def trainfg(req):
    a = req.GET.get('a')
    userid = req.session['userid']
    companyid = getcompany(userid)

    if a == 'trainfig':
        year = int(req.GET.get('year'))
        months = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
        companylevel = []  # 公司级
        workshoplevel = []  # 车间/工段级
        teamlevel = []  # 班组级
        departmentlevel = []  # 部门分厂级
        for month in months:
            first_day, first_day_of_next_month = gettime(
                datetime(year, month, 1))

            a = Train.objects.filter(usecomp__partid=companyid, deletemark=1, starttime__range=(
                first_day, first_day_of_next_month))
            companylevel.append(a.filter(trainlevel__dicid=5).count())
            workshoplevel.append(a.filter(trainlevel__dicid=6).count())
            teamlevel.append(a.filter(trainlevel__dicid=7).count())
            departmentlevel.append(a.filter(trainlevel__dicid=42).count())
        return JsonResponse({'code': 1, 'companylevel': companylevel, 'workshoplevel': workshoplevel, 'teamlevel': teamlevel, 'departmentlevel': departmentlevel})
    elif a == 'trainuser':
        a = Trainuser.objects.filter(participant__usecomp__partid=companyid)
        if req.GET.get('qssj'):
            a = a.filter(train__submittime__gte=req.GET.get('qssj'))
        if req.GET.get('jssj'):
            a = a.filter(train__submittime__lte=req.GET.get('jssj'))
        if req.GET.get('fxbm'):
            fxbm = req.GET.get('fxbm')
            parts = Partment.objects.filter(
                partlink__contains=',' + fxbm + ',') | Partment.objects.filter(partid=fxbm)
            a = a.filter(participant__ubelongpart__in=parts)
        total = a.count()
        objs = a.values('participant__name', 'participant__username').annotate(
            count=Count('participant__userid'))
        return HttpResponse(transjson(total, objs), content_type="application/json")
    elif a == 'traintype':
        year = int(req.GET.get('year'))
        month = int(req.GET.get('month'))
        traintypelist = []

        first_day, first_day_of_next_month = gettime(datetime(year, month, 1))
        a = Train.objects.filter(usecomp__partid=companyid, deletemark=1, starttime__range=(
            first_day, first_day_of_next_month))
        for i in Dickey.objects.filter(Q(usecomps__contains=',1,') | Q(usecomps__contains=','+str(companyid)+','), dicparent_id=8):
            count = a.filter(traintype__dickeyid=i.dickeyid).count()
            dickeyname = i.dickeyname
            traintypelist.append({'value': count, 'name': dickeyname})
        return HttpResponse(json.dumps({'code': 1, 'data': {'traintypelist': list(traintypelist)}}), content_type='application/json')
# 设备统计图


def equipmentfig(req):
    a = req.GET.get('a')
    userid = req.session['userid']
    companyid = getcompany(userid)

    if a == 'state':
        # year = int(req.GET.get('year'))
        # month = int(req.GET.get('month'))
        # first_day,first_day_of_next_month = gettime(datetime(year,month,1))
        a = Equipment.objects.filter(usecomp__partid=companyid, deletemark=1)
        normal = a.filter(state=1).count()  # 正常
        abnormal = a.filter(state=0).count()  # 异常
        return JsonResponse({"code": 1, "normal": normal, "abnormal": abnormal})
    elif a == 'eqmcount':
        eqmlist = Equipment.objects.filter(usecomp__partid=companyid, deletemark=1).values(
            'area__name').annotate(num=Count('area'))

        return HttpResponse(json.dumps({'code': 1, 'data': {'eqmlist': list(eqmlist)}}), content_type='application/json')


#责任制
def getresbilitydata(req):
    a = req.GET.get('a')
    userid = req.session['userid']
    companyid = getcompany(userid)
    if a=='dic':#行为列表
        
       dicclass=req.GET.get('dicclass')
       a = Dickey.objects.filter(dicparent=dicclass,deletemark=1)
       a = (a.filter(usecomps__contains=',1,')|a.filter(usecomps__contains=','+companyid+',')).exclude(nousecomps__contains=','+companyid+',')
       a = a.values('dickeyid','dicparent__dicname','dickeyname','dicparent__dicid','detail').order_by('dickeyid')
       return HttpResponse(transstr(a,'dickeyid','dickeyname'),content_type="application/json")
    elif a=='job':#岗位列表
        joblist = Group.objects.filter(usecomp__partid=companyid).exclude(grouptype=0).values('groupid', 'groupname', 'grouptype')
        return HttpResponse(transstr(joblist,'groupid','groupname'),content_type="application/json")
    elif a== 'tree':#部门列表
        list_items = (Partment.objects.filter(partlink__contains=','+companyid+',') | Partment.objects.filter(partid=companyid)
                      ).annotate(id=F('partid'), parentId=F('parentid'), name=F('partname')).values('id', 'parentId', 'name')
        return HttpResponse(json.dumps(list(list_items)), content_type="application/json")
    elif a== 'upload':#文件上传
        username = User.objects.get(userid=req.session['userid']).username
        file_name = time.strftime('%Y%m%d%H%M%S')+ '_' + req.FILES['mf'].name
        user_upload_folder = os.path.join('media/zeren', username)
        if not os.path.exists(user_upload_folder):
            os.mkdir(user_upload_folder)
        filepath = os.path.join(user_upload_folder, file_name)
        filepath = filepath.replace('\\','/')
        with open( filepath, 'wb') as f:
            f.write(req.FILES['mf'].read())
        return JsonResponse({"code":1,"filename":file_name,"filepath":filepath})
    elif a=='add':#新增责任制
         obj = Resbility()
         data = json.loads(req.body.decode('utf-8'))
         obj.title = data['title']
         if 'group' in data and data['group']:

             obj.jobs =Group.objects.get(groupid= data['group'])
         if 'type' in data and data['type']:
             obj.homeworktype= Dickey.objects.get(dickeyid=data['type'])
         if data['filepath']:
             obj.resbilitypath=data['filepath']

         obj.createuser=User.objects.get(userid=userid)
         if 'publisdate' in data and data['publisdate']:
             obj.createdate=data['publisdate']
         obj.usecomp=Partment.objects.get(partid=companyid)
         if data['filepath']:
             obj.filepath=data['filepath']
         if 'jobpart' in data and data['jobpart']:
             obj.department=Partment.objects.get(partid=data['jobpart'])
        
         obj.save()
         return JsonResponse({"code":1})
    elif a=='listall':#责任列表
         startnum,endnum=fenye(req)
         #groups = Group.objects.filter(users__userid=userid)
        # part= Partment.objects.filter(partid=User.objects.get(userid=userid).ubelongpart.partid)
         #a = Resbility.objects.filter(usecomp=companyid,jobs__in=groups,department__in=part).order_by('id')
         a = Resbility.objects.filter(usecomp=companyid,deletemark=1).order_by('id')
         total = a.count()
         startnum,endnum=fenye(req)
         a = a[startnum:endnum].values('id','title','department__partname','jobs__groupname','resbilitypath','homeworktype__dickeyname','createdate','createuser__name','reads')
         return HttpResponse(transjson(total,a),content_type="application/json")
       #点击阅读
    elif a=='readnum':
         id =req.GET.get('id')
         a = Resbility.objects.get(id=id)
         a.reads=a.reads+1
         a.save()
         obj = Readerblility()
         obj.readid=a
         obj.num=''
         obj.readeruser=User.objects.get(userid=userid)
         obj.save()
         return JsonResponse({"code":1,"url": a.resbilitypath})
     #删除
    elif a == 'del':
        id =req.GET.get('id')
        userid = req.session['userid']
        companyid = getcompany(userid)#公司ID
        a = Resbility.objects.get(id=id)
        if a.createuser==User.objects.get(userid=userid):
           a.deletemark=0
           a.save()
           return JsonResponse({"code":1})

        else:
            
            return JsonResponse({"code":0})
    elif a=='detail':
         id =req.GET.get('zrid')
         a = Readerblility.objects.filter(readid=id).values('id','readeruser__name','readertime')
         total = a.count()
         return HttpResponse(transjson(total,a),content_type="application/json")


#操作规程
def getprodata(req):
    a = req.GET.get('a')
    userid = req.session['userid']
    companyid = getcompany(userid)
    if a=='dic':#行为列表
        
       dicclass=req.GET.get('dicclass')
       a = Dickey.objects.filter(dicparent=dicclass,deletemark=1)
       a = (a.filter(usecomps__contains=',1,')|a.filter(usecomps__contains=','+companyid+',')).exclude(nousecomps__contains=','+companyid+',')
       a = a.values('dickeyid','dicparent__dicname','dickeyname','dicparent__dicid','detail').order_by('dickeyid')
       return HttpResponse(transstr(a,'dickeyid','dickeyname'),content_type="application/json")
    elif a=='job':#岗位列表
        joblist = Group.objects.filter(usecomp__partid=companyid).exclude(grouptype=0).values('groupid', 'groupname', 'grouptype')
        return HttpResponse(transstr(joblist,'groupid','groupname'),content_type="application/json")
    elif a== 'tree':#部门列表
        list_items = (Partment.objects.filter(partlink__contains=','+companyid+',') | Partment.objects.filter(partid=companyid)
                      ).annotate(id=F('partid'), parentId=F('parentid'), name=F('partname')).values('id', 'parentId', 'name')
        return HttpResponse(json.dumps(list(list_items)), content_type="application/json")
    elif a== 'upload':#文件上传
        username = User.objects.get(userid=req.session['userid']).username
        file_name = time.strftime('%Y%m%d%H%M%S')+ '_' + req.FILES['mf'].name
        user_upload_folder = os.path.join('media/caozuo', username)
        if not os.path.exists(user_upload_folder):
            os.mkdir(user_upload_folder)
        filepath = os.path.join(user_upload_folder, file_name)
        filepath = filepath.replace('\\','/')
        with open( filepath, 'wb') as f:
            f.write(req.FILES['mf'].read())
        return JsonResponse({"code":1,"filename":file_name,"filepath":filepath})
    elif a=='add':#新增责任制
         obj = Operproce()
         data = json.loads(req.body.decode('utf-8'))
         obj.title = data['title']
         if 'group' in data and data['group']:
             obj.jobs =Group.objects.get(groupid= data['group'])
         if 'type' in data and data['type']:
             obj.homeworktype= Dickey.objects.get(dickeyid=data['type'])
         if 'jobpart' in data and data['jobpart']:
             obj.department=Partment.objects.get(partid=data['jobpart'])
         if data['filepath']:
             obj.operprocepath=data['filepath']
         obj.createuser=User.objects.get(userid=userid)
         if 'publisdate' in data and data['publisdate']:
             obj.createdate=data['publisdate']
         obj.usecomp=Partment.objects.get(partid=companyid)
         if data['filepath']:
             obj.filepath=data['filepath']
         obj.save()
         return JsonResponse({"code":1})
    elif a=='listall':#责任列表
         startnum,endnum=fenye(req)
         #groups = Group.objects.filter(users__userid=userid)
        # part= Partment.objects.filter(partid=User.objects.get(userid=userid).ubelongpart.partid)
         #a = Resbility.objects.filter(usecomp=companyid,jobs__in=groups,department__in=part).order_by('id')
         a = Operproce.objects.filter(usecomp=companyid,deletemark=1).order_by('id')
         total = a.count()
         startnum,endnum=fenye(req)
         a = a[startnum:endnum].values('id','title','department__partname','jobs__groupname','operprocepath','homeworktype__dickeyname','createdate','createuser__name','reads')
         return HttpResponse(transjson(total,a),content_type="application/json")
       #点击阅读
    elif a=='readnum':
         id =req.GET.get('id')
         a = Operproce.objects.get(id=id)
         a.reads=a.reads+1
         a.save()
         obj = ReaderOperproce()
         obj.readid=a
         obj.num=''
         obj.readeruser=User.objects.get(userid=userid)
         obj.save()
         return JsonResponse({"code":1,"url": a.operprocepath})
     #删除
    elif a == 'del':
        id =req.GET.get('id')
        userid = req.session['userid']
        companyid = getcompany(userid)#公司ID
        a = Operproce.objects.get(id=id)
        if a.createuser==User.objects.get(userid=userid):
           a.deletemark=0
           a.save()
           return JsonResponse({"code":1})

        else:
            
            return JsonResponse({"code":0})
    elif a=='detail':
         id =req.GET.get('zrid')
         a = ReaderOperproce.objects.filter(readid=id).values('id','readeruser__name','readertime')
         total = a.count()
         return HttpResponse(transjson(total,a),content_type="application/json")
def checkprojects(req):
    a = req.GET.get('a')
    userid = req.session['userid']
    companyid = getcompany(userid)
    if a == 'add':
        data = json.loads(req.body.decode('utf-8'))
        if data['id']==0:

        
            obj = Checkproject()
        
            obj.checktitle = data['checktitle']
            obj.checkcontent = data['checkcontent']
            obj.createuser = User.objects.get(userid=userid)
            obj.requirements = data['requirements']
            obj.usecomp=Partment.objects.get(partid=companyid)
            obj.save()
        else:
            obj = Checkproject.objects.get(id=data['id'])
        
            obj.checktitle = data['checktitle']
            obj.checkcontent = data['checkcontent']
            obj.requirements = data['requirements']
            obj.save()
        
        
        return JsonResponse({"code": 1})
    elif a == 'detail':
        obj = Checkproject.objects.filter(id=req.GET.get('id'))
        obj = obj.values('checktitle', 'checkcontent', 'requirements')[0]
       
        return JsonResponse({'code': 1, 'data': obj})

    elif a == 'project':
         projectlist = Checkproject.objects.filter(usecomp__partid=companyid).values('id', 'checktitle', 'checkcontent')
         return HttpResponse(transstr(projectlist,'id','checktitle'),content_type="application/json")
    elif a == 'listall':
        startnum,endnum = fenye(req)
        a = Checkproject.objects.filter(usecomp=Partment.objects.get(partid=companyid), deletemark=1)
        
        total = a.count()
        startnum, endnum = fenye(req)
        a = a[startnum:endnum].values('id','checktitle', 'checkcontent', 'requirements', 'createuser__name', 'createdate')
        
        return HttpResponse(transjson(total, a), content_type="application/json") 
    #任务表保存
    elif a == 'addcheck':
        data = json.loads(req.body.decode('utf-8'))
        obj = Checktable()
        obj.checktitle = data['checktaskname']
        obj.checkcontent=data['checkcontent']
        obj.createuser = User.objects.get(userid=userid)
        obj.usecomp=Partment.objects.get(partid=companyid)
        obj.save()
        #list = data['checkprjtype']
        #for i in list:
         #  x = Checkproject.objects.get(id=i)
          # obj.checkprjtype.add(x)
        return JsonResponse({"code": 1})
    #任务列表
    elif a == 'listall2':
        startnum,endnum = fenye(req)
        a = Checktable.objects.filter(usecomp=Partment.objects.get(partid=companyid), deletemark=1)
        total = a.count()
        startnum, endnum = fenye(req)
        
        a = a[startnum:endnum].values('id','checktitle','checkcontent', 'createuser__name','createdate')
        
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'listall3':
        startnum,endnum = fenye(req)
        a = Checktask.objects.filter(usecomp=Partment.objects.get(partid=companyid), deletemark=1).order_by('-createdate')
        total = a.count()
        startnum, endnum = fenye(req)
        
        a = a[startnum:endnum].values('id','checktaskname','taskstate','tasktype','checktype__checktitle','checkplace', 'checktime','createuser__name','createdate')
       
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'listall4':
        startnum,endnum = fenye(req)
        a = Checkjob.objects.filter(usecomp=Partment.objects.get(partid=companyid),checkname__userid=userid,deletemark=1).order_by('-starttime')
        total = a.count()
        startnum, endnum = fenye(req)
        
        a = a.order_by('-starttime')[startnum:endnum].values('id','checktask__checktaskname','jobstate','starttime','endtime','yanshou','checkquestion','zguser__username','zgtime','checktask__checktype__checktitle','checkname__username','checkname__name', 'taskstate','checktask__checktime','createuser__username','createdate')
        
        return HttpResponse(transjson(total, a), content_type="application/json")


    elif a == 'listchuli':
        a = Checkjob.objects.filter(usecomp=Partment.objects.get(partid=companyid),taskstate=2,checktask__createuser__userid=userid).exclude(deletemark=0,yanshou=None)
        total = a.count()
        
        startnum, endnum = fenye(req)
        a = a.order_by('-starttime')[startnum:endnum].values('id','checkname__name','checktask__checktaskname','jobstate','starttime','endtime','yanshou','checkquestion','zguser__username','zgtime','checktask__checktype__checktitle','checkname__username', 'taskstate','checktask__checktime','createuser__username','createdate')
        
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'wxlistall':
        a = Checkjob.objects.filter(usecomp=Partment.objects.get(partid=companyid),taskstate=2).exclude(deletemark=0)
        total = a.count()
        startnum, endnum = fenye(req)
        a = a.order_by('-starttime')[startnum:endnum].values('id','checkname__name','checktask__checktaskname','jobstate','starttime','endtime','yanshou','checkquestion','zguser__username','zgtime','checktask__checktype__checktitle','checkname__username', 'taskstate','checktask__checktime','createuser__username','createdate')
        
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'listself':
        a = Checkjob.objects.filter(usecomp=Partment.objects.get(partid=companyid),checkname__userid=userid,deletemark=1)
        s=a.filter(Q(taskstate=1)|Q(taskstate=4))
        total = s.count()
        startnum, endnum = fenye(req)
        
        a = s.order_by('-starttime')[startnum:endnum].values('id','checkname__name','checktask__checktaskname','jobstate','starttime','endtime','yanshou','checkquestion','zguser__username','zgtime','checktask__checktype__checktitle','checkname__username', 'taskstate','checktask__checktime','createuser__username','createdate')
        
        return HttpResponse(transjson(total, a), content_type="application/json")
    elif a == 'listallx':
        a = Checkjob.objects.filter(usecomp=Partment.objects.get(
            partid=companyid),deletemark=1)
        total = a.count()
        startnum, endnum = fenye(req)
        a = a.order_by('-starttime')[startnum:endnum].values('id','checkname__name','checktask__checktaskname','jobstate','starttime','endtime','yanshou','checkquestion','zguser__username','zgtime','checktask__checktype__checktitle','checkname__username', 'taskstate','checktask__checktime','createuser__username','createdate')
        
        return HttpResponse(transjson(total, a), content_type="application/json")

    elif a == 'jobdetail':
         obj = Checkjob.objects.filter(id=req.GET.get('id'))
         obj = obj.values('checktask__checktaskname','zguser','yhtp','content','jctime','zgtime','checkname__name','zgjg','jobstate','taskstate','checkquestion','checktask__checkplace','checktask__checktype__checkcontent','checkname__username','checktask__checktime')[0]
         if obj['yhtp']:
            obj['yhtp'] = obj['yhtp'].split('?')
            
         else:
            obj['yhtp'] == []
         return JsonResponse({'code': 1, 'data': obj})
    elif a == 'addjob':
         data = json.loads(req.body.decode('utf-8'))
         yhtp = '?'.join(data['yhtp1']) if 'yhtp1' in data else []
         zghtp = '?'.join(data['zghtp']) if 'zghtp' in data else []
         obj = Checkjob.objects.get(id=req.GET.get('jobid'))
         if data['checkquestion']:
             obj.checkquestion = data['checkquestion'] 
         obj.zgjg = data['zgjg']
         obj.taskstate =int(data['taskstate'])
         obj.createuser = User.objects.get(userid=userid)
         obj.content=data['content']
         obj.jctime=datetime.now()
         obj.zgtime=datetime.now()
         if yhtp:
             obj.yhtp=yhtp
         obj.zghtp=zghtp
         s=[]
         if data['participant']!="":
             list = data['participant'].split(',')
             for i in list:
                x = User.objects.get(userid=i)
                obj.pmpeople.add(x)
                s.append(x.openid)
         postdict = {
                'touser': '',
                'template_id': 'lOuwSE67vZC3ZVFYPZvz2eb7JdFxqx7ysMFkXrYmYh0',
                "miniprogram": {"appid": "wx5c39b569f01c27db"},
                'data': {
                    'first': {
                        'value': '处罚通知:'
                    },
                    'keyword1': {
                        'value':'经验教训：'+ obj.content
                    },
                    'keyword2': {
                        'value': '通知时间：'+str(obj.createdate)
                    },
                    'keyword3': {
                        'value': '涉及人员：'+obj.createuser.name
                    },
                    'remark': {
                        'value': '请及时查看阅读'
                    }
                }
            }
         send_wechatmsgs.delay(postdict, s)
         obj.save()
         obj_checktask = obj.checktask
         if obj_checktask.zxstate==2:
               for i in obj_checktask.checkname.all():
                  if i.userid != userid:
                      Checkjob.objects.filter(checkname=i,checktask=obj_checktask).update(taskstate=3)
         return JsonResponse({'code': 1})
   
    elif a == 'yanshou':
         obj = Checkjob.objects.get(id=req.GET.get('id'))
         obj.yanshou = datetime.now()
         obj.yanshouren = User.objects.get(userid=userid)
         obj.save()
         return JsonResponse({'code': 1})
    elif a=='checktablist':
         projectlist = Checktable.objects.filter(usecomp__partid=companyid,deletemark=1).values('id', 'checktitle')
         return HttpResponse(transstr(projectlist,'id','checktitle'),content_type="application/json")
    elif a=='checktablist2':
         projectlist = Checktask.objects.filter(usecomp__partid=companyid,deletemark=1).values('id', 'checktaskname')
         return HttpResponse(transstr(projectlist,'id','checktaskname'),content_type="application/json")
    elif a=='addchecklist':
         data = json.loads(req.body.decode('utf-8'))
        
         tasktype=int(data['tasktype'])
         starttime =datetime.strptime(str(data['starttime']), '%Y-%m-%d %H:%M')
         obj = Checktask()
         obj.checktaskname = data['checktaskname']
         obj.checktime=starttime
         obj.checkplace=data['checkplace']
         obj.zxstate=data['zxstate']
         obj.tasktype=tasktype
         obj.checktype =Checktable.objects.get(id=data['checktabtitle']) 
         obj.createuser = User.objects.get(userid=userid)
         obj.usecomp=Partment.objects.get(partid=companyid)
         obj.userlist=data['participant'].split(',')
         obj.save()
         
         list = data['participant'].split(',')
         s=[]
         for i in list:
            x = User.objects.get(userid=i)
            obj.checkname.add(x)
            objs = Checkjob()
            objs.checktask=obj
            objs.checkname=x
            objs.taskstate=4
            objs.starttime=starttime
            if tasktype==1:
               objs.endtime =starttime+ timedelta(days=1)
            elif tasktype==2:
               objs.endtime=starttime + timedelta(days=7)
            elif tasktype==3:
               objs.endtime=starttime+ timedelta(days=30)
            elif tasktype==4:
               objs.endtime=starttime + timedelta(days=120)
            elif tasktype==5:
               objs.endtime=starttime + timedelta(days=182)
            elif tasktype==6:
               objs.endtime=starttime + timedelta(days=365)
            
            objs.usecomp=Partment.objects.get(partid=companyid)
            
            objs.save()
            s.append(x.openid)
         postdict = {
                'touser': '',
                'template_id': 'lOuwSE67vZC3ZVFYPZvz2eb7JdFxqx7ysMFkXrYmYh0',
                "miniprogram": {"appid": "wx5c39b569f01c27db"},
                'data': {
                    'first': {
                        'value': '检查任务通知:'
                    },
                    'keyword1': {
                        'value':'任务名：'+ obj.checktaskname
                    },
                    'keyword2': {
                        'value': '执行时间：'+str(data['starttime'])
                    },
                    'keyword3': {
                        'value': '发布人：'+obj.createuser.name
                    },
                    'remark': {
                        'value': '请及时查看阅读'
                    }
                }
            }
         send_wechatmsgs.delay(postdict, s)
         return JsonResponse({"code": 1})
     
     #专项检查
    elif a=='addchecklist2':
         data = json.loads(req.body.decode('utf-8'))
        
         
         starttime =datetime.strptime(str(data['starttime']), '%Y-%m-%d %H:%M')
         endtime =datetime.strptime(str(data['endtime']), '%Y-%m-%d %H:%M')
         obj = Checktask()
         obj.checktaskname = data['checktaskname']
         obj.checktime=starttime
         obj.checkplace=data['checkplace']
         obj.zxstate=data['zxstate']
         obj.tasktype=7#专项检查
         obj.checktype =Checktable.objects.get(id=data['checktabtitle']) 
         obj.createuser = User.objects.get(userid=userid)
         obj.usecomp=Partment.objects.get(partid=companyid)
         obj.userlist=data['participant'].split(',')
         obj.save()
         
         list = data['participant'].split(',')
         s=[]
         for i in list:
            x = User.objects.get(userid=i)
            obj.checkname.add(x)
            objs = Checkjob()
            objs.checktask=obj
            objs.checkname=x
            objs.taskstate=4
            objs.starttime=starttime
            
            objs.endtime=endtime
            
            objs.usecomp=Partment.objects.get(partid=companyid)
            
            objs.save()
            s.append(x.openid)
         postdict = {
                'touser': '',
                'template_id': 'lOuwSE67vZC3ZVFYPZvz2eb7JdFxqx7ysMFkXrYmYh0',
                "miniprogram": {"appid": "wx5c39b569f01c27db"},
                'data': {
                    'first': {
                        'value': '检查任务通知:'
                    },
                    'keyword1': {
                        'value':'任务名：'+ obj.checktaskname
                    },
                    'keyword2': {
                        'value': '执行时间：'+str(data['starttime'])
                    },
                    'keyword3': {
                        'value': '发布人：'+obj.createuser.name
                    },
                    'remark': {
                        'value': '请及时查看阅读'
                    }
                }
            }
         send_wechatmsgs.delay(postdict, s)
         return JsonResponse({"code": 1})
     

    
     #删除
    elif a == 'del':
        id =req.GET.get('id')
        a = Checktask.objects.get(id=id)
        if User.objects.get(userid=userid).issuper == 1:
           a.deletemark=0
           a.save()
           return JsonResponse({"code":1})

        else:
            
            return JsonResponse({"code":0})
    elif a == 'updchechtab':
         obj = Checktable.objects.filter(id=req.GET.get('id'))
         obj = obj.values('checktitle','checkcontent')[0]
       
         return JsonResponse({'code': 1, 'data': obj})
    elif a == 'updchecktaba':
        data = json.loads(req.body.decode('utf-8'))
        a = Checktable.objects.get(id=req.GET.get('id'))
        a.checktitle = data['checktaskname']
        a.checkcontent = data['checkcontent']
        a.save()
        return JsonResponse({"code": 1})
    elif a == 'deltab':
        id =req.GET.get('id')
        a = Checktable.objects.get(id=id)
        if User.objects.get(userid=userid).issuper == 1:
           a.deletemark=0
           a.save()
           return JsonResponse({"code":1})

        else:
            
            return JsonResponse({"code":0})
        
    elif a == 'deljob':
        id =req.GET.get('id')
        a = Checkjob.objects.get(id=id)
        if User.objects.get(userid=userid).issuper == 1:
           a.deletemark=0
           a.save()
           return JsonResponse({"code":1})

        else:
            
            return JsonResponse({"code":0})

    elif a == 'checkjobdetail':
        id = req.GET.get('id')
        a = Checkjob.objects.filter(id=id)
        list1=Checkjob.objects.get(id=id).pmpeople.all()
        uselist=[]
        for item in list1:
            uselist.append(item.name)
        
        x = a.values('checktask__checktaskname','starttime','zgjg','checktask__tasktype','endtime','jobstate','zguser__username','checktask__checktype__checkcontent','checktask__checkplace','checktask__checktime' ,'checkname__username','checkname__name', 'checkquestion', 'zgtime', 'zguser__username', 'createuser__username',
                     'createdate', 'taskstate','zghtp','jctime','content','yhtp','pmpeople', 'zgyq','zgjg', 'yanshou', 'yanshouren__name')[0]
        x['bcfr'] = uselist
        if x['yhtp']:
            x['yhtp'] = x['yhtp'].split('?')
        else:
            x['yhtp'] == []
        if x['zghtp']:
            x['zghtp'] = x['zghtp'].split('?')
        else:
            x['zghtp'] == []
        return HttpResponse(json.dumps(x, cls=MyEncoder), content_type="application/json")
    elif a == 'checkdetail':
        id = req.GET.get('id')
        a = Checktask.objects.filter(id=id)
        list1=Checktask.objects.get(id=id).checkname.all()
        uselist=[]
        for item in list1:
            uselist.append(item.name)
        
        x = a.values('checktaskname','zxstate','tasktype','checkplace','checktime','checktype__checktitle','checktype__checkcontent')[0]
        x['bcfr'] = uselist
        return HttpResponse(json.dumps(x, cls=MyEncoder), content_type="application/json")
    elif a=='checkstop':
        id = req.GET.get('id')
        a = Checktask.objects.get(id=id)
        if a.createuser==User.objects.get(userid=userid):
           a.taskstate=2
           a.save()
           return JsonResponse({"code":1})

        else:
            
            return JsonResponse({"code":0})
#筛选
    elif a == 'listsearch':
        a = Checkjob.objects.filter(usecomp=Partment.objects.get(
            partid=companyid)).exclude(deletemark=0)
        qssj = req.GET.get('qssj')#开始时间
        jssj = req.GET.get('jssj')#结束时间
        checktabtitle = req.GET.get('checktabtitle')#检查表名
        checktaskname = req.GET.get('checktaskname')#任务名称
        checkername = req.GET.get('checkername', None)
        if qssj:
            a = a.filter(starttime__gte=qssj)
        if jssj:
            a = a.filter(starttime__lte=jssj)
        if checktabtitle:
            a = a.filter(checktask__checktype__id=checktabtitle)
        if checktaskname:
            a = a.filter(checktask__id=checktaskname)
        if checkername:
            a = a.filter(checkname__name=checkername)
        total = a.count()
         
        startnum, endnum = fenye(req)
        
        a = a.order_by('-starttime')[startnum:endnum].values('id','checktask__checktaskname','jobstate','starttime','endtime','yanshou','checkquestion','zguser__username','zgtime','checktask__checktype__checktitle','checkname__username','checkname__name', 'taskstate','checktask__checktime','createuser__username','createdate')
        
        return HttpResponse(transjson(total, a), content_type="application/json")