ASJServer/Controller/shareUserPermission.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
from django.core import serializers
import traceback, simplejson as json
from django.shortcuts import HttpResponse
from django.views.generic.base import View
from django.core.exceptions import FieldError
from django.views.decorators.csrf import csrf_exempt
from django.utils.decorators import method_decorator
from Service.TokenManager import JSONTokenManager
from Model.models import Device_User, Device_Info, Role
from Service.CommonService import CommonService
from Service.ResponseService import *



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

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

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

    def searchUserSQL(self, fieldDict, *args, **kwargs):
        exact = fieldDict.get('exact', True)
        if exact == '0' or exact == 'False':
            exact = False
        else:
            exact = True

        if 'exact' in fieldDict.keys():
            fieldDict.pop('exact')

        try:
            if  exact == 'True' or exact == 1:
                User = Device_User.objects.filter(**fieldDict).order_by('-data_joined')
            elif exact == 'False' or exact == 0:
                if 'username' in fieldDict.keys():
                    User = Device_User.objects.filter(username = fieldDict.get('username',
                                                                                           None)).order_by('-data_joined')
                elif 'userEmail' in fieldDict.keys():
                    User = Device_User.objects.filter(userEmail = fieldDict.get('userEmail',
                                                                                           None)).order_by('-data_joined')
                elif 'userID' in fieldDict.keys():
                    User = Device_User.objects.filter(userID = fieldDict.get('userID',
                                                                                           None)).order_by('-data_joined')
                else:
                    User = Device_User.objects.filter(**fieldDict).order_by('-data_joined')
            else:
                User = Device_User.objects.filter(**fieldDict).order_by('-data_joined')

        except FieldError:
            return ResponseFormal(502)
        except Exception as e:
            errorInfo = traceback.format_exc()
            print('查询数据库错误: %s' % errorInfo)
            return ResponseFormal(500,{'details':repr(e)})
        else:
            if User:
                ddUser = User[0].device_info_set.all()
                sqlJSON = serializers.serialize('json', User)
                sqlList = json.loads(sqlJSON)
                if ddUser:
                    sqlJSON1 = serializers.serialize('json', ddUser)
                    sqlList1 = json.loads(sqlJSON1)
                    device_Info_dict={}
                    device_Info_list=[]
                    for eachJson1 in sqlList1:
                        device_Info_dict['primaryUserID']=eachJson1['fields']['primaryUserID']
                        device_Info_dict['Type']=eachJson1['fields']['Type']
                        device_Info_dict['UID']=eachJson1['fields']['UID']
                        device_Info_dict['pk']=eachJson1['pk']
                        device_Info_dict['NickName']=eachJson1['fields']['NickName']
                        device_Info_dict['View_Password']=eachJson1['fields']['View_Password']
                        device_Info_dict['View_Account']=eachJson1['fields']['View_Account']
                        device_Info_dict['Online']=eachJson1['fields']['Online']
                        device_Info_dict['EventNotification']=eachJson1['fields']['EventNotification']
                        device_Info_dict['ChannelIndex']=eachJson1['fields']['ChannelIndex']
                        device_Info_dict['EventNotification']=eachJson1['fields']['EventNotification']
                        device_Info_dict['NotificationMode']=eachJson1['fields']['NotificationMode']

                        device_Info_list.append(device_Info_dict)
                        device_Info_dict={}
                    sqlList[0]['device_info'] = device_Info_list
                sqlDict = dict(zip(["datas"], [sqlList]))
                return ResponseFormal(0, sqlDict)
            else:
                # 发送邮件
                # sms()
                return ResponseFormal(102)
    def searchUserPCSQL(self, fieldDict):
        try:
            page = int(fieldDict['page'])
            line = int(fieldDict['line'])
            fieldDict.pop('page')
            fieldDict.pop('line')
            fieldDict.pop('type')
            if len(fieldDict) > 0:
                searchCondition=CommonService.get_kwargs(data=fieldDict)
                device_user_queryset = Device_User.objects.filter(**searchCondition).order_by('-data_joined')
            else:
                device_user_queryset = Device_User.objects.all().order_by('-data_joined')
        except FieldError:
            return ResponseFormal(502)
        except Exception as e:
            errorInfo = traceback.format_exc()
            print('查询数据库错误: %s' % errorInfo)
            return ResponseFormal(500, {"details": repr(e)})
        else:
            if device_user_queryset:
                device_user_count = device_user_queryset.count()
                device_user_res=device_user_queryset[(page-1)*line:page*line]
                sqlDict = CommonService.query_set_to_dict(device_user_res)
                for k, v in enumerate(sqlDict["datas"]):
                    for val in device_user_res:
                        if v['pk']==val.userID:
                            device_info_query_set=val.device_info_set.all()
                            device_info_list = CommonService.query_set_to_dict(device_info_query_set)
                            # device_user关联到device_info
                            sqlDict["datas"][k]['device_info']=device_info_list
                    if len(v['fields']['role'])>0:
                        role_query_set=Role.objects.get(rid=v['fields']['role'][0])
                        sqlDict["datas"][k]['fields']['role'].append(role_query_set.roleName)
                sqlDict['count'] = device_user_count
                return ResponseFormal(0,sqlDict)
            else:
                return ResponseFormal(0,{"datas":""})
    def searchUser(self, fieldDict, *args, **kwargs):
        if fieldDict != None:
            token = fieldDict.get('token', None)
            if token != None:
                tokenManager = JSONTokenManager()
                error_code = tokenManager.verify_AToken(token)
                if error_code == 0:
                    fieldDict = fieldDict.dict()
                    fieldDict.pop('token')
                    type = fieldDict.get('type',None)
                    if type == 'PC':
                        response = HttpResponse(self.searchUserPCSQL(fieldDict))
                    else:
                        response = HttpResponse(self.searchUserSQL(fieldDict, args, kwargs))
                    return response
                else:
                    response = HttpResponse(tokenManager.errorCodeInfo(error_code))
                    return response
            else:
                return ResponseJSON(444)
        else:
            return ResponseJSON(444)

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

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

        queryDict = request.POST
        return self.shareUser(queryDict, args, kwargs)

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

        queryDict = request.GET
        return self.shareUser(queryDict, args, kwargs)

    def shareUser(self, queryDict, *args, **kwargs):
        token = queryDict.get('token', None)
        GuestID = queryDict.get('guestID', None)
        content = queryDict.get('content', None)
        sharedAll = queryDict.get('sharedAll', False)

        if sharedAll in ('1', '0'):
            sharedAll = bool(int(sharedAll))
        elif sharedAll in ('true', 'false'):
            if sharedAll == 'true':
                sharedAll = 1
            else:
                sharedAll = 0

        if token != None and GuestID != None:
            tokenManager = JSONTokenManager()
            error_code = tokenManager.verify_AToken(token)
            if error_code == 0:
                MasterID = tokenManager.accessDict.get('userID', None)
                if sharedAll and MasterID != None:
                    response = HttpResponse(self.shareUserSQL(MasterID, GuestID, True, args, kwargs))
                    return response
                if content != None and MasterID != None:
                    response = HttpResponse(self.shareUserSQL(MasterID, GuestID, False, args, content=content))
                    return response
                else:
                    return ResponseJSON(804)
            else:
                response = HttpResponse(tokenManager.errorCodeInfo(error_code))
                return response
        else:
            return ResponseJSON(800)

    def shareUserSQL(self, MasterID, GuestID, sharedAll, *args, **kwargs):
        try:
            Guest = Device_User.objects.filter(userID = GuestID).order_by('-data_joined')
            Master = Device_Info.objects.filter(userID_id = MasterID).order_by('-data_joined')
        except Exception as e:
            errorInfo = traceback.format_exc()
            print('查询数据库错误: %s' % errorInfo)
            return ResponseFormal(500, {"details": repr(e)})
        else:
            if Master:
                if Guest:
                    querysetList = []
                    dictLen = 0

                    if sharedAll:
                        for equipment in Master:
                            eqDict = equipment.model_to_dict(exclude=['id', 'data_joined', 'primaryUserID'])

                            shareEquipment = Device_Info.objects.filter(userID_id=GuestID, primaryUserID= \
                                MasterID, UID=eqDict.get('UID', None)).order_by('-data_joined')

                            if shareEquipment:
                                dictLen += 1
                                continue
                            else:
                                eqDict['primaryUserID'] = eqDict.pop('userID')
                                eqDict['isShare'] = True
                                eqDict['userID_id'] = GuestID
                                eqDict['id'] = CommonService.getUserID(getUser=False)
                                querysetList.append(Device_Info(**eqDict))
                    else:
                        content = kwargs.get('content', None)
                        if content != None:
                            contentDict = json.loads(content)
                            uidlist = UID = contentDict.get('UID', None)
                            print(uidlist)
                            for equipment in Master:
                                eqDict = equipment.model_to_dict(exclude=['id', 'data_joined', 'primaryUserID'])

                                if eqDict['UID'] in uidlist:
                                    UID.remove(eqDict['UID'])
                                    shareEquipment = Device_Info.objects.filter(userID_id=GuestID, primaryUserID= \
                                        MasterID, UID=eqDict.get('UID', None)).order_by('-data_joined')
                                    if shareEquipment:
                                        dictLen += 1
                                    else:
                                        eqDict['primaryUserID'] = eqDict.pop('userID')
                                        eqDict['isShare'] = True
                                        eqDict['userID_id'] = GuestID
                                        eqDict['id'] = CommonService.getUserID(getUser=False)
                                        querysetList.append(Device_Info(**eqDict))
                                else:
                                    continue

                    if len(querysetList) == 0:
                        if sharedAll:
                            return ResponseFormal(160)
                        else:
                            if len(UID) > 0:
                                return ResponseFormal(160,{'error_UID': UID})
                            else:
                                return ResponseFormal(160)
                    else:
                        try:
                            equipmentCount = Device_Info.objects.bulk_create(querysetList)
                        except Exception as e:
                            errorInfo = traceback.format_exc()
                            print('添加数据库记录错误: %s' % errorInfo)
                            return ResponseFormal(500, {"details": repr(e)})
                        else:
                            if dictLen > 0:
                                return ResponseFormal(0, {
                                            'Shared': dictLen,
                                            'Sharing': len(querysetList),
                                            'errormsg': u'A part of the equipment has been shared!',
                                        })
                            else:
                                if sharedAll:
                                    return ResponseFormal(0, {
                                        'Sharing': len(querysetList)
                                    })
                                else:
                                    if len(UID) > 0:
                                        return ResponseFormal(0, {
                                            'error_UID': UID,
                                            'Sharing': len(querysetList),
                                        })
                                    else:
                                        return ResponseFormal(0, {
                                            'Sharing': len(querysetList),
                                        })
                else:
                    return ResponseFormal(113)

            else:
                return ResponseFormal(172)

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

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

        queryset = request.POST
        return self.unsharedUserEquipment(queryset, args, kwargs)

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

        queryset = request.GET
        return self.unsharedUserEquipment(queryset, args, kwargs)

    def unsharedUserEquipment(self, queryset, *args, **kwargs):
        token = queryset.get('token', None)
        GuestID = queryset.get('guestID', None)
        content = queryset.get('content', None)
        unsharedAll = queryset.get('unsharedAll', False)

        if unsharedAll in ('1', '0'):
            unsharedAll = bool(int(unsharedAll))
        elif unsharedAll in ('true', 'false'):
            if unsharedAll == 'true':
                unsharedAll = 1
            else:
                unsharedAll = 0

        if token != None and GuestID != None and len(GuestID) > 0:
            tokenManager = JSONTokenManager()
            error_code = tokenManager.verify_AToken(token)
            if error_code == 0:
                MasterID = tokenManager.accessDict.get('userID', None)
                if unsharedAll and MasterID != None:
                    response = HttpResponse(self.unsharedUserEquipmentSQL(MasterID, GuestID, True, args, kwargs))
                    return response
                else:
                    if content != None and MasterID != None:
                        response = HttpResponse(self.unsharedUserEquipmentSQL(MasterID, GuestID, False, args, content=content))
                        return response
                    else:
                        return ResponseJSON(805)

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

    def unsharedUserEquipmentSQL(self, MasterID, GuestID, unsharedAll, *args, **kwargs):
        if unsharedAll:
            try:
                equipmentCount = Device_Info.objects.filter(userID_id=GuestID, primaryUserID=MasterID).delete()
            except Exception as e:
                errorInfo = traceback.format_exc()
                print('删除设备更新数据库错误: %s' % errorInfo)
                return ResponseFormal(171, {"details": repr(e)})
            else:
                return ResponseFormal(0, {'removeCount': equipmentCount[0]})
        else:
            content = kwargs.get('content', None)
            if content != None:
                removeCount = 0
                errorRemove = []
                errorUID = []

                contentDict = json.loads(content)
                uidlist = contentDict.get('UID', None)

                for index in range(len(uidlist)):
                    uid = uidlist[index]
                    try:
                        equipment = Device_Info.objects.filter(userID_id=GuestID, primaryUserID=MasterID, UID=uid)
                        if equipment:
                            equipmentCount = equipment.delete()
                        else:
                            errorUID.append(uid)
                            continue
                    except Exception as e:
                        errorInfo = traceback.format_exc()
                        print('查询数据库错误: %s' % errorInfo)

                        errorRemove.append(uid)
                        continue
                    else:
                        removeCount += equipmentCount[0]

                if len(errorRemove) > 0:
                    return ResponseFormal(171, {
                                'removeCount': removeCount,
                                'error_UID': errorRemove,
                            })
                else:
                    if len(errorUID) >0:
                        return ResponseFormal(173, {
                            'removeCount': removeCount,
                            'error_UID': errorUID,
                        })
                    else:
                        return ResponseFormal(0, {
                                     'removeCount': removeCount
                        })