ASJServer/Controller/EquipmentManager.py

from django.views.decorators.csrf import csrf_exempt
from django.core import serializers
import traceback
from Service.ResponseService import *
from Service.ModelService import ModelService
from Model.models import Device_User, Device_Info
from Service.TokenManager import JSONTokenManager
from Service.CommonService import CommonService


def queryUserEquipment(userID):
    try:
        deviceValid = Device_Info.objects.filter(userID_id = userID)
    except Exception as e:
        errorInfo = traceback.format_exc()
        print('查询数据库错误: %s' % errorInfo)
        return ResponseFormal(500, repr(e))
    else:
        if deviceValid:
            sqlJSON = serializers.serialize('json', Device_Info.objects.filter(userID_id = userID))
            sqlList = json.loads(sqlJSON)
            sqlDict = dict(zip(["datas"], [sqlList]))
            return ResponseFormal(0,sqlDict)
        else:
            UserValid = Device_User.objects.filter(userID=userID)
            if UserValid:
                return ResponseFormal(172)
            else:
                return ResponseFormal(113)

def addNewUserEquipment(userID, deviceContent, bulk = False):
    userIDValid = Device_User.objects.filter(userID = userID)
    if userIDValid:
        try:
            try:
                deviceData = json.loads(deviceContent)
            except Exception as e:
                return ResponseFormal(803,repr(e))
            else:
                UID = deviceData.get('UID', None)
                if UID != None:
                    # is_bind = Device_Info.objects.filter(UID = UID,isShare=False)
                    # if is_bind:
                    #     return ResponseFormal(175)
                    dValid = Device_Info.objects.filter(userID = userID, UID = UID)
                    if dValid:
                        return ResponseFormal(174)
                    else:
                        if 'NickName' in deviceData:
                            nValid = Device_Info.objects.filter(userID=userID, NickName=deviceData['NickName'])
                            if nValid.exists():
                                return ResponseJSON(179)
                        userDevice = Device_Info(id=CommonService.getUserID(getUser=False), userID_id=userID, **deviceData)
                        userDevice.save()
                else:
                    return ResponseFormal(806)

        except Exception as e:
            errorInfo = traceback.format_exc()
            print('添加设备错误: %s ' % errorInfo)
            return ResponseFormal(178,repr(e))
        else:
            sqlJSON = serializers.serialize('json', [userDevice])
            sqlList = json.loads(sqlJSON)
            sqlDict =dict(zip(["datas"], [sqlList]))
            return ResponseFormal(0,sqlDict)
    else:
        return ResponseFormal(113)


def delUserEquipment(userID, id):
    try:
        deviceValid = Device_Info.objects.filter(userID_id = userID, id = id)
    except Exception as e:
        errorInfo = traceback.format_exc()
        print('查询数据库错误: %s' % errorInfo)
        return ResponseFormal(500, repr(e))
    else:
        if deviceValid:
            try:
                Device_Info.objects.filter(userID_id = userID, id = id).delete()
            except Exception as e:
                errorInfo = traceback.format_exc()
                print('删除数据库记录错误: %s' % errorInfo)
                return ResponseFormal(176,repr(e))
            else:
                return ResponseFormal(0)
        else:
            UserValid = Device_User.objects.filter(userID = userID)
            if UserValid:
                return ResponseFormal(172)
            else:
                return ResponseFormal(113)

def modifyUserEquipment(userID, deviceContent, id):
    try:
        deviceValid = Device_Info.objects.filter(userID_id = userID, id = id)
    except Exception as e:
        errorInfo = traceback.format_exc()
        print('查询数据库错误: %s' % errorInfo)
        return ResponseFormal(500, repr(e))
    else:
        if deviceValid:
            deviceData = json.loads(deviceContent)
            try:
                userDevice = Device_Info.objects.filter(userID_id = userID, id = id).update(**deviceData)
            except Exception as e:
                errorInfo = traceback.format_exc()
                print('修改设备信息错误: %s ' % errorInfo)
                return ResponseFormal(177,repr(e))
            else:
                sqlJSON = serializers.serialize('json', Device_Info.objects.filter(userID_id = userID, id = id))
                sqlList = json.loads(sqlJSON)
                sqlDict = dict(zip(["datas"], [sqlList]))
                return ResponseFormal(0,sqlDict)
        else:
            UserValid = Device_User.objects.filter(userID=userID)
            if UserValid:
                return ResponseFormal(172)
            else:
                return ResponseFormal(113)

