Lookup channel key value based on channel name.

@param string $channelName The name of the channel.

@return string $channelKey A key value based on the channel name.
349111
private function lookupChannelKey($channelName)
  {

    if ($channelName == '#niche_monitoring') {
      $channelKey = $this->slackConfig['webhookURL_niche_monitoring'];
    } elseif ($channelName == '#after-school-internal') {
      $channelKey = $this->slackConfig['webhookURL_after-school-internal'];
    } else {
      $channelKey = $this->slackConfig['webhookURL_message-broker'];
    }

    return $channelKey;
  }
521752
public function get(CacheKey $key) {

		if (!empty($this->elements[$key->getModule()] [$key->getProperty()])) {
            /** @noinspection PhpUndefinedMethodInspection */
            $tValue = $this->elements[$key->getModule()] [$key->getProperty()]->getValue ();
			return $tValue;
		} else {
			return false;
		}
	}
1212731
protected function getChannels($channels)
    {
        $channels = trim($channels);

        if (empty($channels)) {
            throw new InvalidArgumentException('No channel found.');
        }

        return $channels === '*' ? [] : explode(',', $channels);
    }
392435
public function normalizeChannelName($channel)
    {
        if ($this->isGuardedChannel($channel)) {
            return Str::startsWith($channel, 'private-')
                ? Str::replaceFirst('private-', '', $channel)
                : Str::replaceFirst('presence-', '', $channel);
        }

        return $channel;
    }
766655
public function getChannel($s_channelName) {

		if (!array_key_exists($s_channelName, $this->aI_channels)) {
			throw new \UnexpectedValueException('Channel ' . $s_channelName . ' does not exist');
		}

		return $this->aI_channels[$s_channelName];
	}
642204
public function getHeader($keyName)
    {
        $headers = $this->getHeaders();
        $keyName = self::normalizeHeaderKeyName($keyName);
        if (array_key_exists($keyName, $headers)) {
            return $headers[$keyName];
        }

        return;
    }
1366337
protected static function get_hold_channels($channels)
    {
        $ichannels = array();
        foreach ($channels as $channel) {
            if (is_string($channel)) {
                $channel = new Channel($channel);
            }
            $ichannel = array();
            $ichannel['name'] = $channel->name;
            if (!is_null($channel->prev_id)) {
                $ichannel['prev-id'] = $channel->prev_id;
            }
            $ichannels[] = $ichannel;
        }
        return $ichannels;
    }
1011102
public function get( $propertyName ) {
			
			if ( self::isProperty( $propertyName ) ) {
				
				return array_key_exists( $propertyName, $this->properties )
					? $this->properties[ $propertyName ]
					: null;

			} else {
			
				throw new \browserfs\Exception('Invalid argument: $propertyName: value cannot be a key!' );
			
			}
		}
475253
public function &getChannel($channelname)
    {
        $err = null;

        if (!$this->_channelsyncing) {
            $this->log(SMARTIRC_DEBUG_NOTICE,
                'WARNING: getChannel() is called and the required Channel '
                .'Syncing is not activated!', __FILE__, __LINE__
            );
            return $err;
        }

        if (!isset($this->_channels[strtolower($channelname)])) {
            $this->log(SMARTIRC_DEBUG_NOTICE,
                'WARNING: getChannel() is called and the required channel '
                .$channelname.' has not been joined!', __FILE__, __LINE__
            );
            return $err;
        }

        return $this->_channels[strtolower($channelname)];
    }
1101634
public function find($storageName, $key)
    {
        $qb = $this->conn->createQueryBuilder();

        $qb->select('s.' . $this->dataColumn)
            ->from($this->table, 's')
            ->where($this->keyColumn . ' = ?')
            ->setParameters([$key]);

        $stmt = $qb->execute();

        $data = $stmt->fetchColumn();

        if (! $data) {
            throw new NotFoundException();
        }

        return unserialize($data);
    }
417013
public static function getCountryCode($countryName)
    {
        foreach (self::$countries as $key => $value) {
            if (!strcasecmp($value, $countryName)) {
                return $key;
            }
        }
        return '';
    }
477973
public function &getUser($channelname, $username)
    {
        if (!$this->_channelsyncing) {
            $this->log(SMARTIRC_DEBUG_NOTICE, 'WARNING: getUser() is called and'
                .' the required Channel Syncing is not activated!',
                __FILE__, __LINE__
            );
            return;
        }

        if ($this->isJoined($channelname, $username)) {
            return $this->getChannel($channelname)->users[strtolower($username)];
        }
    }
1216512
public function addChannel($channel, $key = null)
    {
        $channel = strtolower($channel);
        $this->channels[$channel] = $key;
        return $this;
    }
1172942
public function channel($channel = null)
    {
        // If the given driver has not been created before, we will create the instances
        // here and cache it so we can return it next time very quickly. If there is
        // already a driver created by this name, we'll just return that instance.
        if (!$this->hasChannel($channel)) {
            $this->addChannel($channel, $this->createChannel($channel));
        }

        return $this->getChannel($channel);
    }
129262
public function getChannel($message)
    {
        if (is_int($message)) {
            return $this->channels[$message];
        }
        return $this->channels[$message->getChannel()];
    }
1354993
public static function getDbFieldName($propertyName)
    {
        if (!isset(self::$cachedDbFieldNames[$propertyName])) {
            self::$cachedDbFieldNames[$propertyName] = Str::camelToSeparator($propertyName);
        }

        return self::$cachedDbFieldNames[$propertyName];
    }
376063
public function offsetGet( $key )
    {
        $key = strtolower( $key );
        if ( !array_key_exists( $key, $this->lookup ) )
        {
            return null;
        }
        return $this->map[$this->lookup[$key]];
    }