ASJServer/Controller/FeedBack.py

import json
import threading
import time

import oss2
from django.db import transaction
from django.views.generic.base import View

from Ansjer.config import ACCESS_KEY_ID, SECRET_ACCESS_KEY, REGION_NAME, PUSH_BUCKET, PUSH_INACCURATE_BUCKET
from Ansjer.config import OSS_STS_ACCESS_KEY, OSS_STS_ACCESS_SECRET, LOGGER
from Model.models import FeedBackModel, StatResModel, PushInaccurateFeedback
from Object.AWS.AmazonS3Util import AmazonS3Util
from Object.ResponseObject import ResponseObject
from Object.TokenObject import TokenObject
from Object.utils import LocalDateTimeUtil
from Service.CommonService import CommonService
from Service.ModelService import ModelService
from Service.EquipmentInfoService import EquipmentInfoService


class FeedBackView(View):
    def get(self, request, *args, **kwargs):
        request.encoding = 'utf-8'
        operation = kwargs.get('operation', None)
        return self.validation(request.GET, operation)

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

    def validation(self, request_dict, operation):
        response = ResponseObject()
        token = request_dict.get('token', None)
        tko = TokenObject(token)
        if tko.code == 0:
            userID = tko.userID
            if operation == 'add':
                return self.do_add(userID, request_dict, response)
            elif operation == 'getUploadUrl':
                return self.do_get_upload_url(request_dict, response)
            elif operation == 'query':
                return self.do_query(userID, request_dict, response)
            elif operation == 'delete':
                return self.do_delete(userID, request_dict, response)
            elif operation == 'queryByAdmin':
                return self.do_query_by_admin(userID, request_dict, response)
            elif operation == 'deleteByAdmin':
                return self.do_delete_by_admin(userID, request_dict, response)
            elif operation == 'deleteImage':
                return self.do_delete_image(userID, request_dict, response)
            elif operation == 'submitted':  # 查询是否已提交过推送图片反馈
                return self.submitted(userID, request_dict, response)
            elif operation == 'pushInaccurate':  # 用户反馈推送不准确
                return self.push_inaccurate(userID, request_dict, response)
            else:
                return response.json(414)
        else:
            return response.json(tko.code)

    def do_query(self, userID, request_dict, response):
        page = request_dict.get('page', None)
        line = request_dict.get('line', None)
        if page and line:
            page = int(page)
            line = int(line)
        else:
            return response.json(444, 'page,line')

        fb_qs = FeedBackModel.objects.filter(userID_id=userID)[(page - 1) * line:page * line]. \
            values('id', 'status', 'content', 'addTime', 'updTime', 'type')
        sid_list = []
        for fb in fb_qs:
            sid_list.append(fb['id'])
        sm_qs = StatResModel.objects.filter(feedbackmodel__id__in=sid_list).values('id', 'name', 'feedbackmodel__id')
        # return response.json(0,list(sm_qs))
        auth = oss2.Auth(OSS_STS_ACCESS_KEY, OSS_STS_ACCESS_SECRET)
        bucket = oss2.Bucket(auth, 'oss-cn-hongkong.aliyuncs.com', 'statres')
        res = []
        for fb in fb_qs:
            fb['img_url'] = []
            for sm in sm_qs:
                if sm['feedbackmodel__id'] == fb['id']:
                    obj = 'feedback/' + sm['name']
                    img_url = bucket.sign_url('GET', obj, 3600)
                    fb['img_url'].append(img_url)
                    # fb['FS__name'] = sm['name']
            res.append(fb)
        return response.json(0, res)

    def do_add(self, userID, request_dict, response):
        nowTime = int(time.time())
        content = request_dict.get('content', None)
        type = request_dict.get('type', None)
        res_1 = request_dict.get('res_1', None)
        res_2 = request_dict.get('res_2', None)
        res_3 = request_dict.get('res_3', None)

        app = request_dict.get('app', None)
        phone_model = request_dict.get('phone_model', None)
        os_version = request_dict.get('os_version', None)
        uid = request_dict.get('uid', None)
        product_type = request_dict.get('product_type', None)
        app_version = request_dict.get('app_version', None)
        appBundleId = request_dict.get('appBundleId', None)
        email = request_dict.get('email', None)
        score = request_dict.get('score', None)

        try:
            with transaction.atomic():
                fb = FeedBackModel()
                fb.addTime = nowTime
                fb.updTime = nowTime
                fb.content = content
                if type:
                    fb.type = type
                if app:
                    fb.app = app
                if phone_model:
                    fb.phone_model = phone_model
                if os_version:
                    fb.os_version = os_version
                if uid:
                    fb.uid = uid
                if product_type:
                    fb.product_type = product_type
                if app_version:
                    fb.app_version = app_version
                if appBundleId:
                    fb.appBundleId = appBundleId
                if email:
                    fb.email = email
                if score:
                    fb.score = score
                fb.userID_id = userID
                fb.save()
                if res_1:
                    fb.FS.add(StatResModel.objects.create(addTime=nowTime, name=res_1))
                if res_2:
                    fb.FS.add(StatResModel.objects.create(addTime=nowTime, name=res_2))
                if res_3:
                    fb.FS.add(StatResModel.objects.create(addTime=nowTime, name=res_3))
        except Exception as e:
            print(repr(e))
            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))
        else:
            return response.json(0)

    def do_get_upload_url(self, request_dict, response):
        uploadType = request_dict.get('uploadType', None)
        uploadType = json.loads(uploadType)
        if len(uploadType):
            res = []
            auth = oss2.Auth(OSS_STS_ACCESS_KEY, OSS_STS_ACCESS_SECRET)
            bucket = oss2.Bucket(auth, 'oss-cn-hongkong.aliyuncs.com', 'statres')
            for upType in uploadType:
                name = CommonService.createOrderID()
                s_name = str(name) + '.' + upType
                obj = 'feedback/' + s_name

                url = bucket.sign_url('PUT', obj, 7200)
                res.append({'put_url': url, 'res_name': s_name})
            return response.json(0, res)
        else:
            return response.json(444, 'uploadType')

    def do_delete(self, userID, request_dict, response):
        id = request_dict.get('id', None)
        try:
            fb_qs = FeedBackModel.objects.get(userID_id=userID, id=id)
            sr_id_list = fb_qs.FS.values_list('id', flat=True)
            StatResModel.objects.filter(id__in=sr_id_list).delete()
            fb_qs.delete()
            # is_delete = StatResModel.objects.filter(id__in=sr_id_list).delete()

            # print(is_delete)
            print('----------')

        except Exception as e:
            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))
        else:
            return response.json(0)

    def do_query_by_admin(self, userID, request_dict, response):
        own_perm = ModelService.check_perm(userID, 30)
        if own_perm:
            page = request_dict.get('page', None)
            line = request_dict.get('line', None)
            status = request_dict.get('status', None)
            username = request_dict.get('username', None)
            type = request_dict.get('type', None)
            if page and line:
                page = int(page)
                line = int(line)
                filter_data = {}
                if status:
                    filter_data = {'status': status}
                if username:
                    filter_data = {'userID_id': ModelService.get_userID_byname(username)}
                if type:
                    filter_data = {'type': type}

                try:
                    fb_qs = FeedBackModel.objects.filter()
                except Exception as e:
                    return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))
                print('----------')
                if filter_data:
                    fb_qs = fb_qs.filter(**filter_data)
                count = fb_qs.count()
                fb_qs = fb_qs[(page - 1) * line:page * line].values('id', 'type', 'status', 'content', 'addTime', 'app',
                                                                    'uid', 'os_version', 'phone_model', 'product_type',
                                                                    'updTime', 'userID__username', 'userID__phone',
                                                                    'userID__userEmail', 'app_version', 'appBundleId',
                                                                    'email', 'score'
                                                                    )
                sid_list = []
                print(fb_qs)
                for fb in fb_qs:
                    sid_list.append(fb['id'])
                sm_qs = StatResModel.objects.filter(feedbackmodel__id__in=sid_list).values('id', 'name',
                                                                                           'feedbackmodel__id')
                auth = oss2.Auth(OSS_STS_ACCESS_KEY, OSS_STS_ACCESS_SECRET)
                bucket = oss2.Bucket(auth, 'oss-cn-hongkong.aliyuncs.com', 'statres')
                res = []
                print(sm_qs)
                for fb in fb_qs:
                    fb['img_url'] = []
                    for sm in sm_qs:
                        if sm['feedbackmodel__id'] == fb['id']:
                            obj = 'feedback/' + sm['name']
                            img_url = bucket.sign_url('GET', obj, 3600)
                            # img_url.replace('statres.oss-cn-hongkong.aliyuncs.com','static.zositech.xyz')
                            fb['img_url'].append(img_url)
                            # fb['FS__name'] = sm['name']
                            if fb['userID__username'] == '':
                                fb['userID__username'] = fb['userID__userEmail']
                            if fb['userID__username'] == '':
                                fb['userID__username'] = fb['userID__phone']
                    res.append(fb)
                return response.json(0, {'datas': res, 'count': count})
            else:
                return response.json(444, 'page,line')
        else:
            return response.json(404)

    def do_delete_by_admin(self, userID, request_dict, response):
        own_perm = ModelService.check_perm(userID, 10)
        if own_perm:

            id = request_dict.get('id', None)
            try:
                fb_qs = FeedBackModel.objects.get(id=id)
                sr_id_list = fb_qs.FS.values_list('id', flat=True)
                StatResModel.objects.filter(id__in=sr_id_list).delete()
                fb_qs.delete()
                print('----------')
            except Exception as e:
                return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))
            else:
                return response.json(0)
        else:
            return response.json(404)

    def do_delete_image(self, userID, request_dict, response):
        # own_perm = ModelService.check_perm(userID, 10)
        # if not own_perm:
        #     return response.json(404)
        end_time = request_dict.get('end_time', None)
        if end_time is None:
            return response.json(444)
        sys_ms_qs = FeedBackModel.objects.filter(addTime__lt=end_time).order_by('id').values('id')
        ids = []
        for sys_ms in sys_ms_qs:
            ids.append(sys_ms['id'])

        sm_qs = StatResModel.objects.filter(feedbackmodel__id__in=ids).values('id', 'name')
        names = []
        time_struct = time.localtime()
        current_year = time_struct.tm_year
        target_year = current_year - 1
        str_prefix = str(target_year)
        print(str_prefix)
        for sm in sm_qs:
            name = sm['name']
            if name.find(str_prefix) == 0:
                names.append('feedback/' + name)

        # auth = oss2.Auth(OSS_STS_ACCESS_KEY, OSS_STS_ACCESS_SECRET)
        # bucket = oss2.Bucket(auth, 'oss-cn-hongkong.aliyuncs.com', 'statres')
        # bucket.batch_delete_objects(names)
        # FeedBackModel.objects.filter(id__in=ids).delete()
        print(names)
        print(len(names))

        return response.json(0)

    @staticmethod
    def submitted(user_id, request_dict, response):
        equipment_info_id = request_dict.get('equipment_info_id', None)
        uid = request_dict.get('uid', None)
        is_st = request_dict.get('is_st', None)
        event_type = request_dict.get('event_type', None)
        event_time = request_dict.get('event_time', None)
        channel = request_dict.get('channel', None)
        if not all([equipment_info_id, uid, is_st, event_type, event_time, channel]):
            return response.json(444)
        is_st, event_type, channel = int(is_st), int(event_type), int(channel)
        # 查询数据是否存在
        push_inaccurate_feedback_qs = PushInaccurateFeedback.objects.filter(equipment_info_id=equipment_info_id,
                                                                            user_id=user_id, uid=uid, channel=channel,
                                                                            event_type=event_type,
                                                                            event_time=event_time,
                                                                            is_st=is_st)
        if push_inaccurate_feedback_qs.exists():
            return response.json(174)
        # 查询图片是否存在s3
        if is_st == 3:
            key = '{uid}/{channel}/{event_time}_0.jpeg'.format(uid=uid, channel=channel, event_time=event_time)
        else:
            key = '{uid}/{channel}/{event_time}.jpeg'.format(uid=uid, channel=channel, event_time=event_time)
        try:
            s3 = AmazonS3Util(
                aws_access_key_id=ACCESS_KEY_ID,
                secret_access_key=SECRET_ACCESS_KEY,
                region_name=REGION_NAME
            )
            have_object = s3.get_object(PUSH_BUCKET, key)
            if have_object:
                return response.json(0)
            else:
                return response.json(174)
        except Exception as e:
            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))

    @staticmethod
    def push_inaccurate(user_id, request_dict, response):
        equipment_info_id = request_dict.get('equipment_info_id', None)
        uid = request_dict.get('uid', None)
        is_st = request_dict.get('is_st', None)
        event_type = request_dict.get('event_type', None)
        event_time = request_dict.get('event_time', None)
        channel = request_dict.get('channel', None)
        tag = request_dict.get('tag', '')
        if not all([equipment_info_id, uid, is_st, event_type, event_time, channel]):
            return response.json(444)
        try:
            thread = threading.Thread(target=FeedBackView.asyn_push_inaccurate,
                                      args=(
                                          equipment_info_id, uid, channel, user_id, event_type, event_time, int(is_st),
                                          tag,))
            thread.start()
            return response.json(0)
        except Exception as e:
            return response.json(500, repr(e))

    @staticmethod
    def asyn_push_inaccurate(equipment_info_id, uid, channel, user_id, event_type, event_time, is_st, tag):
        try:
            # 默认查询近七天内数据
            now_time = int(time.time())
            start_time = LocalDateTimeUtil.get_before_days_timestamp(now_time, 7)
            uid_list = uid.split(',')
            equipment_info_qs, count = EquipmentInfoService. \
                union_equipment_info(user_id, uid_list, event_type, start_time, now_time, 1, 10, event_time)
            identify_type = 1 if equipment_info_qs[0]['eventTag'] else 0
            s3 = AmazonS3Util(
                aws_access_key_id=ACCESS_KEY_ID,
                secret_access_key=SECRET_ACCESS_KEY,
                region_name=REGION_NAME
            )
            if is_st != 3:
                file_path = '{uid}/{channel}/{event_time}.jpeg'.format(uid=uid,
                                                                       channel=channel,
                                                                       event_time=event_time)
                s3.copy_obj(PUSH_BUCKET, PUSH_INACCURATE_BUCKET, file_path)
            else:
                for index in range(3):
                    file_path = '{uid}/{channel}/{event_time}_{index}.jpeg'.format(uid=uid,
                                                                                   channel=channel,
                                                                                   event_time=event_time,
                                                                                   index=index)
                    if s3.get_object(PUSH_BUCKET, file_path):
                        s3.copy_obj(PUSH_BUCKET, PUSH_INACCURATE_BUCKET, file_path)
            PushInaccurateFeedback.objects.create(equipment_info_id=equipment_info_id, user_id=user_id,
                                                  event_type=event_type, uid=uid, channel=channel,
                                                  add_time=now_time, tag=tag, is_st=is_st, event_time=event_time,
                                                  identify_type=identify_type)
        except Exception as e:
            LOGGER.info('asyn_push_inaccurate, errLine:{}, errMsg:{}'.format(e.__traceback__.tb_lineno, repr(e)))