def showAllUserEquipment(userID):

    try:
        userValid = Device_User.objects.filter(userID = userID).order_by('-data_joined')
    except Exception as e:
        errorInfo = traceback.format_exc()
        print('查询数据库错误: %s' % errorInfo)
        return ResponseFormal(500,repr(e))

    else:
        if userValid:
            # own_permission = ModelService.check_permission(userID=userID,permID=30)
            if userValid[0].is_superuser != 100 and userValid[0].is_superuser != 1:
                return ResponseFormal(604)
            else:
                sqlJSON = serializers.serialize('json', Device_Info.objects.all())#.order_by('-data_joined'))
                sqlList = json.loads(sqlJSON)
                print(sqlList, sqlJSON)
                sqlDict = dict(zip(["datas"], [sqlList]))
                return ResponseFormal(0,sqlDict)
        else:
            return ResponseFormal(113)

def showAllUserEquipmentPC(userID,fieldDict):
    try:
        user_valid = Device_User.objects.filter(userID=userID).order_by('-data_joined')
    except Exception as e:
        errorInfo = traceback.format_exc()
        print('查询数据库错误: %s' % errorInfo)
        return ResponseJSON(500,repr(e))
    else:
        if user_valid:
            own_permission = ModelService.check_permission(userID=userID, permID=30)
            if own_permission:
                page = int(fieldDict['page'])
                line = int(fieldDict['line'])
                device_info_query_set = Device_Info.objects.all()
                device_info_count = device_info_query_set.count()
                device_info_res = device_info_query_set[(page - 1) * line:page * line]
                sqlDict = CommonService.query_set_to_dict(query_set=device_info_res)
                sqlDict['count'] = device_info_count
                return ResponseJSON(0, sqlDict)
            else:
                return ResponseJSON(604)
        else:
            return ResponseJSON(113)

def getKwargs(data={}):
    kwargs = {}
    for (k, v) in data.items():
        if v is not None and v != u'':
            kwargs[k+'__icontains'] = v
    return kwargs

def findEquipmentInfo(content,type,fieldDict):
    if type ==1:
        Device_Info_QuerySet=Device_Info.objects.all()
    if type==2:
        searchCondition=content
        kwargs = getKwargs(data=searchCondition)
        Device_Info_QuerySet=Device_Info.objects.filter(**kwargs)
    page = int(fieldDict['page'])
    line = int(fieldDict['line'])
    device_info_count = Device_Info_QuerySet.count()
    res = Device_Info_QuerySet[(page - 1) * line:page * line]
    send_dict = CommonService.query_set_to_dict(query_set=res)
    for k, v in enumerate(send_dict["datas"]):
        for val in res:
            if v['pk'] == val.id:
                username = ModelService.get_user_name(send_dict["datas"][k]['fields']['userID'])
                send_dict["datas"][k]['fields']['username'] = username
                primary = ModelService.get_user_name(send_dict["datas"][k]['fields']['primaryUserID'])
                send_dict["datas"][k]['fields']['primaryusername'] = primary
    send_dict['count'] = device_info_count
    return send_dict
@csrf_exempt
def queryUserEquipmentInterface(request, *callback_args,
                                **callback_kwargs):
    '''
    查询用户设备
    :param request:
    :param callback_args:
    :param callback_kwargs:
    :return:
    '''

    if request.method == 'POST':
        request.encoding = 'utf-8'
        token = request.POST.get('token', None)

        if token is not None:
            tM = JSONTokenManager()
            error_code = tM.verify_AToken(token)
            if error_code == 0:
                userID = tM.accessDict.get('userID', None)
                if userID:
                    response = HttpResponse(queryUserEquipment(userID))
                    return response
                else:
                    return ResponseJSON(310)
            else:
                response = HttpResponse(tM.errorCodeInfo(error_code))
                return response
        else:
            return ResponseJSON(800)

    elif request.method == 'GET':
        request.encoding = 'gb2312'
        token = request.GET.get('token', None)

        if token is not None:
            tM = JSONTokenManager()
            error_code = tM.verify_AToken(token)
            if error_code == 0:
                userID = tM.accessDict.get('userID', None)
                # userID = '151547899913020418607560093'

                if userID:
                    response = HttpResponse(queryUserEquipment(userID))
                    return response
                else:
                    return ResponseJSON(310)

            else:
                response = HttpResponse(tM.errorCodeInfo(error_code))
                return response
        else:
            return ResponseJSON(800)

    else:
        return ResponseJSON(801)

@csrf_exempt
def addNewUserEquipmentInterface(request, *callback_args,
                                 **callback_kwargs):
    if request.method == 'POST':
        request.encoding = 'utf-8'
        request_dict = request.POST
    elif request.method == 'GET':
        request.encoding = 'utf-8'
        request_dict = request.GET
    else:
        return ResponseJSON(801)
    token = request_dict.get('token', None)
    deviceContent = request_dict.get('content', None)
    if token is not None and deviceContent is not None:
        tM = JSONTokenManager()
        error_code = tM.verify_AToken(token)
        if error_code == 0:
            userID = tM.accessDict.get('userID', None)
            if userID:
                response = HttpResponse(addNewUserEquipment(userID, deviceContent))
                return response
            else:
                return ResponseJSON(310)
        else:
            response = HttpResponse(tM.errorCodeInfo(error_code))
            return response
    else:
        return ResponseJSON(800)


