Get various information about a specific channel/room

        :param room_id:
        :param kwargs:
        :return:
547152
def get_room_info(self, room_id, **kwargs):
        
        return GetRoomInfo(settings=self.settings, **kwargs).call(
            room_id=room_id,
            **kwargs
        )
750611
public static channel get(nitro_service service, String id) throws Exception{
		channel obj = new channel();
		obj.set_id(id);
		channel response = (channel) obj.get_resource(service);
		return response;
	}
397678
def get_channel_by_channel_id(self, channel_id):
        
        self._validate_uuid(channel_id)

        url = "/notification/v1/channel/{}".format(channel_id)

        response = NWS_DAO().getURL(url, self._read_headers)

        if response.status != 200:
            raise DataFailureException(url, response.status, response.data)

        data = json.loads(response.data)
        return self._channel_from_json(data.get("Channel"))
998511
def set_room_alias(self, room_id, room_alias):
        
        data = {
            "room_id": room_id
        }

        return self._send("PUT", "/directory/room/{}".format(quote(room_alias)),
                          content=data)
380766
def channels_archive(self, room_id, **kwargs):
        """"""
        return self.__call_api_post('channels.archive', roomId=room_id, kwargs=kwargs)
22860
def fetch_todays_schedule(self, rooms):
        
        room_ids = self.fetch_room_ids(rooms)
        inst_id = self.fetch_inst_id()
        ret = {}
        now = datetime.datetime.now()
        day = DAYS[now.isoweekday() - 1]
        for room_name in room_ids:
            ret[room_name] = []
            try:
                events = msgpack.unpack(urllib2.urlopen(
                    "%s/snapshot/head/%s/location/%s?format=msgpack" % (
                        self.url, inst_id, room_ids[room_name])))['events']
            except urllib2.HTTPError, e:
                raise RuusterError(e)
            for event in events:
                starttime = datetime.datetime.strptime(
                        event['starttime'], '%H:%M:%S').time()
                endtime = datetime.datetime.strptime(
                        event['endtime'], '%H:%M:%S').time()
                if event['day'] != day:
                    continue
                ok = False
                for period in event['eventperiods']:
                    startdate = datetime.datetime.strptime(
                            period['startdate'], '%Y-%m-%d %H:%M:%SZ').date()
                    enddate = datetime.datetime.strptime(
                            period['enddate'], '%Y-%m-%d %H:%M:%SZ').date()
                    if (startdate <= now.date() and now.date() <= enddate):
                        ok = True
                        break
                if not ok:
                    continue
                name = event['course']['name']
                if name == 'Reserveringen' and 'comment' in event:
                    name = event['comment']
                ret[room_name].append((starttime, endtime,
                        normalize_event_name(name)))
        return ret
772008
def list_rooms(api_key=None):
    '''
    
    '''
    if not api_key:
        api_key = _get_api_key()
    return salt.utils.slack.query(function='rooms',
                                  api_key=api_key,
                                  opts=__opts__)
77906
def channels_set_description(self, room_id, description, **kwargs):
        """"""
        return self.__call_api_post('channels.setDescription', roomId=room_id, description=description, kwargs=kwargs)
780317
def groups_history(self, room_id, **kwargs):
        """"""
        return self.__call_api_get('groups.history', roomId=room_id, kwargs=kwargs)
626270
def get_channel_info(self):
        
        self.assert_open()
        channel_info = self.handle[self.global_key + 'channel_id'].attrs.items()
        channel_info = {key: _clean(value) for key, value in channel_info}
        channel_info['channel_number'] = int(channel_info['channel_number'])
        return channel_info
355561
public function room($room_id)
    {
        $url          = $this->url.'chatrooms/'.$room_id;
        $option       = [];
        $access_token = $this->getToken();
        $header []    = 'Authorization: Bearer '.$access_token;

        return Http::postCurl($url, $option, $header, 'GET');
    }
963798
def channel_name_to_id(self, channel_name, force_lookup=False):
        
        if force_lookup or not self.channel_name_id_map:
            channels = self.channels_list()['channels']
            self.channel_name_id_map = {channel['name']: channel['id'] for channel in channels}
        channel = channel_name.startswith('#') and channel_name[1:] or channel_name
        return self.channel_name_id_map.get(channel)
1324930
def send_message(self, message, room_id, **kwargs):
        
        return SendMessage(settings=self.settings, **kwargs).call(
            message=message,
            room_id=room_id,
            **kwargs
        )
936009
def _retrieve_channel_id(email, profile='telemetry'):
    '''
    
    '''
    key = "telemetry.channels"
    auth = _auth(profile=profile)

    if key not in __context__:
        get_url = _get_telemetry_base(profile) + "/notification-channels?_type=EmailNotificationChannel"
        response = requests.get(get_url, headers=auth)

        if response.status_code == 200:
            cache_result = {}
            for index, alert in enumerate(response.json()):
                cache_result[alert.get('email')] = alert.get('_id', 'false')

            __context__[key] = cache_result

    return __context__[key].get(email, False)
120898
def hosts(self, **kwargs):
        
        kwargs['channelID'] = self.id
        return self.connection.listHosts(**kwargs)
132537
def room_members(self, stream_id):
        '''  '''
        req_hook = 'pod/v2/room/' + str(stream_id) + '/membership/list'
        req_args = None
        status_code, response = self.__rest__.GET_query(req_hook, req_args)
        self.logger.debug('%s: %s' % (status_code, response))
        return status_code, response
459769
def get_rooms(self, sid, namespace):
        """"""
        r = []
        try:
            for room_name, room in six.iteritems(self.rooms[namespace]):
                if room_name is not None and sid in room and room[sid]:
                    r.append(room_name)
        except KeyError:
            pass
        return r