ASJServer/Controller/PermissionManager.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
from itertools import chain
from django.core import serializers
from django.views.generic.base import View
import django.dispatch, traceback
from django.views.decorators.csrf import csrf_exempt
from django.utils.decorators import method_decorator
from Service.TokenManager import JSONTokenManager
from Model.models import Permissions, Role, Device_User
from Service.CommonService import CommonService
from Service.ModelService import ModelService
from Service.ResponseService import *

# 创建信号
roles_done = django.dispatch.Signal(providing_args=[])
perms_done = django.dispatch.Signal(providing_args=[])
rmanger_done = django.dispatch.Signal(providing_args=[])

class Roles(object):
    '''
    role Manager Class
    '''
    try:
        rid = []
        rolename = []
        roles = Role.objects.all()
        for role in roles:
            rolename.append(role.roleName)
            rid.append(role.rid)
    except Exception as e:
        pass
    def __init__(self):
        '''
        信号监听, 注册信号
        Signal.connect(receiver, sender=None, weak=True, dispatch_uid=None)
        receiver: 信号接受者，回调函数
        sender: 信号发送者
        '''
        roles_done.connect(self.callback)

        self.startSignal()

    def callback(self, sender, **kwargs):
        '''
        开启监听之后，就要去实现回调函数了, 注册信号
        :param sender:
        :param kwargs:
        :return:
        '''
        Roles.rid = []
        Roles.rolename = []
        Roles.roles = Role.objects.all()

        for role in Roles.roles:
            Roles.rolename.append(role.roleName)
            Roles.rid.append(role.rid)

    def startSignal(self):
        '''
        触发信号
        指定信号发送者
        :return:
        '''
        roles_done.send(sender=self.__class__)

    def toJSON(self, QuerySets, fields=None, exclude=None):
        listSets = []
        for QuerySet in QuerySets:
            data = {}
            opts = QuerySet._meta
            for f in chain(opts.concrete_fields, opts.private_fields, opts.many_to_many):
                if not getattr(f, 'editable', False):
                    continue
                if fields and f.name not in fields:
                    continue
                if exclude and f.name in exclude:
                    continue
                data[f.name] = f.value_from_object(QuerySet)
            listSets.append(data)
        return listSets

    def queryAllRoles(self, rolenames=None, exclude=None):
        roles =[]
        for role in chain(Roles.roles):
            if rolenames and role.roleName not in rolenames:
                continue
            if exclude and role.roleName in exclude:
                continue
            roles.append(role)
        if len(roles) > 0:
            resultDict=CommonService.query_set_to_dict(roles)
            for k, v in enumerate(resultDict["datas"]):
                if len(v['fields']['permission']) > 0:
                    resultDict["datas"][k]['fields']['permissionJson']={}
                    for pid in v['fields']['permission']:
                        permission_query_set= Permissions.objects.get(id=pid)
                        resultDict["datas"][k]['fields']['permissionJson'][pid]=permission_query_set.permName
            return ResponseFormal(0,resultDict)
        
        else:
            return ResponseFormal(0, {})

    def addRoles(self, content=None):
        try:
            roleContent = json.loads(content)
        except Exception as e:
            return ResponseFormal(803,repr(e))
        else:
            rid = roleContent.get('rid', None)
            if rid == None:
                return ResponseFormal(806)
            try:
                if rid in chain(Roles.rid):
                    return ResponseFormal(807)

                permission_list = roleContent['permission']
                roleContent.pop('permission')
                role = Role(**roleContent)
                role.save()
                if len(permission_list) > 0:
                    role.permission.add(*permission_list)
            except Exception as e:
                return ResponseFormal(808,repr(e))
            else:
                self.startSignal()
                return ResponseFormal(0)

    def delRoles(self, rid=None, rolename=None):
        if rid != None:
            if rid not in Roles.rid:
                return ResponseFormal(190)

            try:
                roletuple = Role.objects.filter(rid = rid).delete()
            except Exception as e:
                return ResponseFormal(192, repr(e))
            else:
                if roletuple[0] == 1:
                    self.startSignal()
                    return self.queryAllRoles()
                else:
                    return ResponseFormal(193,{'error_msg':roletuple})
        elif rolename != None:
            if rid not in Roles.rolename:
                return ResponseFormal(191)
            try:
                roletuple = Role.objects.filter(roleName = rolename).delete()
            except Exception as e:
                return ResponseFormal(192)
            else:
                if roletuple[0] == 1:
                    self.startSignal()
                    return self.queryAllRoles()
                else:
                    return ResponseFormal(193)

    def modifyRoles(self, rid=None, content=None):
        if rid not in Roles.rid:
            return ResponseFormal(190)
        try:
            roleContent = json.loads(content)
        except Exception as e:
            errorInfo = traceback.format_exc()
            print('The content parameter format is wrong: %s' % errorInfo)
            return ResponseFormal(803)
        else:
            try:
                permission_list = roleContent['permission']
                roleContent.pop('permission')
                roleCount = Role.objects.filter(rid = rid).update(**roleContent)
                if roleCount:
                    if len(permission_list) > 0:
                        Role.objects.get(rid=rid).permission.set(permission_list)
                    else:
                        Role.objects.get(rid=rid).permission.clear()
            except Exception as e:
                return ResponseFormal(194)

            else:
                if roleCount == 1:
                    self.startSignal()
                    return self.queryAllRoles()
                else:
                    return ResponseFormal(195)

