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.ModelService import ModelService
from Service.CommonService import CommonService
from Model.models import Equipment_Version
from django.utils import timezone
import os,simplejson as json
from Object.ResponseObject import ResponseObject
from Object.TokenObject import TokenObject
from Ansjer.settings import BASE_DIR
from Ansjer.config import SERVER_DOMAIN
import time


'''
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)
        response = ResponseObject()
        if token is not None:
            tko = TokenObject(token)
            tko.valid()
            response.lang = tko.lang
            if tko.code == 0:
                userID = tko.userID
                if userID is not None:
                    operation = request_dict.get('operation', None)
                    if operation is not None:
                        if operation == 'delete':
                            return self.delete(request_dict, userID, response)
                        elif operation == 'query':
                            return self.query(request_dict, userID, response)
                        elif operation == 'find':
                            return self.find(request_dict, userID, response)
                        elif operation == 'update':
                            return self.update(request_dict, userID, response)
                    return response.json(444, 'operation')
                else:
                    return response.json(309)
            else:
                return response.json(tko.code)
        else:
            return response.json(309)

    def delete(self, request_dict, userID,response):
        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 = Equipment_Version.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 response.json(0)
            else:
                return response.json(404)
        return response.json(444)

    def query(self, request_dict, userID,response):
        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.qs_to_dict(res)
                    send_json['count'] = count
                    return response.json(0, send_json)
                return response.json(0)
            else:
                return response.json(404)
        else:
            return response.json(444)

    def find(self, request_dict, userID,response):
        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.qs_to_dict(res)
                    send_json['count'] = count
                    return response.json(0, send_json)
                else:
                    return response.json(0)
            else:
                return response.json(404)
        else:
            return response.json(444)

    def update(self, request_dict, userID,response):
        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 response.json(0, {'update_time': str(update_time)})
            else:
                return response.json(404)
        return response.json(444)