dev/endpoints/endpoint_get_AAAAA/src/Controller/NodesController.php

<?php

namespace Drupal\endpoint_get_AAAAA\Controller;

use Drupal\Core\Controller\ControllerBase;
use Drupal\node\Entity\Node;
use Drupal\media\Plugin\media\Source;
use Drupal\media\Entity;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Drupal\Core\Url;
use Drupal\Core\Language\LanguageInterface;
use Drupal\Core\TempStore;
use Drupal\Core\Entity\EntityTypeManagerInterface;
use Drupal\Core\File\FileSystemInterface;
use Drupal\Core\File\FileUrlGeneratorInterface;
use Drupal\node\NodeInterface;
use Drupal\Core\DependencyInjection\ContainerInjectionInterface;
use Symfony\Component\DependencyInjection\ContainerInterface;

class NodesController extends ControllerBase implements ContainerInjectionInterface {

  public static function create(ContainerInterface $container) {
    return new static(
      $container->get('entity_type.manager'),
      $container->get('file_url_generator')
    );
  }

  protected $entityTypeManager;
  protected $fileUrlGenerator;

  public function __construct(
    EntityTypeManagerInterface $entityTypeManager,
    FileUrlGeneratorInterface $fileUrlGenerator
  ) {
    $this->entityTypeManager = $entityTypeManager;
    $this->fileUrlGenerator = $fileUrlGenerator;
  }

  private const NODE_TYPE = 'AAAAA'; // Editable

  /*
   * Used for : Taxonomy reference field
   * Value    : single ID of field_article_category value
   * Url      : optional URL argument - single value
   * Example  : /api/en/articles/1234
   */
  private const FIELD_CATEGORY = 'field_category'; // Editable

  /* Used for : Taxonomy reference field
   * Value    : multiple ID's of field_article_subcategory values
   * Url      : optional URL query params - accept multiple values
   * Example  : /api/en/articles/1234?subcategory=55,66,77
   */
  private const FIELD_SUBCATEGORY = 'field_subcategory'; // Editable

  private const HTTP_BAD_REQUEST = 400;
  private const HTTP_NOT_FOUND = 404;
  private const HTTP_OK = 200;
  private array $response = [];
  private int $statusCode = self::HTTP_OK;

  /*
   * Main
   */
  public function getNodes(Request $request, $lang, $category = 'all') {
    $nodes = $this->loadNodes($request, $lang, $category);
    $nodes_response = $this->buildNodes($nodes, $lang, $category);

    $this->response = [
      'code' => $this->statusCode,
			'count' => count($nodes_response),
      'nodes' => $nodes_response
    ];
    return new JsonResponse($this->response, $this->statusCode);
  }

  /*
   * Response List
   */
  private function buildNodes(array $nodes, $lang): array {
    $nodes_response = [];
    foreach ($nodes as $node) {
      /* don't show node if it hasn't translation */
      if ( $node->hasTranslation($lang)) {
			  $node = $node->getTranslation($lang);
        $published = $node->get('status')->value;

        /* USER - get user name */
        $uid = $node->getOwnerId();
        $user = \Drupal\user\Entity\User::load($uid);
        $name = $user->getDisplayName();
        // AUTO_ADD_CODE_BELLOW_extractor

        if ($published == 1) {
          $nodes_response[] = [
            'id' => intval($node->id()),
			      'title' => $node->getTitle(),
            'lang' => $node->get('langcode')->value,
            'alias' => $node->get('path')->alias,
            'author' => $name,
            // AUTO_ADD_CODE_BELLOW_response
            'created' => $node->get('created')->value
          ];
        }
      }
    }
    return $nodes_response;
  }

  /*
   * FIELD_EXPLODE
   */
  // AUTO_ADD_CODE_BELLOW_splitter



  /*
   *
   * get response nodes
   *
   */
  private function loadNodes($request, $lang, $category) {

    /* build the query for nodes */
    $query = \Drupal::entityTypeManager()
      ->getStorage('node')
      ->getQuery()
      ->accessCheck(false);

    /* if category exist as URL parameter, create a query condition */
    if ($category != 'all'){
      $query->condition(self::FIELD_CATEGORY, $category);
    }

    /* if subcategory exist as URL query, create the query condition */
    if ($request->query->get('subcategory')){
      $or_group = $query->orConditionGroup();
      $terms = explode(',', $request->query->get('subcategory'));
      foreach ($terms as $term) {
        $or_group->condition(self::FIELD_SUBCATEGORY.'.target_id', $term);
      }
      $query->condition($or_group);
    }

    /* add pager */
		$query->range($request->get('start'), $request->get('length'));

    /* sort results by DESC or ASC */
    if ($request->get('sort')) {
      $sort = $request->get('sort');
      if(strcasecmp($sort, 'desc') == 0 || strcasecmp($sort, 'asc') == 0){
        $sort = $request->get('sort');
      }
      else{
        $sort = 'DESC';
      }
    }
    else{
      $sort = 'DESC';
    }

    /* sort results by field */
    if ($request->get('sortby')) {
      $sortby = $request->get('sortby');
      if(strcasecmp($sortby, 'title') == 0 || strcasecmp($sortby, 'created') == 0){
        $sortby = $request->get('sortby');
      }
      else{
        $sortby = 'created';
      }
    }
    else{
      $sortby = 'created';
    }

    /* filter creation date range: ?start_date=2023-01-01&end_date=2025-12-31 */
    if ($request->get('start_date') && $request->get('end_date')) {
      $startDate = $request->get('start_date');
      $endDate = $request->get('end_date');
      if ($startDate && $endDate) {
        $startDate = strtotime($startDate);
        $endDate = strtotime($endDate);
        $query->condition('created', $startDate, '>=');
        $query->condition('created', $endDate, '<=');
      }
    }

    /* pager: ?offset=0&limit=3 */
    $offset = $request->get('offset');
    $limit = $request->get('limit');
    if (isset($offset) && isset($limit)) {
      $offset = intval($offset);
      $limit = intval($limit);
      $query->range($offset, $limit);
    }

    /* execute query to get node ids */
    $nodeIds = $query
      ->condition('type', self::NODE_TYPE)
      ->sort($sortby, $sort, $lang)
      ->execute();

    /* get nodes from ids */
    $nodes=\Drupal::entityTypeManager()
      ->getStorage('node')
      ->loadMultiple($nodeIds);

    /* build the response list of nodes */
    $nodeList=[];
    foreach ($nodes as $node) {
      if ($node instanceof NodeInterface && $node->access('view')) {
        $tid = $node->id();
        $translatedNode = $node->hasTranslation($lang) ? $node->getTranslation($lang) : $node;
        $translatedNode->currentTranslation = $lang;
        $nodeList[$tid] = $translatedNode;
      }
    }
    return $nodeList;

  }
  // \Drupal::logger('Bundle AAAAA')->notice(''.$some_var);
}