class Permission(object):
    try:
        id = []
        permname = []
        perms = Permissions.objects.all()
        for perm in perms:
            id.append(perm.id)
            permname.append(perm.permName)
    except Exception as e:
        pass
    def __init__(self):
        perms_done.connect(self.callback)

        self.startSignal()

    def callback(self, sender, **kwargs):
        Permission.id = []
        Permission.permname = []
        Permission.roles = Permissions.objects.all()

        for perm in Permission.roles:
            Permission.id.append(perm.id)
            Permission.permname.append(perm.permName)

    def startSignal(self):
        perms_done.send(sender=self.__class__)

    def queryAllPerms(self, perms=None, exclude=None):
        opts =[]
        for perm in chain(Permission.permname):
            if perms and perm not in perms:
                continue
            if exclude and perm in exclude:
                continue
            opts.append(perm)
        return ResponseFormal(0,{'perms':opts})

    def queryAllPermsInfo(self, perms=None, exclude=None):
        sqlJSON = serializers.serialize('json', Permissions.objects.all())
        sqlList = json.loads(sqlJSON)
        sqlDict = dict(zip(["datas"], [sqlList]))
        return ResponseFormal(0,sqlDict)

    def addPerms(self, content=None):
        try:
            permContent = json.loads(content)
        except Exception as e:
            return ResponseFormal(803, repr(e))
        else:
            permname = permContent.get('permName', None)
            if permname == None:
                return ResponseFormal(806)
            if permname in chain(Permission.permname):
                return ResponseFormal(815)
            try:
                perm = Permissions(**permContent)
                perm.save()
            except Exception as e:
                return ResponseFormal(816, repr(e))
            else:
                self.startSignal()
                sqlJSON = serializers.serialize('json', [perm])
                sqlList = json.loads(sqlJSON)
                sqlDict = dict(zip(["datas"], [sqlList]))
                return ResponseFormal(0,sqlDict)

    def delPerms(self, id=None, permName=None):
        try:
            if id != None:
                perm = Permissions.objects.filter(id = id)
            elif permName != None:
                perm = Permissions.objects.filter(permName = permName)
            else:
                return ResponseFormal(800)
        except Exception as e:
            return ResponseFormal(500, repr(e))
        else:
            if not perm:
                return ResponseFormal(817)
            try:
                perm.delete()
            except Exception as e:
                return ResponseFormal(818, repr(e))
            else:
                self.startSignal()
                sqlJSON = serializers.serialize('json', Permissions.objects.all())
                sqlList = json.loads(sqlJSON)
                sqlDict = dict(zip(["datas"], [sqlList]))
                return ResponseFormal(0,sqlDict)

    def modifyPerm(self, id=None, content=None):
        if id not in Permission.id:
            return ResponseFormal(817)
        try:
            permContent = json.loads(content)
        except Exception as e:
            return ResponseFormal(803, repr(e))
        else:
            try:
                perm = Permissions.objects.filter(id = id).update(**permContent)
            except Exception as e:
                return ResponseFormal(819, repr(e))
            else:
                self.startSignal()

                sqlJSON = serializers.serialize('json', Permissions.objects.filter(id = id))
                sqlList = json.loads(sqlJSON)
                sqlDict = dict(zip(["datas"], [sqlList]))
                return ResponseFormal(0,sqlDict)

    @staticmethod
    def getAllPermission():
        send_dict=CommonService.query_set_to_dict(Permissions.objects.all())
        return ResponseFormal(0, send_dict)


