修复订单查询统计错误、云存用户接口分页错误及加云存位置列

AdminController/ProductsSchemeManageController.py

@@ -801,31 +801,34 @@ class ProductsSchemeManageView(View):
             activated_prefixes = set(activated_prefixes_qs)
 
             if order_number:
-                product_scheme = products_schemes_qs.filter(order_number=order_number).first()
-
-                if not product_scheme:
+                storage_codes = products_schemes_qs.filter(order_number=order_number).values_list('storage_code',
+                                                                                                  flat=True).distinct()
+                if not storage_codes:
                     return response.json(0, {})
 
-                order_devices_qs = DeviceScheme.objects.filter(storage_code=product_scheme.storage_code)
+                # 批量查询设备
+                serial_numbers = DeviceScheme.objects.filter(
+                    storage_code__in=storage_codes,
+                ).values_list('serial_number', flat=True)
+                total_devices_in_stock = len(serial_numbers)
 
-                # 设备总数
-                devices_in_stock = order_devices_qs.count()
+                # 提取前缀
+                order_prefixes = {sn[:6] for sn in serial_numbers} if serial_numbers else set()
 
-                # 激活数量
-                order_prefixes = order_devices_qs.annotate(
-                    prefix=Substr('serial_number', 1, 6)
-                ).values_list('prefix', flat=True)
-
-                devices_activated = CompanySerialModel.objects.filter(
-                    serial_number__in=order_prefixes,
-                    status__gt=1
-                ).count()
+                # 批量查询激活设备
+                if order_prefixes:
+                    q_objects = Q()
+                    for prefix in order_prefixes:
+                        q_objects |= Q(serial_number__startswith=prefix)
+                    total_devices_activated = CompanySerialModel.objects.filter(q_objects, status__gt=1).count()
+                else:
+                    total_devices_activated = 0
 
                 return response.json(0, {
-                    'order_number': product_scheme.order_number,
-                    'devices_in_stock': devices_in_stock,
-                    'devices_activated': devices_activated,
-                    'devices_inactive': devices_in_stock - devices_activated
+                    'order_number': order_number,
+                    'devices_in_stock': total_devices_in_stock,
+                    'devices_activated': total_devices_activated,
+                    'devices_inactive': total_devices_in_stock - total_devices_activated
                 })
             else:
                 # 查询汇总数据

AdminController/ServeManagementController.py

@@ -16,7 +16,7 @@ import xlrd
 import xlwt
 from django.core.paginator import Paginator
 from django.db import transaction, connection
-from django.db.models import F, Sum, Count, Q
+from django.db.models import F, Count, Q, OuterRef, Subquery
 from django.http import HttpResponse, StreamingHttpResponse
 from django.utils.encoding import escape_uri_path
 from django.views.generic.base import View
@@ -1869,111 +1869,123 @@ class serveManagement(View):
                     addTime__gte=endStartTime,
                     addTime__lte=endEndTime)
 
-            uid_list = []
+            if not uid_bucket_qs.exists():
+                return response.json(0, {'list': [], 'total': 0})
+
+            bucket_ids = uid_bucket_qs.values_list('id', flat=True)
+            order_qs = Order_Model.objects.filter(uid_bucket_id__in=bucket_ids).select_related('userID')
+
+            if username:
+                order_qs = order_qs.filter(userID__username=username)
+            if phone:
+                order_qs = order_qs.filter(userID__phone__contains=phone)
+            if userEmail:
+                order_qs = order_qs.filter(userID__userEmail__contains=userEmail)
+            if payType:
+                order_qs = order_qs.filter(payType=int(payType))
+
+            if logTimeRange and len(logTimeRange) == 2:
+                logStartTime = int(logTimeRange[0][:-3]) if logTimeRange[0] else None
+                logEndTime = int(logTimeRange[1][:-3]) if logTimeRange[1] else None
+                if logStartTime and logEndTime:
+                        log_uids = CloudLogModel.objects.filter(
+                            operation='cloudstorage/queryvodlist',
+                            time__gte=logStartTime,
+                            time__lte=logEndTime
+                        ).values_list('uid', flat=True)
+
+                filtered_buckets = uid_bucket_qs.filter(uid__in=log_uids)
+                order_qs = order_qs.filter(uid_bucket_id__in=filtered_buckets.values_list('id', flat=True))
+
+
             uid_set_dict = {}
             if ucode and ucode != ['']:
                 uid_set_qs = UidSetModel.objects.filter(ucode__in=ucode).values('uid', 'ucode', 'version').distinct()
