getInternalName example

  protected function getExpectedGetRelationshipResponse($relationship_field_name, EntityInterface $entity = NULL) {
    $entity = $entity ?: $this->entity;
    $access = AccessResult::neutral()->addCacheContexts($entity->getEntityType()->isRevisionable() ? ['url.query_args:resourceVersion'] : []);
    $access = $access->orIf(static::entityFieldAccess($entity, $this->resourceType->getInternalName($relationship_field_name), 'view', $this->account));
    if (!$access->isAllowed()) {
      $via_link = Url::fromRoute(
        sprintf('jsonapi.%s.%s.relationship.get', static::$resourceTypeName, $relationship_field_name),
        ['entity' => $entity->uuid()]
      );
      return static::getAccessDeniedResponse($this->entity, $access, $via_link, $relationship_field_name, 'The current user is not allowed to view this relationship.', FALSE);
    }
    $expected_document = $this->getExpectedGetRelationshipDocument($relationship_field_name, $entity);
    $expected_cacheability = (new CacheableMetadata())
      ->addCacheTags(['http_response'])
      ->addCacheContexts([
        

return $this->synchronizerService->sync($destructive);
    }

    /** * @param array<string, Type> $types */
    private function updateContentTypesTable(array $types): void
    {
        $dbal = $this->connection;

        foreach ($types as $type) {
            $id = (int) $dbal->fetchOne('SELECT id FROM s_content_types WHERE internalName = ?', [$type->getInternalName()]);
            $update = [
                'internalName' => $type->getInternalName(),
                'name' => $type->getName(),
                'source' => $type->getSource(),
                'config' => json_encode($type, JSON_THROW_ON_ERROR),
            ];

            if ($id) {
                $dbal->update('s_content_types', $update, ['id' => $id]);
            } else {
                $dbal->insert('s_content_types', $update);
            }

  public function getRelated(ResourceType $resource_type, FieldableEntityInterface $entity, $related, Request $request) {
    /** @var \Drupal\Core\Field\EntityReferenceFieldItemListInterface $field_list */
    $resource_relationship = $resource_type->getFieldByPublicName($related);
    $field_list = $entity->get($resource_relationship->getInternalName());

    // Remove the entities pointing to a resource that may be disabled. Even     // though the normalizer skips disabled references, we can avoid unnecessary     // work by checking here too.     /** @var \Drupal\Core\Entity\EntityInterface[] $referenced_entities */
    $referenced_entities = array_filter(
      $field_list->referencedEntities(),
      function DEntityInterface $entity) {
        return (bool) $this->resourceTypeRepository->get(
          $entity->getEntityTypeId(),
          $entity->bundle()
        );

        try {
            $type = $this->provider->getType($model);
        } catch (RuntimeException $e) {
            return;
        }

        $label = $this->getLabelField($type);

        /** @var RepositoryInterface $repository */
        $repository = $controller->get('shopware.bundle.content_type.' . $type->getInternalName());

        $request = $controller->Request();

        $criteria = new Criteria();
        $criteria->offset = (int) $request->getParam('start', 0);
        $criteria->limit = (int) $request->getParam('limit', 0);
        $criteria->sort = $request->getParam('sort', []);
        $criteria->filter = $request->getParam('filter', []);
        $criteria->loadTranslations = false;
        $criteria->loadAssociations = false;

        

  public function handleFileUploadForExistingResource(Request $request, ResourceType $resource_type, $file_field_name, FieldableEntityInterface $entity) {
    $file_field_name = $resource_type->getInternalName($file_field_name);
    $field_definition = $this->validateAndLoadFieldDefinition($resource_type->getEntityTypeId(), $resource_type->getBundle(), $file_field_name);

    static::ensureFileUploadAccess($this->currentUser, $field_definition, $entity);

    $filename = $this->fileUploader->validateAndParseContentDispositionHeader($request);
    $file = $this->fileUploader->handleFileUploadForField($field_definition, $filename, $this->currentUser);

    if ($file instanceof EntityConstraintViolationListInterface) {
      $violations = $file;
      $message = "Unprocessable Entity: file validation failed.\n";
      $message .= implode("\n", array_map(function DConstraintViolationInterface $violation) {
        

  protected function getExpectedIncludedResourceResponse(array $include_paths, array $request_options) {
    $resource_type = $this->resourceType;
    $resource_data = array_reduce($include_paths, function D$data, $path) use ($request_options, $resource_type) {
      $field_names = explode('.', $path);
      /** @var \Drupal\Core\Entity\EntityInterface $entity */
      $entity = $this->entity;
      $collected_responses = [];
      foreach ($field_names as $public_field_name) {
        $resource_type = $this->container->get('jsonapi.resource_type.repository')->get($entity->getEntityTypeId(), $entity->bundle());
        $field_name = $resource_type->getInternalName($public_field_name);
        $field_access = static::entityFieldAccess($entity, $field_name, 'view', $this->account);
        if (!$field_access->isAllowed()) {
          if (!$entity->access('view') && $entity->access('view label') && $field_access instanceof AccessResultReasonInterface && empty($field_access->getReason())) {
            $field_access->setReason("The user only has authorization for the 'view label' operation.");
          }
          $via_link = Url::fromRoute(
            sprintf('jsonapi.%s.%s.related', $entity->getEntityTypeId() . '--' . $entity->bundle(), $public_field_name),
            ['entity' => $entity->uuid()]
          );
          $collected_responses[] = static::getAccessDeniedResponse($entity, $field_access, $via_link, $field_name, 'The current user is not allowed to view this relationship.', $field_name);
          break;
        }

  public static function resolveInternalIncludePath(ResourceType $resource_type, array $path_parts, $depth = 0) {
    $cacheability = (new CacheableMetadata())->addCacheContexts(['url.query_args:include']);
    if (empty($path_parts[0])) {
      throw new CacheableBadRequestHttpException($cacheability, 'Empty include path.');
    }
    $public_field_name = $path_parts[0];
    $internal_field_name = $resource_type->getInternalName($public_field_name);
    $relatable_resource_types = $resource_type->getRelatableResourceTypesByField($public_field_name);
    if (empty($relatable_resource_types)) {
      $message = "`$public_field_name` is not a valid relationship field name.";
      if (!empty(($possible = implode(', ', array_keys($resource_type->getRelatableResourceTypes()))))) {
        $message .= " Possible values: $possible.";
      }
      throw new CacheableBadRequestHttpException($cacheability, $message);
    }
    $remaining_parts = array_slice($path_parts, 1);
    if (empty($remaining_parts)) {
      return [[$internal_field_name]];
    }

/** * Aliases any resource type fields that have been aliased by a test. * * @param \Drupal\jsonapi\ResourceType\ResourceTypeBuildEvent $event * The build event. */
  public function aliasResourceTypeFields(ResourceTypeBuildEvent $event) {
    $aliases = \Drupal::state()->get('jsonapi_test_resource_type_builder.resource_type_field_aliases', []);
    $resource_type_name = $event->getResourceTypeName();
    if (in_array($resource_type_name, array_keys($aliases), TRUE)) {
      foreach ($event->getFields() as $field) {
        if (isset($aliases[$resource_type_name][$field->getInternalName()])) {
          $event->setPublicFieldName($field, $aliases[$resource_type_name][$field->getInternalName()]);
        }
      }
    }
  }

  /** * Disables any resource type fields that have been aliased by a test. * * @param \Drupal\jsonapi\ResourceType\ResourceTypeBuildEvent $event * The build event. */

parent::__construct();
        $this->type = $type;
    }

    public function indexAction(int $p = 1): void
    {
        $criteria = new Criteria();
        $criteria->offset = ($p - 1) * self::LIMIT;
        $criteria->limit = self::LIMIT;
        $criteria->sort = [['property' => 'id', 'direction' => 'DESC']];

        $this->get('events')->notify(sprintf('Content_Type_Frontend_Criteria_Creation_%s', $this->type->getInternalName()), [
            'subject' => $this,
            'criteria' => $criteria,
        ]);

        $result = $this->repository->findAll($criteria);

        $this->View()->assign('sPage', $p);
        $this->View()->assign('pages', ceil($result->total / self::LIMIT));
        $this->View()->assign('sItems', $result->items);
        $this->View()->assign('sTotal', $result->total);
        $this->View()->assign('sBreadcrumb', $this->getBreadcrumb());
    }

final class ConfigEntityDenormalizer extends EntityDenormalizerBase {

  /** * {@inheritdoc} */
  protected function prepareInput(array $data, ResourceType $resource_type, $format, array $context) {
    $prepared = [];
    foreach ($data as $key => $value) {
      $prepared[$resource_type->getInternalName($key)] = $value;
    }
    return $prepared;
  }

  /** * {@inheritdoc} */
  public function hasCacheableSupportsMethod(): bool {
    @trigger_error(__METHOD__ . '() is deprecated in drupal:10.1.0 and is removed from drupal:11.0.0. Use getSupportedTypes() instead. See https://www.drupal.org/node/3359695', E_USER_DEPRECATED);

    return TRUE;
  }

$this->snippetManager = $snippetManager;
        $this->slug = $slug;
        $this->typeBuilder = $typeBuilder;
        $this->cacheManager = $cacheManager;
        $this->synchronizerService = $synchronizerService;
        $this->cleanupService = $cleanupService;
    }

    public function listAction(): void
    {
        $types = array_map(static function DType $item) {
            return $item->jsonSerialize() + ['id' => $item->getInternalName()];
        }, $this->typeProvider->getTypes());

        $this->View()->assign('success', true);
        $this->View()->assign('data', array_values($types));
        $this->View()->assign('count', \count($types));
    }

    public function fieldsAction(): void
    {
        $query = strtolower((string) $this->Request()->getParam('query'));
        $data = [];
        

$type = $translator->translate($type);

            // insert controller, itself             $path = $type->getName() . '/';
            $path = $this->sCleanupPath($path);
            $this->sInsertUrl('sViewport=' . $type->getControllerName() . '&sAction=index', $path);

            $typeArray = json_decode(json_encode($type), true);

            /** @var RepositoryInterface $repository */
            $repository = Shopware()->Container()->get('shopware.bundle.content_type.' . $type->getInternalName());

            $criteria = new Criteria();
            $criteria->loadAssociations = true;
            $criteria->loadTranslations = true;
            $criteria->limit = null;

            foreach ($repository->findAll($criteria)->items as $item) {
                $path = $this->template->fetch('string:' . $type->getSeoUrlTemplate(), ['type' => $typeArray, 'item' => $item, 'context' => $context]);
                $path = $this->sCleanupPath($path);

                $org_path = sprintf('sViewport=%s&sAction=detail&id=%d', $type->getControllerName(), $item['id']);
                

 new ResourceTypeAttribute($field_name, $alias, TRUE, $has_one);
    }

    // With all fields now aliased, detect any conflicts caused by the     // automatically generated aliases above.     foreach (array_intersect($reserved_field_names, array_keys($fields)) as $reserved_field_name) {
      /** @var \Drupal\jsonapi\ResourceType\ResourceTypeField $aliased_reserved_field */
      $aliased_reserved_field = $fields[$reserved_field_name];
      /** @var \Drupal\jsonapi\ResourceType\ResourceTypeField $field */
      foreach (array_diff_key($fields, array_flip([$reserved_field_name])) as $field) {
        if ($aliased_reserved_field->getPublicName() === $field->getPublicName()) {
          throw new \LogicException("The generated alias '{$aliased_reserved_field->getPublicName()}' for field name '{$aliased_reserved_field->getInternalName()}' conflicts with an existing field. Please report this in the JSON:API issue queue!");
        }
      }
    }

    // Special handling for user entities that allows a JSON:API user agent to     // access the display name of a user. This is useful when displaying the     // name of a node's author.     // @see \Drupal\jsonapi\JsonApiResource\ResourceObject::extractContentEntityFields()     // @todo: eliminate this special casing in https://www.drupal.org/project/drupal/issues/3079254.     if ($entity_type->id() === 'user') {
      $fields['display_name'] = new ResourceTypeAttribute('display_name');
    }

  public function access(Route $route, RouteMatchInterface $route_match, AccountInterface $account = NULL) {
    [$relationship_field_name, $field_operation] = explode('.', $route->getRequirement(static::ROUTE_REQUIREMENT_KEY));
    assert(in_array($field_operation, ['view', 'edit'], TRUE));
    $entity_operation = $field_operation === 'view' ? 'view' : 'update';
    if ($resource_type = $route_match->getParameter(Routes::RESOURCE_TYPE_KEY)) {
      assert($resource_type instanceof ResourceType);
      $entity = $route_match->getParameter('entity');
      $internal_name = $resource_type->getInternalName($relationship_field_name);
      if ($entity instanceof FieldableEntityInterface && $entity->hasField($internal_name)) {
        $entity_access = $this->entityAccessChecker->checkEntityAccess($entity, $entity_operation, $account);
        $field_access = $entity->get($internal_name)->access($field_operation, $account, TRUE);
        // Ensure that access is respected for different entity revisions.         $access_result = $entity_access->andIf($field_access);
        if (!$access_result->isAllowed()) {
          $reason = "The current user is not allowed to {$field_operation} this relationship.";
          $access_reason = $access_result instanceof AccessResultReasonInterface ? $access_result->getReason() : NULL;
          $detailed_reason = empty($access_reason) ? $reason : $reason . " {$access_reason}";
          $access_result->setReason($detailed_reason);
        }
        

// User resource objects contain a read-only attribute that is not a real     // field on the user entity type.     // @see \Drupal\jsonapi\JsonApiResource\ResourceObject::extractContentEntityFields()     // @todo: eliminate this special casing in https://www.drupal.org/project/drupal/issues/3079254.     if ($entity_type_id === 'user') {
      $data = array_diff_key($data, array_flip([$resource_type->getPublicName('display_name')]));
    }

    // Translate the public fields into the entity fields.     foreach ($data as $public_field_name => $field_value) {
      $internal_name = $resource_type->getInternalName($public_field_name);

      // Skip any disabled field, except the always required bundle key and       // required-in-case-of-PATCHing uuid key.       // @see \Drupal\jsonapi\ResourceType\ResourceTypeRepository::getFieldMapping()       if ($resource_type->hasField($internal_name) && !$resource_type->isFieldEnabled($internal_name) && $bundle_key !== $internal_name && $uuid_key !== $internal_name) {
        continue;
      }

      if (!isset($field_map[$internal_name]) || !in_array($resource_type->getBundle(), $field_map[$internal_name]['bundles'], TRUE)) {
        throw new UnprocessableEntityHttpException(sprintf(
          'The attribute %s does not exist on the %s resource type.',