ASJServer/Controller/EquipmentOTA.py

from django.views.generic.base import View
from django.utils.decorators import method_decorator
from django.views.decorators.csrf import csrf_exempt
from Service.TokenManager import JSONTokenManager
from Service.ModelService import ModelService
from Service.CommonService import CommonService
from Model.models import Equipment_Version
from Ansjer.config import *
from django.utils import timezone
import os
from Service.ResponseService import *
'''
http://192.168.136.45:8077/equipment/OTA?token=test&operation=query&page=1&line=10
http://192.168.136.45:8077/equipment/OTA?token=test&operation=find&page=1&line=10&content={}
http://192.168.136.40:8077/equipment/OTA?eid=138001524641441203480138000&token=test&operation=delete
http://192.168.136.40:8077/equipment/OTA?eid=138001524641441203480138000&token=test&operation=update&status=1
'''

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

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

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

    def validation(self, request_dict, *args, **kwargs):
        token = request_dict.get('token', None)
        if token is not None:
            tokenManager = JSONTokenManager()
            error_code = tokenManager.verify_AToken(token)
            if error_code == 0:
                userID = tokenManager.accessDict.get('userID', None)
                operation = request_dict.get('operation', None)
                param_flag = CommonService.get_param_flag(data=[userID, operation])
                if param_flag is True:
                    if operation == 'delete':
                        return self.delete(request_dict=request_dict, userID=userID)
                    elif operation == 'query':
                        return self.query(request_dict=request_dict, userID=userID)
                    elif operation == 'find':
                        return self.find(request_dict=request_dict, userID=userID)
                    elif operation == 'update':
                        return self.update(request_dict=request_dict, userID=userID)

                return ResponseJSON(444)
            else:
                return HttpResponse(tokenManager.errorCodeInfo(error_code))
        else:
            return ResponseJSON(311)

    def delete(self, request_dict, userID):
        eid = request_dict.get('eid', None)
        param_flag = CommonService.get_param_flag(data=[eid])
        if param_flag is True:
            own_permission = ModelService.check_permission(userID=userID,permID=230)
            if own_permission is True:
                ev = Equipment_Version.objects.filter(eid=eid)
                if ev.exists():
                    try:
                        has_ev = EquipmentOTA.objects.filter(filePath = ev[0].filePath)
                        if has_ev.exists():
                            pass
                        else:
                            filepath = os.path.join(BASE_DIR,ev[0].filePath)
                            os.remove(filepath)
                    except Exception as e:
                        pass
                    ev.delete()
                    return ResponseJSON(0)
            else:
                return ResponseJSON(404)
        return ResponseJSON(444)

    def query(self, request_dict,userID):
        page = int(request_dict.get('page', None))
        line = int(request_dict.get('line', None))
        param_flag = CommonService.get_param_flag(data=[page,line])
        if param_flag is True:
            own_permission = ModelService.check_permission(userID=userID, permID=240)
            if own_permission is True:
                equipment_version_queryset = Equipment_Version.objects.all().order_by('-data_joined')
                if equipment_version_queryset.exists():
                    count = equipment_version_queryset.count()
                    res = equipment_version_queryset[(page - 1) * line:page * line]
                    send_json = CommonService.query_set_to_dict(res)
                    send_json['count'] = count
                    return ResponseJSON(0, send_json)
            else:
                return ResponseJSON(404)
        else:
            return ResponseJSON(444)

    def find(self, request_dict,userID):
        page = int(request_dict.get('page', None))
        line = int(request_dict.get('line', None))
        content = request_dict.get('content', None)
        param_flag = CommonService.get_param_flag(data=[page,line,content])
        if param_flag is True:
            own_permission = ModelService.check_permission(userID=userID, permID=250)
            if own_permission is True:
                content = json.loads(content)
                search_kwargs = CommonService.get_kwargs(data=content)
                equipment_version_queryset = Equipment_Version.objects.filter(**search_kwargs)
                if equipment_version_queryset.exists():
                    count = equipment_version_queryset.count()
                    res = equipment_version_queryset[(page - 1) * line:page * line]
                    send_json = CommonService.query_set_to_dict(res)
                    send_json['count'] = count
                    return ResponseJSON(0, send_json)
                else:
                    return ResponseJSON(0)
            else:
                return ResponseJSON(404)
        else:
            return ResponseJSON(444)

    def update(self,request_dict,userID):
        eid = request_dict.get('eid', None)
        param_flag = CommonService.get_param_flag(data=[eid])
        if param_flag is True:
            own_permission = ModelService.check_permission(userID=userID, permID=230)
            if own_permission is True:
                ev = Equipment_Version.objects.filter(eid=eid)
                if ev.exists():
                    status = request_dict.get('status',None)
                    try:

                        update_time = timezone.localtime(timezone.now())
                        ev.update(status=status,update_time=update_time)
                    except Exception as e:
                        print(repr(e))
                        pass
                    return ResponseJSON(0,{'update_time':str(update_time)})
            else:
                return ResponseJSON(404)
        return ResponseJSON(444)