class EntityUntranslatableFieldsConstraintValidator

class EntityUntranslatableFieldsConstraintValidator extends ConstraintValidator implements ContainerInjectionInterface {
  use EntityChangesDetectionTrait;
  
  /**
   * The entity type manager.
   *
   * @var \Drupal\Core\Entity\EntityTypeManagerInterface
   */
  protected $entityTypeManager;
  
  /**
   * Constructs an EntityUntranslatableFieldsConstraintValidator object.
   *
   * @param \Drupal\Core\Entity\EntityTypeManagerInterface $entity_type_manager
   *   The entity type manager.
   */
  public function __construct(EntityTypeManagerInterface $entity_type_manager) {
    $this->entityTypeManager = $entity_type_manager;
  }
  
  /**
   * {@inheritdoc}
   */
  public static function create(ContainerInterface $container) {
    return new static($container->get('entity_type.manager'));
  }
  
  /**
   * {@inheritdoc}
   */
  public function validate($entity, Constraint $constraint) {
    /** @var \Drupal\Core\Entity\ContentEntityInterface $entity */
    /** @var \Drupal\Core\Entity\Plugin\Validation\Constraint\EntityUntranslatableFieldsConstraint $constraint */
    // Untranslatable field restrictions apply only to revisions of multilingual
    // entities.
    if ($entity->isNew() || !$entity->isTranslatable() || !$entity->getEntityType()
      ->isRevisionable()) {
      return;
    }
    if ($entity->isDefaultRevision() && !$entity->isDefaultTranslationAffectedOnly()) {
      return;
    }
    // To avoid unintentional reverts and data losses, we forbid changes to
    // untranslatable fields in pending revisions for multilingual entities. The
    // only case where changes in pending revisions are acceptable is when
    // untranslatable fields affect only the default translation, in which case
    // a pending revision contains only one affected translation. Even in this
    // case, multiple translations would be affected in a single revision, if we
    // allowed changes to untranslatable fields while editing non-default
    // translations, so that is forbidden too. For the same reason, when changes
    // to untranslatable fields affect all translations, we can only allow them
    // in default revisions.
    if ($this->hasUntranslatableFieldsChanges($entity)) {
      if ($entity->isDefaultTranslationAffectedOnly()) {
        foreach ($entity->getTranslationLanguages(FALSE) as $langcode => $language) {
          if ($entity->getTranslation($langcode)
            ->hasTranslationChanges()) {
            $this->context
              ->addViolation($constraint->defaultTranslationMessage);
            break;

          }
        }
      }
      else {
        $this->context
          ->addViolation($constraint->defaultRevisionMessage);
      }
    }
  }
  
  /**
   * Checks whether an entity has untranslatable field changes.
   *
   * @param \Drupal\Core\Entity\ContentEntityInterface $entity
   *   A content entity object.
   *
   * @return bool
   *   TRUE if untranslatable fields have changes, FALSE otherwise.
   */
  protected function hasUntranslatableFieldsChanges(ContentEntityInterface $entity) {
    $skip_fields = $this->getFieldsToSkipFromTranslationChangesCheck($entity);
    /** @var \Drupal\Core\Entity\ContentEntityInterface $original */
    if (isset($entity->original)) {
      $original = $entity->original;
    }
    else {
      /** @var \Drupal\Core\Entity\RevisionableStorageInterface $storage */
      $storage = $this->entityTypeManager
        ->getStorage($entity->getEntityTypeId());
      $original = $storage->loadRevision($entity->getLoadedRevisionId());
    }
    foreach ($entity->getFieldDefinitions() as $field_name => $definition) {
      if (in_array($field_name, $skip_fields, TRUE) || $definition->isTranslatable() || $definition->isComputed()) {
        continue;
      }
      $items = $entity->get($field_name)
        ->filterEmptyItems();
      $original_items = $original->get($field_name)
        ->filterEmptyItems();
      if ($items->hasAffectingChanges($original_items, $entity->getUntranslated()
        ->language()
        ->getId())) {
        return TRUE;
      }
    }
    return FALSE;
  }

}