Return's the name of the default configuration file.

@param string $entityTypeCode The entity type code to return the default configuration file for

@return string The name of the entity type's default configuration file
@throws \Exception
506618
protected function getDefaultConfigurationFile($entityTypeCode)
    {

        // query whether or not a default configuration file for the passed entity type code exists
        if (isset($this->configurationFileMappings[$entityTypeCode])) {
            return $this->configurationFileMappings[$entityTypeCode];
        }

        // throw an exception, if no default configuration file for the passed entity type is available
        throw new \Exception(
            sprintf(
                'Can\'t find a default configuration file for entity Type Code \'%s\' (MUST be one of catalog_product, catalog_product_price, catalog_product_inventory, catalog_category or eav_attribute)',
                $entityTypeCode
            )
        );
    }
387108
protected function getEntityName()
    {
        if (null === $this->entityName) {
            $name             = get_class($this);
            $type             = ucfirst($this->abstractType);
            $name             = str_replace($this->getModuleNamespace() . '\\' . $type . '\\', '', $name);
            $name             = str_replace($type, '', $name);
            $this->entityName = $name;
        }
        return $this->entityName;
    }
589646
public function getCommonFile($langcode = null)
    {
        if (!isset($langcode)) {
            $langcode = $this->langcode;
        }

        return $this->getCompiledDirectory($langcode) . "/$langcode.csv";
    }
688231
protected function lookUpEntity($entityId) {
        $entity = $this->generateEntity();
        $entityInstance = $entity->findFirst($entityId);
        if($entityInstance === false) {
            throw new Exception("Invalid Entity Id: Entity not found.", 404);
        }
        return $entityInstance;
    }
645403
public function getUFIdByCode($entity, $code)
    {
        if (!$entity) {
            throw new MigrationException('Не задана сущность свойства');
        }

        if (!$code) {
            throw new MigrationException('Не задан код свойства');
        }

        $filter = [
            'ENTITY_ID'  => $entity,
            'FIELD_NAME' => $code,
        ];

        $arField = CUserTypeEntity::GetList(['ID' => 'ASC'], $filter)->fetch();
        if (!$arField || !$arField['ID']) {
            throw new MigrationException("Не найдено свойство с FIELD_NAME = {$filter['FIELD_NAME']} и ENTITY_ID = {$filter['ENTITY_ID']}");
        }

        return $arField['ID'];
    }
396000
public function getDataMapperForEntity($entityClass)
    {
        Assertion::keyIsset($this->entityDataMapperMap, $entityClass, sprintf(
            "Could not find data mapper service name for entity class '%s'",
            $entityClass
        ));

        $entityDMServiceName = $this->entityDataMapperMap[$entityClass];

        $dataMapper = $this->get($entityDMServiceName);

        if (! is_a($dataMapper->getEntityClass(), $entityClass, true)) {
            throw new Exception\RuntimeException(sprintf(
                '"%s" entity class mismatch: expected "%s", got "%s"',
                $entityDMServiceName,
                $entityClass,
                $dataMapper->getEntityClass()
            ));
        }

        return $dataMapper;
    }
755194
protected function getEventName($eventCode)
    {
        $event = '(unknown event)';

        switch ($eventCode) {
            case Event::RESOURCE_DELETED:
                $event = 'deleted';
                break;
            case Event::RESOURCE_CREATED:
                $event = 'created';
                break;
            case Event::RESOURCE_MODIFIED:
                $event = 'modified';
                break;
        }

        return $event;
    }
1149375
protected function getDevelopmentEnvironmentContent(Exception $ex, int $statusCode) : string
    {
        ob_start();

        if ($statusCode === 503) {
            require __DIR__ . "/templates/{$this->getRequestFormat()}/MaintenanceMode.php";
        } else {
            require __DIR__ . "/templates/{$this->getRequestFormat()}/DevelopmentException.php";
        }

        return ob_get_clean();
    }
1259848
public function getPath($languageCode)
    {
        $route = $this->routes()->newQuery()
            ->where('language_code', $languageCode)
            ->first();
        if (empty($route->path)) {
            throw new DomainException("There is no route in '$languageCode' language for content: $this->id");
        }
        return $route->path;
    }
1207777
private function getContext($contextCode)
    {
        if (empty($contextCode)) {
            $contextCode = ContextInterface::DEFAULT_CONTEXT;
        }

        if ($contextCode instanceof ContextInterface) {
            return $contextCode;
        }

        $context = $this->contextManager->find($contextCode);

        if (!$context instanceof ContextInterface) {
            $context = $this->contextManager->create();

            $context->setId($contextCode);
            $context->setName($contextCode);
            $context->setEnabled(true);

            $this->contextManager->save($context);
        }

        return $context;
    }
523190
public static function getTypeForCode( $typeCode )
	{
		return isset( XmlTypeCode::$codeToTypeMap[ $typeCode ] )
			? XmlTypeCode::$codeToTypeMap[ $typeCode ]
			: false;
	}
45850
public function getLanguageName(string $languageCode): string
    {
        $posixLanguageCode = $this->localeConverter->convertToPOSIX($languageCode);
        if ($posixLanguageCode === null) {
            return '';
        }

        $posixLanguageCode = mb_substr($posixLanguageCode, 0, 2);
        $languageName = Intl::getLanguageBundle()->getLanguageName($posixLanguageCode, null, $posixLanguageCode);

        return ucwords($languageName);
    }
1351575
public function getName(string $code): string
    {
        $result = $code;

        if (empty($code)) {
            throw new InvalidArgumentException("Code must be a non-empty string.");
        }

        $languages = $this->getSupported();
        if (!empty($languages[$code])) {
            $result = $languages[$code];
        }

        return $result;
    }
236979
public function getEntityType()
    {

        // query whether or not the entity type with the passed code is available
        if (isset($this->entityTypes[$entityTypeCode = $this->getEntityTypeCode()])) {
            return $this->entityTypes[$entityTypeCode];
        }

        // throw a new exception
        throw new \Exception(
            $this->appendExceptionSuffix(
                sprintf('Requested entity type "%s" is not available', $entityTypeCode)
            )
        );
    }
590106
public function getData4CodeType($code, $type)
    {
        $query = $this->createQueryBuilder('p')
            ->select('p')
            ->where('p.code = :code')
            ->setParameter('code', $code)
            ->andWhere('p.expire >= :expire')
            ->setParameter('expire', new \DateTime())
            ->andWhere('p.type = :type')
            ->setParameter('type', $type)
            ->getQuery();

        return $query->getOneOrNullResult();
    }
526229
public function getLanguage($languageCode = null): ?string
    {
        $languageCode = $languageCode ? mb_strtoupper($languageCode) : null;

        return $this->get("languages.{$languageCode}") ?: (current($this->get('languages', [])) ?: null);
    }
569375
public function getEntityNamespace()
    {
        $namespace = '';
        if (($bundleNamespace = $this->parseComment('bundleNamespace')) || ($bundleNamespace = $this->getConfig()->get(Formatter::CFG_BUNDLE_NAMESPACE))) {
            $namespace = $bundleNamespace.'\\';
        }
        if ($entityNamespace = $this->getConfig()->get(Formatter::CFG_ENTITY_NAMESPACE)) {
            $namespace .= $entityNamespace;
        } else {
            $namespace .= 'Entity';
        }

        return $namespace;
    }