class rolesManager(object):

    def assign(self, userID=None, rid=None):
        dUser = Device_User.objects.filter(userID = userID)
        if not dUser:
            return ResponseFormal(113)

        role = Role.objects.filter(rid = rid)
        if not role:
            return ResponseFormal(190)
        rids = dUser[0].get_role_id()
        if rid in rids:
            return ResponseFormal(196)
        try:
            dUser[0].role.add(role[0])
        except Exception as e:
            return ResponseFormal(196, repr(e))
        else:
            rids = dUser[0].get_role_id()
            return ResponseFormal(0,{'rid':rids})

    def remove(self, userID=None, rid=None):
        dUser = Device_User.objects.filter(userID = userID)
        if not dUser:
            return ResponseFormal(113)
        rids = dUser[0].get_role_id()
        if rid not in rids:
            return ResponseFormal(198)
        try:
            dUser[0].role.remove(rid)
        except Exception as e:
            return ResponseFormal(199, repr(e))
        else:
            rids = dUser[0].get_role_id()
            if len(rids) == 0:
                urole = Role.objects.filter(roleName = 'Users')
                dUser[0].role.add(urole[0])
                rids = dUser[0].get_role_id()
            return ResponseFormal(0,{'rid':rids})
    def query(self, userID=None):
        dUser = Device_User.objects.filter(userID = userID)
        if not dUser:
            return ResponseFormal(113)
        sqlJSON = serializers.serialize('json', Role.objects.filter(device_user = userID))
        sqlList = json.loads(sqlJSON)
        sqlDict = dict(zip(["datas"], [sqlList]))
        return ResponseFormal(0, sqlDict)

    def queryAll(self):
        sqlJSON = serializers.serialize('json', Role.objects.all())
        sqlList = json.loads(sqlJSON)
        sqlDict = dict(zip(["datas"], [sqlList]))
        return ResponseFormal(0, sqlDict)

