Добавил работу с заявками на кубсат

dbapp/mainapp/views/kubsat.py

@@ -19,13 +19,65 @@ from mainapp.utils import calculate_mean_coords
 
 class KubsatView(LoginRequiredMixin, FormView):
     """Страница Кубсат с фильтрами и таблицей источников"""
-    template_name = 'mainapp/kubsat.html'
+    template_name = 'mainapp/kubsat_tabs.html'
     form_class = KubsatFilterForm
     
     def get_context_data(self, **kwargs):
         context = super().get_context_data(**kwargs)
         context['full_width_page'] = True
         
+        # Добавляем данные для вкладки заявок
+        from mainapp.models import SourceRequest
+        requests_qs = SourceRequest.objects.select_related(
+            'source', 'source__info', 'source__ownership',
+            'created_by__user', 'updated_by__user'
+        ).prefetch_related(
+            'source__source_objitems__parameter_obj__modulation'
+        ).order_by('-created_at')
+        
+        # Фильтры для заявок
+        status = self.request.GET.get('status')
+        if status:
+            requests_qs = requests_qs.filter(status=status)
+        
+        priority = self.request.GET.get('priority')
+        if priority:
+            requests_qs = requests_qs.filter(priority=priority)
+        
+        # Добавляем данные источника к каждой заявке
+        requests_list = []
+        for req in requests_qs[:100]:
+            # Получаем данные из первой точки источника
+            objitem_name = '-'
+            modulation = '-'
+            symbol_rate = '-'
+            
+            if req.source:
+                first_objitem = req.source.source_objitems.select_related(
+                    'parameter_obj__modulation'
+                ).order_by('geo_obj__timestamp').first()
+                
+                if first_objitem:
+                    objitem_name = first_objitem.name or '-'
+                    if first_objitem.parameter_obj:
+                        if first_objitem.parameter_obj.modulation:
+                            modulation = first_objitem.parameter_obj.modulation.name
+                        if first_objitem.parameter_obj.bod_velocity and first_objitem.parameter_obj.bod_velocity > 0:
+                            symbol_rate = str(int(first_objitem.parameter_obj.bod_velocity))
+            
+            # Добавляем атрибуты к объекту заявки
+            req.objitem_name = objitem_name
+            req.modulation = modulation
+            req.symbol_rate = symbol_rate
+            requests_list.append(req)
+        
+        context['requests'] = requests_list
+        context['status_choices'] = SourceRequest.STATUS_CHOICES
+        context['priority_choices'] = SourceRequest.PRIORITY_CHOICES
+        context['current_status'] = status or ''
+        context['current_priority'] = priority or ''
+        context['search_query'] = self.request.GET.get('search', '')
+        
         # Если форма была отправлена, применяем фильтры
         if self.request.GET:
             form = self.form_class(self.request.GET)
@@ -38,11 +90,23 @@ class KubsatView(LoginRequiredMixin, FormView):
                 objitem_count = form.cleaned_data.get('objitem_count')
                 sources_with_date_info = []
                 for source in sources:
+                    # Get latest request info for this source
+                    latest_request = source.source_requests.order_by('-created_at').first()
+                    requests_count = source.source_requests.count()
+                    
                     source_data = {
                         'source': source,
                         'objitems_data': [],
                         'has_lyngsat': False,
-                        'lyngsat_id': None
+                        'lyngsat_id': None,
+                        'has_request': latest_request is not None,
+                        'request_status': latest_request.get_status_display() if latest_request else None,
+                        'request_status_raw': latest_request.status if latest_request else None,
+                        'gso_success': latest_request.gso_success if latest_request else None,
+                        'kubsat_success': latest_request.kubsat_success if latest_request else None,
+                        'planned_at': latest_request.planned_at if latest_request else None,
+                        'requests_count': requests_count,
+                        'average_coords': None,  # Будет рассчитано после сбора точек
                     }
                     
                     for objitem in source.source_objitems.all():
@@ -89,6 +153,27 @@ class KubsatView(LoginRequiredMixin, FormView):
                         elif objitem_count == '2+':
                             include_source = (filtered_count >= 2)
                     
