Get find and exclude configuration values for exclude_location_map.

@return array
Array of nids.
541085
protected function getExcludeLocationMapIds() {
    $config = $this->configFactory->get('openy_programs_search.settings');
    $exclude_location_map = $config->get('exclude_location_map');

    return is_array($exclude_location_map) ? $exclude_location_map : [];
  }
844069
protected function getAdditionAdapterOptions()
    {
        /** @var \common_ext_ExtensionsManager $extManager */
        $extManager = ServiceManager::getServiceManager()->get(\common_ext_ExtensionsManager::SERVICE_ID);
        $taoTestTaker = $extManager->getExtensionById('taoTestTaker');
        $config = $taoTestTaker->getConfig('csvImporterCallbacks');

        if (empty($config['callbacks'])){
            $returnValue = array(
                'callbacks' => array(
                    '*' => array('trim'),
                    GenerisRdf::PROPERTY_USER_PASSWORD => array('oat\taoTestTaker\models\CsvImporter::taoSubjectsPasswordEncode')
                )
            );
        } else {
            $returnValue = array(
                'callbacks' => $config['callbacks']
            );
        }

        return $returnValue;
    }
533515
public function findGeneralConfiguration(): array
    {
        /** @var array[] $configurationSets */
        $configurationSets = [[]];

        $modules = $this->packageRepository->findModules();
        foreach ($modules as $module) {
            $extra = $module->getExtra();
            $this->validateGeneralConfigurationSectionInExtra($extra);
            if (!isset($extra['phplist/core']['configuration'])) {
                continue;
            }

            $configurationSets[] = $extra['phplist/core']['configuration'];
        }

        return /** @scrutinizer ignore-call */ array_replace_recursive(...$configurationSets);
    }
164063
private function getOrganizeMigrationsModes() : array
    {
        $constPrefix = 'VERSIONS_ORGANIZATION_';
        $prefixLen   = strlen($constPrefix);
        $refClass    = new ReflectionClass('Doctrine\Migrations\Configuration\Configuration');
        $constsArray = $refClass->getConstants();
        $namesArray  = [];

        foreach ($constsArray as $key => $value) {
            if (strpos($key, $constPrefix) !== 0) {
                continue;
            }

            $namesArray[] = substr($key, $prefixLen);
        }

        return $namesArray;
    }
404590
public function getDirectories()
    {

        // initialize the array with the directories
        $directories = array();

        // iterate over the directory keys and read the configuration values
        foreach (DirectoryKeys::getServerDirectoryKeys() as $directoryKey) {
            $directories[$directoryKey] = $this->getSystemConfiguration()->getParam($directoryKey);
        }

        // return the array with the directories
        return $directories;
    }
186124
public function getMap()
    {
        $result = [];

        foreach ($this->getConstants() as $dbName => $dbValue) {
            if (0 === strpos($dbName, self::PREFIX_DB)) {
                $result[$dbValue] = $this->getAppropriateConstValue(self::PREFIX_DB, $dbName);
            }
        }

        return $result;
    }
229126
protected static function getLocalConfigValues()
    {
        $root = self::projectRoot();
        $path = "{$root}/project-x.local.yml";

        if (!file_exists($path)) {
            return [];
        }

        $instance = ProjectXConfig::createFromFile(
            new \SplFileInfo($path)
        );

        return array_filter($instance->toArray());
    }