class permManager(object):

    def queryUser(self, userID=None):
        dUser = Device_User.objects.filter(userID = userID)
        if not dUser:
            return ResponseFormal(190)
        sqlDict = dict(zip(['datas'], [dUser[0].get_all_permission()]))
        return ResponseFormal(0, sqlDict)

    def queryAllUser(self):
        sqlJSON = serializers.serialize('json', Device_User.objects.all())
        sqlList = json.loads(sqlJSON)
        sqlDict = dict(zip(['datas'], [sqlList]))
        return ResponseFormal(0, sqlDict)

    def queryRole(self, rid=None):
        role = Role.objects.filter(rid = rid)
        if not role:
            return ResponseFormal(190)
        sqlDict = dict(zip(["datas"], [role[0].get_all_permission()]))
        return ResponseFormal(0, sqlDict)

    def queryMoreRole(self, rid=None):
        role = Role.objects.filter(rid = rid)
        if not role:
            roleDict = {'rid': role[0].rid, 'error_msg': u'The rid does not exist!'}
            return roleDict
        roleDict = {'rid' : role[0].rid, 'perms': role[0].get_all_permission()}
        return roleDict

    def queryAllRole(self):
        sqlJSON = serializers.serialize('json', Role.objects.all())
        sqlList = json.loads(sqlJSON)
        sqlDict = dict(zip(["datas"], [sqlList]))
        return ResponseFormal(0, sqlDict)

    def assignUser(self, userID=None, perms=None):
        pids = []
        error_perms = []
        existence_perms = []
        dUser = Device_User.objects.filter(userID=userID)
        if not dUser:
            return ResponseFormal(113)
        for perm in perms:
            if perm in Permission.id:
                print('in', perm)
                continue
            else:
                print('not in', perm)
                error_perms.append(perm)
                perms.remove(perm)
                continue
        permsID = dUser[0].get_all_perms_id()
        for perm in perms:
            if perm not in permsID:
                pids.append(perm)
            else:
                existence_perms.append(perm)

        if len(pids) == 0:
            if len(error_perms) > 0:
                return ResponseFormal(201,{'error_perms': error_perms})
            elif len(existence_perms) > 0:
                return ResponseFormal(206,{'existence_perms': existence_perms})
        try:
            for pid in pids:
                dUser[0].permission.add(pid)
        except Exception as e:
            return ResponseFormal(200, repr(e))
        else:
            if len(error_perms) > 0:
                if len(existence_perms) > 0:
                    return ResponseFormal(0,{'error_msg': 'Some of the permissions you provide have already existed,and some of the permissions do not exist!','error_perms': error_perms,'existence_perms': existence_perms,'perms': dUser[0].get_all_permission()})
                else:
                    return ResponseFormal(0, {'error_msg': 'Some of the permissions you have provided do not exist!','error_perms':error_perms,'perms':dUser[0].get_all_permission()})
            else:
                if len(existence_perms) > 0:
                    return ResponseFormal(0, {'error_msg': 'Some of the permissions you have provided do not exist!','error_perms':error_perms,'perms':dUser[0].get_all_permission()})
                else:
                    return ResponseFormal(0, {'perms': dUser[0].get_all_permission()})

    def assignRole(self, rid=None, perms=None):
        pids = []
        error_perms = []
        existence_perms = []
        role = Role.objects.filter(rid = rid)
        if not role:
            return ResponseFormal(190)
        for perm in perms:
            if perm in Permission.id:
                continue
            else:
                error_perms.append(perm)
                perms.remove(perm)
                continue

        permsID = role[0].get_all_perms_id()
        for perm in perms:
            if perm not in permsID:
                pids.append(perm)
            else:
                existence_perms.append(perm)

        if len(pids) == 0:
            if len(error_perms) > 0:
                return ResponseFormal(201,{'error_perms': error_perms})
            elif len(existence_perms) > 0:
                return ResponseFormal(206,{'error_perms': existence_perms})
        try:
            for pid in pids:
                role[0].permission.add(pid)
        except Exception as e:
            return ResponseFormal(200, repr(e))
        else:
            if len(error_perms) > 0:
                return ResponseFormal(0, {'error_msg': 'Some of the permissions you have provided do not exist!','error_perms': error_perms,'perms': role[0].get_all_permission(),})
            else:
                if len(existence_perms) > 0:
                    return ResponseFormal(206, {
                        'error_msg': 'Some of the permissions you have provided do not exist!',
                        'error_perms': existence_perms, 'perms': role[0].get_all_permission(), })
                else:
                    return ResponseFormal(0, {'perms': role[0].get_all_permission()})

    def removeUser(self, userID=None, perms=None):
        '''
        删除用户权限
        :param userID: 要删除的用户的用户ID
        :param perms:  []，权限列表
        :return: 成功或者错误
        '''
        dUser = Device_User.objects.filter(userID=userID)
        if not dUser:
            return ResponseFormal(113)
        error_perms = []
        for perm in perms:
            if perm in Permission.id:
                continue
            else:
                error_perms.append(perm)
                perms.remove(perm)
                continue

        try:
            # user.user_permissions.remove(permission, permission, ...)  删除权限
            for perm in perms:
                dUser[0].permission.remove(perm)
        except Exception as e:
            return ResponseFormal(202,repr(e))
        else:
            if len(error_perms) > 0:
                return ResponseFormal(201, {
                            'error_msg': 'Some of the permissions you have provided do not exist!',
                            'error_perms': error_perms,
                            'perms': dUser[0].get_all_permission(),
                        })
            else:
                return ResponseFormal(201, {'perms': dUser[0].get_all_permission()})

    def removeRole(self, rid=None, perms=None):
        role = Role.objects.filter(rid = rid)
        if not role:
            return ResponseFormal(190)
        error_perms = []
        for perm in perms:
            if perm in Permission.id:
                continue
            else:
                error_perms.append(perm)
                perms.remove(perm)
                continue

        try:
            # group.permissions.remove(permission, permission, ...)
            for perm in perms:
                role[0].permission.remove(perm)
        except Exception as e:
            return ResponseFormal(203,repr(e))
        else:
            if len(error_perms) > 0:
                return ResponseFormal(201, {
                            'error_msg': 'Some of the permissions you have provided do not exist!',
                            'error_perms': error_perms,
                            'perms': role[0].get_all_permission(),
                        })
            else:
                return ResponseFormal(201, {'perms': role[0].get_all_permission()})

    def clearUser(self, userID=None):
        dUser = Device_User.objects.filter(userID=userID)
        if not dUser:
            return ResponseFormal(113)
        try:
            # user.user_permissions.clear()  清空权限
            dUser[0].permission.clear()
        except Exception as e:
            return ResponseFormal(204,repr(e))
        else:
            return ResponseFormal(0,{'perms': dUser[0].get_all_permission()})

    def clearRole(self, rid=None):
        role = Role.objects.filter(rid = rid)
        if not role:
            return ResponseFormal(190)
        try:
            role[0].permission.clear()
        except Exception as e:
            return ResponseFormal(205,repr(e))
        else:
            return ResponseFormal(0,{'perms': role[0].get_all_permission()})