@csrf_exempt
def delUserEquipmentInterface(request, *callback_args,
                                 **callback_kwargs):
    '''
    删除用户设备
    :param request:
    :param callback_args: 表示任何多个无名参数，tuple类型
    :param callback_kwargs: 表示关键字参数，dict类型
    :return:
    '''
    if request.method == 'POST':
        request.encoding = 'utf-8'

        token = request.POST.get('token', None)
        id = request.POST.get('id', None)

        if token is not None and id is not None:
            tM = JSONTokenManager()
            error_code = tM.verify_AToken(token)
            if error_code == 0:
                userID = tM.accessDict.get('userID', None)
                if userID:
                    response = HttpResponse(delUserEquipment(userID, id))
                    return response
                else:
                    return ResponseJSON(310)
            else:
                response = HttpResponse(tM.errorCodeInfo(error_code))
                return response

        else:
            return ResponseJSON(800)

    elif request.method == 'GET':
        request.encoding = 'gb2312'
        token = request.GET.get('token', None)
        id = request.GET.get('id', None)

        if token is not None and id is not None:
            tM = JSONTokenManager()
            error_code = tM.verify_AToken(token)
            if error_code == 0:
                userID = tM.accessDict.get('userID', None)
                if userID:
                    response = HttpResponse(delUserEquipment(userID, id))
                    return response
                else:
                    return ResponseJSON(310)
            else:
                response = HttpResponse(tM.errorCodeInfo(error_code))
                return response
        else:
            return ResponseJSON(800)
    else:
        return ResponseJSON(801)

@csrf_exempt
def modifyUserEquipmentInterface(request, *callback_args,
                                 **callback_kwargs):
    '''
    修改用户设备
    :param request:
    :param callback_args:
    :param callback_kwargs:
    :return:
    '''
    if request.method == 'POST':
        request.encoding = 'utf-8'
        request_dict = request.POST
    elif request.method == 'GET':
        request.encoding = 'gb2312'
        request_dict = request.GET
    token = request_dict.get('token', None)
    deviceContent = request_dict.get('content', None)
    id = request_dict.get('id', None)
    if token is not None and deviceContent is not None and id is not None:
        tM = JSONTokenManager()
        error_code = tM.verify_AToken(token)
        if error_code == 0:
            userID = tM.accessDict.get('userID', None)
            if userID:
                response = HttpResponse(modifyUserEquipment(userID, deviceContent, id))
                return response
            else:
                return ResponseJSON(310)
        else:
            response = HttpResponse(tM.errorCodeInfo(error_code))
            return response
    else:
        return ResponseJSON(444)

@csrf_exempt
def showAllUserEquipmentInterface(request, *callback_args, **callback_kwargs):
    if request.method == 'POST':
        request.encoding = 'utf-8'
        fieldDict = request.POST
    if request.method == 'GET':
        request.encoding = 'utf-8'
        fieldDict = request.GET
    token = request.POST.get('token', None)
    type = request.POST.get('type', None)
    if token != None:
        tM = JSONTokenManager()
        error_code = tM.verify_AToken(token)
        if error_code == 0:
            userID = tM.accessDict.get('userID', None)
            if userID:
                if type == 'PC':
                    return showAllUserEquipmentPC(userID, fieldDict)
                else:
                    return showAllUserEquipment(userID)
            else:
                return ResponseJSON(310)
        else:
            return HttpResponse(tM.errorCodeInfo(error_code))

    else:
        return ResponseJSON(800)

@csrf_exempt
def findEquipmentInfoInterface(request, *callback_args, **callback_kwargs):
    if request.method == 'GET':
        request.encoding = 'gb2312'
        token = request.GET.get('token',None)
        fieldDict = request.GET
        deviceContent = request.GET.get('content',None)
    if request.method == 'POST':
        request.encoding = 'utf-8'
        token = request.POST.get('token', None)
        fieldDict = request.POST
        deviceContent = request.POST.get('content', None)

    if token != None:
        tM = JSONTokenManager()
        error_code = tM.verify_AToken(token)
        if error_code == 0:
            if deviceContent:
                deviceContent=json.loads(deviceContent)
                resultDict=findEquipmentInfo(content=deviceContent,type=2,fieldDict=fieldDict)
            else:
                resultDict=findEquipmentInfo(content='',type=1,fieldDict=fieldDict)
            return ResponseJSON(0,resultDict)
        else:
            return ResponseJSON(310)
    else:
        return ResponseJSON(800)