59666
public function getConfig()
    {
        return [
            'validators' => [
                'aliases'   => [
                    'consonant'            => Consonant::class,
                    'Consonant'            => Consonant::class,
                    'dateage'              => DateAge::class,
                    'dateAge'              => DateAge::class,
                    'DateAge'              => DateAge::class,
                    'ein'                  => Ein::class,
                    'Ein'                  => Ein::class,
                    'foldername'           => FolderName::class,
                    'folderName'           => FolderName::class,
                    'FolderName'           => FolderName::class,
                    'iataairlinecode'      => IataAirlineCode::class,
                    'iataAirlineCode'      => IataAirlineCode::class,
                    'IataAirlineCode'      => IataAirlineCode::class,
                    'iban'                 => Iban::class,
                    'Iban'                 => Iban::class,
                    'integer'              => Integer::class,
                    'Integer'              => Integer::class,
                    'luhn'                 => Luhn::class,
                    'Luhn'                 => Luhn::class,
                    'notinarray'           => NotInArray::class,
                    'notInArray'           => NotInArray::class,
                    'NotInArray'           => NotInArray::class,
                    'nowhitespace'         => NoWhitespace::class,
                    'noWhitespace'         => NoWhitespace::class,
                    'NoWhitespace'         => NoWhitespace::class,
                    'number'               => Number::class,
                    'Number'               => Number::class,
                    'password'             => Password::class,
                    'Password'             => Password::class,
                    'postcode'             => PostCode::class,
                    'postCode'             => PostCode::class,
                    'PostCode'             => PostCode::class,
                    'routingtransitnumber' => RoutingTransitNumber::class,
                    'routingTransitNumber' => RoutingTransitNumber::class,
                    'RoutingTransitNumber' => RoutingTransitNumber::class,
                    'ssn'                  => Ssn::class,
                    'Ssn'                  => Ssn::class,
                    'swift'                => Swift::class,
                    'Swift'                => Swift::class,
                    'username'             => Username::class,
                    'Username'             => Username::class,
                    'vatiN'                => VatIN::class,
                    'vatIN'                => VatIN::class,
                    'VatIN'                => VatIN::class,
                    'filecrc32'            => File\Crc32::class,
                    'fileCrc32'            => File\Crc32::class,
                    'FileCrc32'            => File\Crc32::class,
                    'filename'             => File\FileName::class,
                    'fileName'             => File\FileName::class,
                    'FileName'             => File\FileName::class,
                    'fileimagesize'        => File\ImageSize::class,
                    'fileImageSize'        => File\ImageSize::class,
                    'FileImageSize'        => File\ImageSize::class,
                    'fileiscompressed'     => File\IsCompressed::class,
                    'fileIsCompressed'     => File\IsCompressed::class,
                    'FileIsCompressed'     => File\IsCompressed::class,
                    'fileisimage'          => File\IsImage::class,
                    'fileIsImage'          => File\IsImage::class,
                    'FileIsImage'          => File\IsImage::class,
                    'filemd5'              => File\Md5::class,
                    'fileMd5'              => File\Md5::class,
                    'FileMd5'              => File\Md5::class,
                    'filemimetype'         => File\MimeType::class,
                    'fileMimeType'         => File\MimeType::class,
                    'FileMimeType'         => File\MimeType::class,
                    'filesha1'             => File\Sha1::class,
                    'fileSha1'             => File\Sha1::class,
                    'FileSha1'             => File\Sha1::class,
                    'filesize'             => File\Size::class,
                    'fileSize'             => File\Size::class,
                    'FileSize'             => File\Size::class,
                    'filewordcount'        => File\WordCount::class,
                    'fileWordCount'        => File\WordCount::class,
                    'FileWordCount'        => File\WordCount::class
                ],
                'factories' => [
                    Consonant::class            => InvokableFactory::class,
                    DateAge::class              => InvokableFactory::class,
                    Ein::class                  => InvokableFactory::class,
                    FolderName::class           => InvokableFactory::class,
                    IataAirlineCode::class      => InvokableFactory::class,
                    Iban::class                 => InvokableFactory::class,
                    Integer::class              => InvokableFactory::class,
                    Luhn::class                 => InvokableFactory::class,
                    NotInArray::class           => InvokableFactory::class,
                    NoWhitespace::class         => InvokableFactory::class,
                    Password::class             => InvokableFactory::class,
                    RoutingTransitNumber::class => InvokableFactory::class,
                    Ssn::class                  => InvokableFactory::class,
                    Swift::class                => InvokableFactory::class,
                    Username::class             => InvokableFactory::class,
                    VatIN::class                => InvokableFactory::class,
                    File\Crc32::class           => InvokableFactory::class,
                    File\FileName::class        => InvokableFactory::class,
                    File\ImageSize::class       => InvokableFactory::class,
                    File\IsCompressed::class    => InvokableFactory::class,
                    File\IsImage::class         => InvokableFactory::class,
                    File\Md5::class             => InvokableFactory::class,
                    File\MimeType::class        => InvokableFactory::class,
                    File\Sha1::class            => InvokableFactory::class,
                    File\Size::class            => InvokableFactory::class,
                    File\WordCount::class       => InvokableFactory::class
                ]
            ]
        ];
    }
435093
protected function getDefaultConfigSettings() : array
    {
        $arResult = [
            'tab'   => 'lovata.toolbox::lang.tab.properties',
            'span'  => 'left',
            'label' => $this->name,
            'comment' => $this->description,
        ];

        //Get property tab
        $sTabName = $this->getSettingValue('tab');
        if (!empty($sTabName)) {
            $arResult['tab'] = $sTabName;
        }

        return $arResult;
    }