# 角色View
class queryRoleView(View):
    @method_decorator(csrf_exempt)
    def dispatch(self, *args, **kwargs):
        return super(queryRoleView, self).dispatch(*args, **kwargs)

    def get(self, request, *args, **kwargs):
        request.encoding = 'gb2312'
        token = request.GET.get('token', None)
        return self.ValidationError(token)

    def post(self, request, *args, **kwargs):
        request.encoding = 'utf-8'
        token = request.POST.get('token', None)
        return self.ValidationError(token)

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

    def queryUserRole(self, userID):
        eUser = Device_User.objects.filter(userID = userID)
        if not eUser:
            return ResponseFormal(102)

        if 100 in eUser[0].get_role_id():
            role = Roles()
            return role.queryAllRoles()
        own_permission = ModelService.check_permission(userID=userID, permID=30)
        if own_permission is True:
            role = Roles()
            return role.queryAllRoles()
        else:
            return ResponseFormal(603)

class addNewRoleView(View):
    @method_decorator(csrf_exempt)
    def dispatch(self, *args, **kwargs):
        return super(addNewRoleView, self).dispatch(*args, **kwargs)

    def get(self, request, *args, **kwargs):
        request.encoding = 'gb2312'
        token = request.GET.get('token', None)
        content = request.GET.get('content', None)

        return self.ValidationError(token, content)

    def post(self, request, *args, **kwargs):
        request.encoding = 'utf-8'
        token = request.POST.get('token', None)
        content = request.POST.get('content', None)

        return self.ValidationError(token, content)

    def ValidationError(self, token, content):
        if token != None and content != None:
            tM = JSONTokenManager()
            error_code = tM.verify_AToken(token)
            if error_code == 0:
                userID = tM.accessDict.get('userID', None)
                if userID:
                    response = HttpResponse(self.AddNewUserRole(userID, content))
                    return response
                else:
                    return ResponseJSON(310)
            else:
                response = HttpResponse(tM.errorCodeInfo(error_code))
                return response

        else:
            return ResponseJSON(800)

    def AddNewUserRole(self, userID, content):
        try:
            User = Device_User.objects.filter(userID = userID)
        except Exception as e:
            return ResponseFormal(500,repr(e))
        else:
            rids = User[0].get_role_id()
            if rids == None:
                return ResponseFormal(606)
            Aperms = False
            for rid in rids:
                if rid < 10:
                    continue
                else:
                    Aperms = True

            if Aperms:
                role = Roles()
                return role.addRoles(content)
            else:
                return ResponseFormal(607)