+                    # Сортируем точки по дате ГЛ перед расчётом усреднённых координат
+                    source_data['objitems_data'].sort(
+                        key=lambda x: x['geo_date'] if x['geo_date'] else datetime.min.date()
+                    )
+                    
+                    # Рассчитываем усреднённые координаты из отфильтрованных точек
+                    if source_data['objitems_data']:
+                        avg_coords = None
+                        for objitem_info in source_data['objitems_data']:
+                            objitem = objitem_info['objitem']
+                            if hasattr(objitem, 'geo_obj') and objitem.geo_obj and objitem.geo_obj.coords:
+                                coord = (float(objitem.geo_obj.coords.x), float(objitem.geo_obj.coords.y))
+                                if avg_coords is None:
+                                    avg_coords = coord
+                                else:
+                                    avg_coords, _ = calculate_mean_coords(avg_coords, coord)
+                        if avg_coords:
+                            source_data['average_coords'] = avg_coords
+                            source_data['avg_lat'] = avg_coords[1]
+                            source_data['avg_lon'] = avg_coords[0]
+                    
                     if source_data['objitems_data'] and include_source:
                         sources_with_date_info.append(source_data)
                 
@@ -99,12 +184,17 @@ class KubsatView(LoginRequiredMixin, FormView):
     
     def apply_filters(self, filters):
         """Применяет фильтры к queryset Source"""
+        from mainapp.models import SourceRequest
+        from django.db.models import Subquery, OuterRef, Exists
+        
         queryset = Source.objects.select_related('info', 'ownership').prefetch_related(
             'source_objitems__parameter_obj__id_satellite',
             'source_objitems__parameter_obj__polarization',
             'source_objitems__parameter_obj__modulation',
             'source_objitems__transponder__sat_id',
-            'source_objitems__lyngsat_source'
+            'source_objitems__lyngsat_source',
+            'source_objitems__geo_obj',
+            'source_requests'
         ).annotate(objitem_count=Count('source_objitems'))
         
         # Фильтр по спутникам
@@ -166,8 +256,38 @@ class KubsatView(LoginRequiredMixin, FormView):
         elif objitem_count == '2+':
             queryset = queryset.filter(objitem_count__gte=2)
         
-        # Фиктивные фильтры (пока не применяются)
-        # has_plans, success_1, success_2, date_from, date_to
+        # Фильтр по наличию планов (заявок со статусом 'planned')
+        has_plans = filters.get('has_plans')
+        if has_plans == 'yes':
+            queryset = queryset.filter(
+                source_requests__status='planned'
+            ).distinct()
+        elif has_plans == 'no':
+            queryset = queryset.exclude(
+                source_requests__status='planned'
+            ).distinct()
+        
+        # Фильтр по ГСО успешно
+        success_1 = filters.get('success_1')
+        if success_1 == 'yes':
+            queryset = queryset.filter(
+                source_requests__gso_success=True
+            ).distinct()
+        elif success_1 == 'no':
+            queryset = queryset.filter(
+                source_requests__gso_success=False
+            ).distinct()
+        
+        # Фильтр по Кубсат успешно
+        success_2 = filters.get('success_2')
+        if success_2 == 'yes':
+            queryset = queryset.filter(
+                source_requests__kubsat_success=True
+            ).distinct()
+        elif success_2 == 'no':
+            queryset = queryset.filter(
+                source_requests__kubsat_success=False
+            ).distinct()
         
         return queryset.distinct()
 
@@ -268,6 +388,11 @@ class KubsatExportView(LoginRequiredMixin, FormView):
             source = data['source']
             objitems_list = data['objitems']
             
+            # Сортируем точки по дате ГЛ перед расчётом
+            objitems_list.sort(
+                key=lambda x: x.geo_obj.timestamp if x.geo_obj and x.geo_obj.timestamp else datetime.min
+            )
+            
             # Рассчитываем инкрементальное среднее координат из оставшихся точек
             average_coords = None
             for objitem in objitems_list:
@@ -411,3 +536,162 @@ class KubsatExportView(LoginRequiredMixin, FormView):
         response['Content-Disposition'] = f'attachment; filename="kubsat_{datetime.now().strftime("%Y%m%d")}.xlsx"'
         
         return response