4938
protected function getDisabledCommands() {
    $disabled_commands_config = $this->getConfigValue('disable-targets');
    if ($disabled_commands_config) {
      $disabled_commands = ArrayManipulator::flattenMultidimensionalArray($disabled_commands_config, ':');
      return $disabled_commands;
    }
    return [];
  }
132549
public function getConfig() {
        return [
            'payment' => [
                self::CODE => [
                    'isActive'                  => $this->config->isActive(),
                    'debug_mode'                => $this->config->isDebugMode(),
                    'public_key'                => $this->config->getPublicKey(),
                    'hosted_url'                => $this->config->getHostedUrl(),
                    'embedded_url'              => $this->config->getEmbeddedUrl(),
                    'countrySpecificCardTypes'  => $this->config->getCountrySpecificCardTypeConfig(),
                    'availableCardTypes'        => $this->config->getAvailableCardTypes(),
                    'useCvv'                    => $this->config->isCvvEnabled(),
                    'ccTypesMapper'             => $this->config->getCcTypesMapper(),
                    'ccVaultCode'               => self::CC_VAULT_CODE,
                    Config::CODE_3DSECURE       => [
                        'enabled' => $this->config->isVerify3DSecure(),
                    ],
                    'attemptN3D' => $this->config->isAttemptN3D(),
                    'integration'               => [
                        'type'          => $this->config->getIntegration(),
                        'isHosted'      => $this->config->isHostedIntegration(),
                    ],
                    'priceAdapter' => ChargeAmountAdapter::getConfigArray(),
                    'design_settings' => $this->config->getDesignSettings(),
                    'accepted_currencies' => $this->config->getAcceptedCurrencies(),
                    'payment_mode' => $this->config->getPaymentMode(),
                    'quote_value' => $this->getQuoteValue(),
                    'quote_currency' => $this->getQuoteCurrency(),
                    'embedded_theme' => $this->config->getEmbeddedTheme(),
                    'embedded_css' => $this->config->getEmbeddedCss(),
                    'css_file' => $this->config->getCssFile(),
                    'custom_css' => $this->config->getCustomCss(),
                    'vault_title' => $this->config->getVaultTitle(),
                    'order_creation' => $this->config->getOrderCreation(),
                    'card_autosave' => $this->config->isCardAutosave(),
                    'integration_language' => $this->config->getIntegrationLanguage()
                ],

                self::CODE_APPLE_PAY => [
                    'isActive' => $this->config->isActiveApplePay(),
                    'debugMode' => $this->config->getApplePayDebugMode(),
                    'processingCertificate' => $this->config->getApplePayProcessingCertificate(),
                    'processingCertificatePassword' => $this->config->getApplePayProcessingCertificatePassword(),
                    'merchantIdCertificate' => $this->config->getApplePayMerchantIdCertificate(),
                    'merchantId' => $this->config->getApplePayMerchantId(),
                    'buttonStyle' => $this->config->getApplePayButtonStyle(),
                    'storeName' => $this->config->getStoreName(),
                    'title' => $this->config->getApplePayTitle(),
                    'supportedNetworks' => $this->config->getApplePaySupportedNetworks(),
                    'merchantCapabilities' => $this->config->getApplePayMerchantCapabilities(),
                    'supportedCountries' => $this->config->getApplePaySupportedCountries()
                ],

                self::CODE_GOOGLE_PAY => [
                    'isActive' => $this->config->isActiveGooglePay(),
                    'debugMode' => $this->config->getGooglePayDebugMode(),
                    'title' => $this->config->getGooglePayTitle(),
                    'allowedNetworks' => $this->config->getGooglePayAllowedNetworks(),
                    'gatewayName' => $this->config->getGooglePayGatewayName(),
                    'merchantId' => $this->config->getGooglePayMerchantId(),
                    'environment' => $this->config->getGooglePayEnvironment(),
                    'buttonStyle' => $this->config->getGooglePayButtonStyle()
                ],
            ],
        ];
    }
1199174
protected function _getConfigSet() : array
    {

        if (empty($_SERVER) && empty($GLOBALS['argv'])) {
            return [];
        }

        return $this->sortConfigSet(
            $this->getConfigSet(),
            $this->get(self::HIERARCHY_PLACEHOLDER_INDEX)
        );

    }