class delRoleView(View):
    @method_decorator(csrf_exempt)
    def dispatch(self, *args, **kwargs):
        return super(delRoleView, self).dispatch(*args, **kwargs)

    def get(self, request, *args, **kwargs):
        request.encoding = 'gb2312'
        token = request.GET.get('token', None)
        rid = request.GET.get('rid', None)

        return self.ValidationError(token, rid)

    def post(self, request, *args, **kwargs):
        request.encoding = 'utf-8'
        token = request.POST.get('token', None)
        rid = request.POST.get('rid', None)

        return self.ValidationError(token, rid)

    def ValidationError(self, token, rid):
        if token != None and rid != None:
            tM = JSONTokenManager()
            error_code = tM.verify_AToken(token)
            if error_code == 0:
                userID = tM.accessDict.get('userID', None)
                if userID:
                    response = HttpResponse(self.delRole(userID, int(rid)))
                    return response
                else:
                    return ResponseJSON(310)
            else:
                response = HttpResponse(tM.errorCodeInfo(error_code))
                return response

    def delRole(self, userID, rid):
        own_permission = ModelService.check_permission(userID=userID, permID=10)
        if own_permission is True:
            role = Roles()
            return role.delRoles(rid)
        else:
            return ResponseJSON(404)

class modifyRoleView(View):
    @method_decorator(csrf_exempt)
    def dispatch(self, *args, **kwargs):
        return super(modifyRoleView, self).dispatch(*args, **kwargs)

    def get(self, request, *args, **kwargs):
        request.encoding = 'gb2312'
        token = request.GET.get('token', None)
        rid =  request.GET.get('rid', None)
        content = request.GET.get('content', None)
        return self.ValidationError(token, rid, content)

    def post(self, request, *args, **kwargs):
        request.encoding = 'utf-8'
        token = request.POST.get('token', None)
        rid = request.POST.get('rid', None)
        content = request.POST.get('content', None)
        return self.ValidationError(token, rid, content)

    def ValidationError(self, token, rid, content):
        if token != None and content != None and rid != None:
            tM = JSONTokenManager()
            error_code = tM.verify_AToken(token)
            if error_code == 0:
                userID = tM.accessDict.get('userID', None)
                if userID:
                    response = HttpResponse(self.modifyRole(userID, int(rid), content))
                    return response
                else:
                    return ResponseJSON(310)
            else:
                response = HttpResponse(tM.errorCodeInfo(error_code))
                return response

        else:
            return ResponseJSON(800)

    def modifyRole(self, userID, rid, content):
        try:
            User = Device_User.objects.filter(userID = userID)
        except Exception as e:
            return ResponseFormal(500, repr(e))
        else:
            rids = User[0].get_role_id()
            if rids == None:
                return ResponseFormal(606)
            Aperms = False
            for rrid in rids:
                if rrid < 10:
                    continue
                else:
                    Aperms = True
            if Aperms:
                role = Roles()
                return role.modifyRoles(rid, content)
            else:
                return ResponseFormal(607)


# 权限View
class addNewPermsView(View):
    @method_decorator(csrf_exempt)
    def dispatch(self, *args, **kwargs):
        return super(addNewPermsView, self).dispatch(*args, **kwargs)

    def get(self, request, *args, **kwargs):
        request.encoding = 'utf-8'
        request_dict = request.GET
        return self.ValidationError(request_dict)

    def post(self, request, *args, **kwargs):
        request.encoding = 'utf-8'
        request_dict = request.POST
        return self.ValidationError(request_dict)

    def ValidationError(self, request_dict):
        token = request_dict.get('token', None)
        type = request_dict.get('type', None)
        if token != None:
            tM = JSONTokenManager()
            error_code = tM.verify_AToken(token)
            if error_code == 0:
                userID = tM.accessDict.get('userID', None)
                if userID:
                    if type == 'PC':
                        return HttpResponse(self.addNewPermission(userID=userID, request_dict=request_dict))
                else:
                    return ResponseJSON(310)
            else:
                return HttpResponse(tM.errorCodeInfo(error_code))
        else:
            return ResponseJSON(800)

    def addNewPermission(self, userID, request_dict):
        user_valid = Device_User.objects.filter(userID=userID).order_by('-data_joined')
        if user_valid:# 判断是否为超级管理员
            ModelService.check_permission(userID,40)
            if user_valid[0].is_superuser == 100 and user_valid[0].is_superuser != 1 and user_valid[0].is_superuser != 10:
                return ResponseFormal(600)
            else:
                add_dict = {'id':int(request_dict['id']),'permName':request_dict['permName'],'description':request_dict['description']}
                try:
                    perm = Permissions(**add_dict)
                    perm.save()
                except Exception as e:
                    return ResponseFormal(816,repr(e))
                else:
                    return Permission.getAllPermission()
        else:
            return ResponseFormal(113)