-                for uid_set in uid_set_qs:
-                    uid_list.append(uid_set['uid'])
-                    uid_set_dict[uid_set['uid']] = {
-                        'ucode': uid_set['ucode'],
-                        'version': uid_set['version']
-                    }
-                uid_bucket_qs = uid_bucket_qs.filter(uid__in=uid_list)
             else:
-                uid_set_qs = UidSetModel.objects.filter().values('uid', 'ucode', 'version').distinct()
-                for uid_set in uid_set_qs:
-                    uid_list.append(uid_set['uid'])
-                    uid_set_dict[uid_set['uid']] = {
-                        'ucode': uid_set['ucode'],
-                        'version': uid_set['version']
-                    }
+                uid_set_qs = UidSetModel.objects.all().values('uid', 'ucode', 'version').distinct()
 
-            if not uid_bucket_qs.exists():
-                return response.json(0, [])
+            for uid_set in uid_set_qs:
+                uid_set_dict[uid_set['uid']] = {
+                    'ucode': uid_set['ucode'],
+                    'version': uid_set['version']
+                }
 
-            order_qs = Order_Model.objects.filter(uid_bucket_id__in=uid_bucket_qs.values('id'))
-            if username or phone or userEmail or payType:
-                if username:
-                    order_qs = order_qs.filter(userID__username=username)
-                if phone:
-                    order_qs = order_qs.filter(userID__phone__contains=phone)
-                if userEmail:
-                    order_qs = order_qs.filter(
-                        userID__userEmail__contains=userEmail)
-                if payType:
-                    order_qs = order_qs.filter(payType=int(payType))
-                # 过滤套餐关联的UID_Bucket数据
-                uid_bucket_qs = uid_bucket_qs.filter(
-                    id__in=order_qs.values_list(
-                        'uid_bucket_id', flat=True))
+            total_count = order_qs.count()
 
-            cg_qs = CloudLogModel.objects.filter(
-                operation='cloudstorage/queryvodlist')
-            if logTimeRange:
-                logStartTime, logEndTime = int(
-                    logTimeRange[0][:-3]), int(logTimeRange[1][:-3])
-                cg_qs = cg_qs.filter(
-                    time__gte=logStartTime,
-                    time__lte=logEndTime)
-                # 过滤套餐关联的UID_Bucket数据
-                uid_bucket_qs = uid_bucket_qs.filter(
-                    uid__in=cg_qs.values('uid'))
+            paginated_orders = order_qs.order_by('-updTime')[(page - 1) * line:page * line]
+
+            # --- 批量取 UID_Bucket ---
+            paginated_bucket_ids = [o.uid_bucket_id for o in paginated_orders]
+            bucket_map = {b.id: b for b in UID_Bucket.objects.filter(id__in=paginated_bucket_ids)}
+
+            # --- 批量取 uid 列表 ---
+            paginated_uids = [bucket_map[i].uid for i in paginated_bucket_ids if i in bucket_map]
+
+            # --- 批量查询存储桶位置 ---
+            bucket_subquery = VodBucketModel.objects.filter(id=OuterRef('bucket_id')).values('vod_location')[:1]
+            sts_crd_qs = StsCrdModel.objects.filter(uid__in=paginated_uids).annotate(
+                bucket_location=Subquery(bucket_subquery)
+            )
+            sts_crd_map = {i.uid: (i.bucket_location or 0) for i in sts_crd_qs}
 
             list_data = []
-            count = uid_bucket_qs.count()
-            uid_bucket_qs = uid_bucket_qs.order_by('-addTime')[(page - 1) * line:page * line]
 
