Django: Как вызвать функцию представления из другого приложения?

# В web_interface/views.py
from django.http import HttpRequest, HttpResponse
from data_processor.views import process_data # Прямой импорт

def display_processed_data(request: HttpRequest) -> HttpResponse:
    """Представление, которое вызывает другое представление напрямую."""
    # Предположим, process_data ожидает данные из request
    # Важно: нужно передать объект request или создать новый,
    # если process_data не зависит от исходного запроса.
    processed_response = process_data(request)

    # Можно использовать результат ответа process_data
    # или выполнить дополнительные действия
    content = f"Результат обработки: {processed_response.content.decode()}"
    return HttpResponse(content)

# В web_interface/views.py
from django.http import HttpRequest, HttpResponse
from django.urls import reverse
from django.test import Client # Используем Django Test Client для внутренних запросов

def display_processed_data_via_url(request: HttpRequest) -> HttpResponse:
    """Представление, которое вызывает другое представление через URL."""
    # Получаем URL для представления process_data
    # Предполагается, что в urls.py приложения data_processor есть:
    # path('process/', views.process_data, name='process_data')
    try:
        process_url = reverse('data_processor:process_data')
    except NoReverseMatch:
        return HttpResponse("Ошибка: URL для process_data не найден.", status=500)

    # Создаем клиент для выполнения внутреннего запроса
    client = Client()

    # Собираем данные для передачи (если необходимо)
    # Данные могут быть взяты из исходного request или сгенерированы
    data_to_process = {'value': request.GET.get('input_value', 'default')}

    # Выполняем POST или GET запрос к URL представления
    # Используем тот же метод, который ожидает process_data
    # Передаем данные, если они нужны
    # Важно: заголовки и другие метаданные исходного запроса не передаются автоматически
    response = client.post(process_url, data=data_to_process)

    if response.status_code == 200:
        content = f"Результат обработки (через URL): {response.content.decode()}"
        return HttpResponse(content)
    else:
        return HttpResponse(f"Ошибка при вызове process_data: {response.status_code}", status=response.status_code)

# В data_processor/services.py
from typing import Dict, Any

def perform_data_processing(data: Dict[str, Any]) -> Dict[str, Any]:
    """Основная логика обработки данных."""
    # Здесь сложная логика: обращение к БД, вычисления, и т.д.
    processed_value = f"Processed: {data.get('value', 'N/A')}"
    return {'result': processed_value, 'status': 'success'}

# В data_processor/views.py
from django.http import HttpRequest, JsonResponse
from .services import perform_data_processing

def process_data(request: HttpRequest) -> JsonResponse:
    """Представление, использующее сервисный слой."""
    if request.method == 'POST':
        # Простая валидация и извлечение данных (в реальности использовать формы/сериализаторы)
        data = request.POST.dict()
        result = perform_data_processing(data)
        return JsonResponse(result)
    return JsonResponse({'error': 'Invalid method'}, status=405)

# В web_interface/views.py
from django.http import HttpRequest, HttpResponse
from data_processor.services import perform_data_processing # Импорт из сервисного слоя

def display_processed_data_via_service(request: HttpRequest) -> HttpResponse:
    """Представление, вызывающее логику через сервисный слой."""
    data_to_process = {'value': request.GET.get('input_value', 'default')}

    # Прямой вызов функции из сервисного слоя
    result_data = perform_data_processing(data_to_process)

    content = f"Результат обработки (через сервис): {result_data.get('result')}"
    return HttpResponse(content)

myproject/
├── manage.py
├── myproject/
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── ...
├── data_processor/
│   ├── __init__.py
│   ├── apps.py
│   ├── models.py
│   ├── services.py # Для сервисного слоя
│   ├── urls.py
│   └── views.py
└── web_interface/
    ├── __init__.py
    ├── apps.py
    ├── models.py
    ├── urls.py
    └── views.py

python manage.py startapp data_processor
python manage.py startapp web_interface

# data_processor/services.py (как в примере выше)
from typing import Dict, Any

def perform_data_processing(data: Dict[str, Any]) -> Dict[str, Any]:
    """Основная логика обработки данных."""
    processed_value = f"Processed: {data.get('value', 'N/A')} by data_processor"
    return {'result': processed_value, 'status': 'success'}

# data_processor/views.py
from django.http import HttpRequest, JsonResponse
from .services import perform_data_processing

def process_data(request: HttpRequest) -> JsonResponse:
    """Представление, которое можно вызвать по URL."""
    if request.method == 'POST':
        data = request.POST.dict()
        result = perform_data_processing(data)
        return JsonResponse(result)
    return JsonResponse({'error': 'Only POST method allowed'}, status=405)

# data_processor/urls.py
from django.urls import path
from . import views

app_name = 'data_processor'
urlpatterns = [
    path('process/', views.process_data, name='process_data'),
]

# myproject/urls.py (главный)
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('data/', include('data_processor.urls', namespace='data_processor')),
    path('web/', include('web_interface.urls', namespace='web_interface')), # Добавляем URL для web_interface
]

# web_interface/views.py
from django.http import HttpRequest, HttpResponse
from data_processor.services import perform_data_processing # Импортируем сервис

def show_results(request: HttpRequest) -> HttpResponse:
    """Отображает результат, полученный от data_processor."""
    # Получаем данные для обработки (например, из GET-параметра)
    input_value = request.GET.get('input', 'test_value')
    data_to_process = {'value': input_value}

    # Вызываем функцию сервисного слоя
    processing_result = perform_data_processing(data_to_process)

    # Формируем ответ
    content = f"Data Processor Result: {processing_result.get('result', 'Error')}"
    return HttpResponse(content)

# web_interface/urls.py
from django.urls import path
from . import views

app_name = 'web_interface'
urlpatterns = [
    path('show/', views.show_results, name='show_results'),
]

# web_interface/views.py
from django.http import HttpRequest, HttpResponse
from django.urls import reverse, NoReverseMatch
from django.test import Client

def show_results_via_url(request: HttpRequest) -> HttpResponse:
    """Отображает результат, полученный от data_processor через URL вызов."""
    input_value = request.GET.get('input', 'test_value')
    data_to_process = {'value': input_value}

    try:
        process_data_url = reverse('data_processor:process_data')
    except NoReverseMatch:
        return HttpResponse("URL 'data_processor:process_data' not found.", status=500)

    client = Client()
    # Используем POST, так как process_data ожидает POST
    response = client.post(process_data_url, data=data_to_process)

    if response.status_code == 200:
        # Ответ будет JsonResponse, нужно извлечь данные
        try:
            result_data = response.json()
            content = f"Data Processor Result (via URL): {result_data.get('result', 'Error in JSON')}"
            return HttpResponse(content)
        except ValueError: # json() может вызвать ошибку, если ответ не JSON
             return HttpResponse("Invalid JSON response from data_processor.", status=500)
    else:
        return HttpResponse(f"Error calling data_processor: {response.status_code}", status=response.status_code)

# web_interface/urls.py
# ... (добавить путь для show_results_via_url)
path('show-url/', views.show_results_via_url, name='show_results_via_url'),