class delPermsView(View):
    @method_decorator(csrf_exempt)
    def dispatch(self, *args, **kwargs):
        return super(delPermsView, self).dispatch(*args, **kwargs)

    def get(self, request, *args, **kwargs):
        request.encoding = 'utf-8'
        request_dict = request.GET
        return self.ValidationError(request_dict)

    def post(self, request, *args, **kwargs):
        request.encoding = 'utf-8'
        request_dict = request.POST
        return self.ValidationError(request_dict)

    def ValidationError(self, request_dict):
        token = request_dict.get('token', None)
        id = request_dict.get('id', None)
        if token != None and id != None:
            tM = JSONTokenManager()
            error_code = tM.verify_AToken(token)
            if error_code == 0:
                userID = tM.accessDict.get('userID', None)
                if userID:
                    response = HttpResponse(self.delPerms(userID, id))
                    return response
                else:
                    return ResponseJSON(310)
            else:
                response = HttpResponse(tM.errorCodeInfo(error_code))
                return response

        else:
            return ResponseJSON(800)

    def delPerms(self, userID, id):
        try:
            User = Device_User.objects.filter(userID = userID)
        except Exception as e:
            return ResponseFormal(500, repr(e))

        else:
            rids = User[0].get_role_id()
            if len(rids) == 0:
                return ResponseFormal(606)
            Aperms = False
            for rid in rids:
                if rid < 10:
                    continue
                else:
                    Aperms = True
            if Aperms:
                perms = Permission()
                return perms.delPerms(id)
            else:
                return ResponseFormal(611)

class queryPermsView(View):
    @method_decorator(csrf_exempt)
    def dispatch(self, *args, **kwargs):
        return super(queryPermsView, self).dispatch(*args, **kwargs)

    def get(self, request, *args, **kwargs):
        request.encoding = 'gb2312'
        token = request.GET.get('token', None)
        request_data = request.GET
        return self.ValidationError(token,request_data)

    def post(self, request, *args, **kwargs):
        request.encoding = 'utf-8'
        token = request.POST.get('token', None)
        request_data = request.POST
        return self.ValidationError(token,request_data)

    def ValidationError(self, token, request_data):
        if token != None:
            tM = JSONTokenManager()
            error_code = tM.verify_AToken(token)
            if error_code == 0:
                userID = tM.accessDict.get('userID', None)
                # userID = '151547867345163613800138001'
                if userID:
                    type = request_data.get('type',None)
                    if type == 'PC':
                        response = HttpResponse(self.querAllPermission(userID))
                    else:
                        response = HttpResponse(self.delPerms(userID))
                    return response
                else:
                    return ResponseJSON(310)
            else:
                response = HttpResponse(tM.errorCodeInfo(error_code))
                return response

        else:
            return ResponseJSON(800)

    def querAllPermission(self, userID):
        permission_query_set=Permissions.objects.all()
        result_dict = CommonService.query_set_to_dict(permission_query_set)
        return ResponseJSON(0,result_dict)

    def delPerms(self, userID):
        try:
            User = Device_User.objects.filter(userID = userID)
        except Exception as e:
            return ResponseFormal(500, repr(e))
        else:
            rids = User[0].get_role_id()
            if len(rids) == 0:
                return ResponseFormal(606)

            Aperms = False
            for rid in rids:
                if rid < 10:
                    continue
                else:
                    Aperms = True

            if Aperms:
                perms = Permission()
                return perms.queryAllPerms()
            else:
                return ResponseFormal(611)