791073
public function getConfig()
    {
        return [
            'cluster' => Config::get('database.redis.cluster'),
            'default' => [
                'host' => $this->HAClient->getIpAddress(),
                'port' => $this->HAClient->getPort(),
                'password' => Config::get('database.redis.password', null),
                'database' => Config::get('database.redis.database', 0),
            ]
        ];
    }
848020
private function getAllConfigFiles()
        {
            $finded = Finder::create()->files()->name('*.php')->in($this->getConfigPath());
            $files = [];
            foreach ($finded as $find) {
                if ($find instanceof SplFileInfo) {
                    $files[explode('.', $find->getFilename())[0]] = $find->getRealPath();
                }
            }

            return $files;
        }
304360
protected function getMapLocationsPrograms() {
    $map = [];

    $cid = __METHOD__;
    if ($cache = $this->cache->get($cid)) {
      return $cache->data;
    }

    $programs = $this->getAllChildCarePrograms();
    foreach ($programs as $program) {
      $locations = $this->getLocationsByChildCareProgramId($program->id);
      foreach ($locations as $lid) {
        $map[$lid][$program->id] = $program->id;
      }
    }

    $this->cache->set($cid, $map);
    return $map;
  }
463167
protected function getMapsOptions()
    {
        return [
            'dragndrop'     => Translate::t('map.options.dragndrop', [], 'mapfield'),
            'streetview'    => Translate::t('map.options.streetview', [], 'mapfield'),
            'zoomcontrol'   => Translate::t('map.options.zoomcontrol', [], 'mapfield'),

            'mapcontrol'    => Translate::t('map.options.mapcontrol', [], 'mapfield'),
            'scalecontrol'  => Translate::t('map.options.scalecontrol', [], 'mapfield'),
            'pancontrol'    => Translate::t('map.options.pancontrol', [], 'mapfield'),

            'rotatecontrol'         => Translate::t('map.options.rotatecontrol', [], 'mapfield'),
            'rotatecontroloptions'  => Translate::t('map.options.rotatecontroloptions', [], 'mapfield'),
            'scrollwheel'           => Translate::t('map.options.scrollwheel', [], 'mapfield'),

            'overviewmapcontrol'        => Translate::t('map.options.overviewmapcontrol', [], 'mapfield'),
            'overviewmapcontroloptions' => Translate::t('map.options.overviewmapcontroloptions', [], 'mapfield'),
        ];
    }
549760
protected function getMapRateOptions() {
    $map = [];

    $cid = __METHOD__;
    if ($cache = $this->cache->get($cid)) {
      return $cache->data;
    }

    $domain = $this->getUrlFromOpenyProgramsSearchSettings('base_url');

    // Here we'll iterate over each program and scrape data for each school.
    // We should be careful in order not to make a high load on Daxko.
    $programs = $this->getAllChildCarePrograms();
    foreach ($programs as $program) {
      // Get a list of schools for particular program.
      $schools = $this->scrapeDaxkoSchoolsByProgram($program->id);

      // @todo Check whether we were scraping correct page (with schools).
      $school_pages = $schools->each(function ($school) {
        $href = $school->attr('href');
        return [
          'url' => $href,
          'id' => $this->getQueryParam('location_id', $href),
        ];
      });

      // Scrape each school page to get the rates url.
      foreach ($school_pages as $school_page) {
        $url = $domain . $school_page['url'];
        $source = $this->getDaxkoPageSource($url);
        $this->crawler->clear();
        $this->crawler->addHtmlContent($source);
        $rate_list = $this->crawler->filter('#session-list-table tr.childcare-rate');

        // Scrape each rate item.
        $rate_data = $rate_list->each(function ($rate_data_item) {
          // Get context ID && session name.
          $link = $rate_data_item->filter('a.session-name');
          return [
            'context_id' => $this->getQueryParam('context_id', $link->attr('href')),
            'name' => $link->text(),
            'registration_url' => $link->attr('href'),
          ];
        });

        // Fill in map dada.
        if (!isset($map[$school_page['id']][$program->id])) {
          $map[$school_page['id']][$program->id] = [];
        }

        foreach ($rate_data as $rate_data_item) {
          $map[$school_page['id']][$program->id][$rate_data_item['context_id']] = $rate_data_item;
        }
      }
    }

    $this->cache->set($cid, $map);
    return $map;
  }