-            for uid_bucket in uid_bucket_qs:
-                for order in order_qs.filter(uid_bucket_id=uid_bucket.id) \
-                        .values('orderID', 'uid_bucket_id', 'desc', 'userID__userID',
-                                'UID', 'price', 'payType', 'userID__username', 'userID__phone',
-                                'userID__userEmail', 'userID__data_joined', 'agreement_id'):
-                    # 套餐到期时间累加未使用套餐
-                    unused_qs = Unused_Uid_Meal.objects.filter(uid=uid_bucket.uid).values('expire')
-                    if unused_qs.exists():
-                        addMonth = 0
-                        for unused in unused_qs:
-                            addMonth += unused['expire']
-                        endTime = CommonService.calcMonthLater(addMonth, uid_bucket.endTime)
-                        endTime = time.strftime("%Y--%m--%d %H:%M:%S", time.localtime(endTime))
-                    else:
-                        endTime = time.strftime("%Y--%m--%d %H:%M:%S", time.localtime(uid_bucket.endTime))
-                    uid = uid_bucket.uid.upper()
-                    data = {
+            for order in paginated_orders:
+                uid_bucket = bucket_map.get(order.uid_bucket_id)
+                if not uid_bucket:
+                    continue
+
+                uid = uid_bucket.uid.upper()
+
+                # 套餐到期时间
+                unused_qs = Unused_Uid_Meal.objects.filter(uid=uid_bucket.uid).values('expire')
+                if unused_qs.exists():
+                    addMonth = sum(x['expire'] for x in unused_qs)
+                    endTime = CommonService.calcMonthLater(addMonth, uid_bucket.endTime)
+                    endTime = time.strftime("%Y--%m--%d %H:%M:%S", time.localtime(endTime))
+                else:
+                    endTime = time.strftime("%Y--%m--%d %H:%M:%S", time.localtime(uid_bucket.endTime))
+
+                device_info = Device_Info.objects.filter(UID=uid).first()
+                serial_number = device_info.serial_number if (device_info and device_info.serial_number) else 'N/A'
+
+                # 计算播放次数
+                playcount = CloudLogModel.objects.filter(
+                    operation='cloudstorage/queryvodlist', uid=uid_bucket.uid
+                ).count()
+
+                data = {
                         'id': uid_bucket.id,
-                        'orderId': order['orderID'],
+                        'orderId': order.orderID,
                         'uid': uid,
-                        'agreementId': order['agreement_id'] if order['agreement_id'] else 'N/A',
+                        'agreementId': order.agreement_id if order.agreement_id else 'N/A',
                         'channel': uid_bucket.channel,
                         'status': uid_bucket.status,
                         'endTime': endTime,
                         'addTime': time.strftime("%Y--%m--%d %H:%M:%S", time.localtime(uid_bucket.addTime)),
                         'use_status': uid_bucket.use_status,
                         'has_unused': uid_bucket.has_unused,
-                        'desc': order['desc'],
-                        'payType': order['payType'],
-                        'price': order['price'],
-                        'username': order['userID__username'],
-                        'phone': order['userID__phone'],
-                        'userEmail': order['userID__userEmail'],
-                        'data_joined': order['userID__data_joined'].strftime("%Y-%m-%d %H:%M:%S"),
-                        'playcount': cg_qs.filter(operation='cloudstorage/queryvodlist', uid=order['UID']).count(),
-                        'serial_number': 'N/A'
-                    }
-                    device_info_qs = Device_Info.objects.filter(UID=uid).values('serial_number')
-                    if device_info_qs.exists():
-                        data['serial_number'] = device_info_qs[0]['serial_number'] if device_info_qs[0][
-                            'serial_number'] else 'N/A'
-                    if uid in uid_set_dict:
-                        data['ucode'] = uid_set_dict[uid]['ucode']
-                        data['version'] = uid_set_dict[uid]['version']
-
-                    list_data.append(data)
-            return response.json(
-                0, {'list': list_data, 'total': count})
+                        'desc': order.desc,
+                        'payType': order.payType,
+                        'price': order.price,
+                        'username': order.userID.username,
+                        'userID': order.userID.userID,
+                        'phone': order.userID.phone,
+                        'userEmail': order.userID.userEmail,
+                        'data_joined': order.userID.data_joined.strftime("%Y-%m-%d %H:%M:%S"),
+                        'playcount': playcount,
+                        'serial_number': serial_number,
+                        'bucket_location': sts_crd_map.get(uid_bucket.uid, 0),
+
+                        'ucode': uid_set_dict.get(uid, {}).get('ucode', 'N/A'),
+                        'version': uid_set_dict.get(uid, {}).get('version', 'N/A'),
+                }
+                list_data.append(data)
+
+            return response.json(0, {'list': list_data, 'total': total_count})
+
         except Exception as e:
-            print(e)
+            LOGGER.error('查询云存用户错误{}'.format(e))
             return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))
 
     @classmethod