+
+
+class KubsatCreateRequestsView(LoginRequiredMixin, FormView):
+    """Массовое создание заявок из отфильтрованных данных"""
+    form_class = KubsatFilterForm
+    
+    def post(self, request, *args, **kwargs):
+        import json
+        from django.http import JsonResponse
+        from mainapp.models import SourceRequest, CustomUser
+        
+        # Получаем список ID точек (ObjItem) из POST
+        objitem_ids = request.POST.getlist('objitem_ids')
+        
+        if not objitem_ids:
+            return JsonResponse({'success': False, 'error': 'Нет данных для создания заявок'}, status=400)
+        
+        # Получаем ObjItem с их источниками
+        objitems = ObjItem.objects.filter(id__in=objitem_ids).select_related(
+            'source',
+            'geo_obj'
+        )
+        
+        # Группируем ObjItem по Source
+        sources_objitems = {}
+        for objitem in objitems:
+            if objitem.source:
+                if objitem.source.id not in sources_objitems:
+                    sources_objitems[objitem.source.id] = {
+                        'source': objitem.source,
+                        'objitems': []
+                    }
+                sources_objitems[objitem.source.id]['objitems'].append(objitem)
+        
+        # Получаем CustomUser для текущего пользователя
+        try:
+            custom_user = CustomUser.objects.get(user=request.user)
+        except CustomUser.DoesNotExist:
+            custom_user = None
+        
+        created_count = 0
+        errors = []
+        
+        for source_id, data in sources_objitems.items():
+            source = data['source']
+            objitems_list = data['objitems']
+            
+            # Сортируем точки по дате ГЛ перед расчётом
+            objitems_list.sort(
+                key=lambda x: x.geo_obj.timestamp if x.geo_obj and x.geo_obj.timestamp else datetime.min
+            )
+            
+            # Рассчитываем усреднённые координаты из выбранных точек
+            average_coords = None
+            points_with_coords = 0
+            
+            for objitem in objitems_list:
+                if hasattr(objitem, 'geo_obj') and objitem.geo_obj and objitem.geo_obj.coords:
+                    coord = (objitem.geo_obj.coords.x, objitem.geo_obj.coords.y)
+                    points_with_coords += 1
+                    
+                    if average_coords is None:
+                        average_coords = coord
+                    else:
+                        average_coords, _ = calculate_mean_coords(average_coords, coord)
+            
+            # Создаём Point объект если есть координаты
+            coords_point = None
+            if average_coords:
+                coords_point = Point(average_coords[0], average_coords[1], srid=4326)
+            
+            try:
+                # Создаём новую заявку со статусом "planned"
+                source_request = SourceRequest.objects.create(
+                    source=source,
+                    status='planned',
+                    priority='medium',
+                    coords=coords_point,
+                    points_count=points_with_coords,
+                    created_by=custom_user,
+                    updated_by=custom_user,
+                    comment=f'Создано из Кубсат. Точек: {len(objitems_list)}'
+                )
+                created_count += 1
+            except Exception as e:
+                errors.append(f'Источник #{source_id}: {str(e)}')
+        
+        return JsonResponse({
+            'success': True,
+            'created_count': created_count,
+            'total_sources': len(sources_objitems),
+            'errors': errors
+        })
+
+
+class KubsatRecalculateCoordsView(LoginRequiredMixin, FormView):
+    """API для пересчёта усреднённых координат по списку ObjItem ID"""
+    form_class = KubsatFilterForm
+    
+    def post(self, request, *args, **kwargs):
+        import json
+        from django.http import JsonResponse
+        
+        # Получаем список ID точек (ObjItem) из POST
+        objitem_ids = request.POST.getlist('objitem_ids')
+        
+        if not objitem_ids:
+            return JsonResponse({'success': False, 'error': 'Нет данных для расчёта'}, status=400)
+        
+        # Получаем ObjItem с их источниками, сортируем по дате ГЛ
+        objitems = ObjItem.objects.filter(id__in=objitem_ids).select_related(
+            'source',
+            'geo_obj'
+        ).order_by('geo_obj__timestamp')  # Сортировка по дате ГЛ
+        
+        # Группируем ObjItem по Source
+        sources_objitems = {}
+        for objitem in objitems:
+            if objitem.source:
+                if objitem.source.id not in sources_objitems:
+                    sources_objitems[objitem.source.id] = []
+                sources_objitems[objitem.source.id].append(objitem)
+        
+        # Рассчитываем усреднённые координаты для каждого источника
+        results = {}
+        for source_id, objitems_list in sources_objitems.items():
+            # Сортируем по дате ГЛ (на случай если порядок сбился)
+            objitems_list.sort(key=lambda x: x.geo_obj.timestamp if x.geo_obj and x.geo_obj.timestamp else datetime.min)
+            
+            average_coords = None
+            points_count = 0
+            
+            for objitem in objitems_list:
+                if hasattr(objitem, 'geo_obj') and objitem.geo_obj and objitem.geo_obj.coords:
+                    coord = (float(objitem.geo_obj.coords.x), float(objitem.geo_obj.coords.y))
+                    points_count += 1
+                    
+                    if average_coords is None:
+                        average_coords = coord
+                    else:
+                        average_coords, _ = calculate_mean_coords(average_coords, coord)
+            
+            if average_coords:
+                results[str(source_id)] = {
+                    'avg_lon': average_coords[0],
+                    'avg_lat': average_coords[1],
+                    'points_count': points_count
+                }
+            else:
+                results[str(source_id)] = {
+                    'avg_lon': None,
+                    'avg_lat': None,
+                    'points_count': 0
+                }
+        
+        return JsonResponse({
+            'success': True,
+            'results': results
+        })