class modifyPermsView(View):
    @method_decorator(csrf_exempt)
    def dispatch(self, *args, **kwargs):
        return super(modifyPermsView, self).dispatch(*args, **kwargs)

    def get(self, request, *args, **kwargs):
        request.encoding = 'gb2312'
        request_dict = request.GET
        return self.ValidationError(request_dict)

    def post(self, request, *args, **kwargs):
        request.encoding = 'utf-8'
        # token = request.POST.get('token', None)
        request_dict = request.POST
        return self.ValidationError(request_dict)

    def ValidationError(self, request_dict):
        token = request_dict.get('token', None)
        if token != None:
            tM = JSONTokenManager()
            error_code = tM.verify_AToken(token)
            if error_code == 0:
                userID = tM.accessDict.get('userID', None)
                if userID:
                    update_dict = {'permName':request_dict['permName'],'description':request_dict['description']}
                    response = HttpResponse(self.modifyPerms(userID=userID,id=request_dict['id'], update_dict=update_dict))
                    return response
                else:
                    return ResponseJSON(310)
            else:
                response = HttpResponse(tM.errorCodeInfo(error_code))
                return response
        else:
            return ResponseJSON(800)

    def modifyPerms(self, userID, id, update_dict):
        try:
            User = Device_User.objects.filter(userID = userID)
        except Exception as e:
            return ResponseFormal(500, repr(e))
        else:
            rids = User[0].get_role_id()
            if len(rids) == 0:
                return ResponseFormal(606)
            Aperms = False
            for rid in rids:
                if rid < 10:
                    continue
                else:
                    Aperms = True

            if Aperms:
                try:
                    Permissions.objects.filter(id = int(id)).update(**update_dict)
                except Exception as e:
                    return ResponseFormal(500,repr(e))
                else:
                    return Permission.getAllPermission()
            else:
                return ResponseFormal(611)

class queryRolePermsView(View):
    @method_decorator(csrf_exempt)
    def dispatch(self, *args, **kwargs):
        return super(queryRolePermsView, self).dispatch(*args, **kwargs)

    def get(self, request, *args, **kwargs):
        request.encoding = 'gb2312'

        token = request.GET.get('token', None)
        allUser = request.GET.get('allUser', False)

        return self.ValidationError(token, allUser)

    def post(self, request, *args, **kwargs):
        request.encoding = 'utf-8'

        token = request.POST.get('token', None)
        allUser = request.POST.get('allUser', False)

        return self.ValidationError(token, allUser)

    def ValidationError(self, token, allUser):
        if token != None:
            tM = JSONTokenManager()
            error_code = tM.verify_AToken(token)
            if error_code == 0:
                userID = tM.accessDict.get('userID', None)
                if userID:
                    response = HttpResponse(self.queryRolePerms(userID, allUser))
                    return response
                else:
                    return ResponseJSON(310)
            else:
                response = HttpResponse(tM.errorCodeInfo(error_code))
                return response
        else:
            return ResponseJSON(800)

    def queryRolePerms(self, userID, allUser):
        try:
            dUser = Device_User.objects.filter(userID=userID).order_by('-data_joined')
        except Exception as e:
            return ResponseFormal(500, repr(e))
        else:
            if not dUser:
                return ResponseFormal(113)
            if allUser == '0' or allUser == 'False' or allUser == 'false':
                allUser = False
            elif allUser == '1' or allUser == 'True' or allUser == 'true':
                allUser = True
            else:
                allUser = False
            pM = permManager()
            if not allUser:
                ridslist =[]
                rids = dUser[0].get_role_id()

                for rid in rids:
                    ridslist.append(pM.queryMoreRole(rid))
                sqlDict = dict(zip(["datas"], [ridslist]))
                return ResponseFormal(0,sqlDict)
            else:
                if 100 in dUser[0].get_role_id():
                    return pM.queryAllRole()
                else:
                    return ResponseFormal(612)