Fetches the ids of the rooms with the given names
487161
def fetch_room_ids(self, names):
        
        ret = dict()
        names_set = frozenset(names)
        for d in json.loads(self.open_url(
                            'timetables?type=location'))['timetable']:
            name = d['hostKey']
            if name in names_set:
                ret[name] = d['value'].encode('utf-8')
        return ret
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
101644
def users(&callback)
      connection.http(:get, "/room/#{id}.json") do |data, http| # data can be blank on locked rooms
        callback.call(data ? data[:room][:users].map { |user| Firering::User.instantiate(connection, user) } : Array.new) if callback
      end
    end
291048
async def get_room(self, room_id, from_cache=True) -> Room:
        
        if not from_cache:
            await self.get_rooms()
        for _room in self.rooms:
            if _room.id == room_id:
                return _room
        raise ResourceNotFoundException("Room not found. Id: {}".format(room_id))
292848
def rooms(status=None):
    """"""

    room_query = VCRoom.find(type='vidyo')
    table_data = [['ID', 'Name', 'Status', 'Vidyo ID', 'Extension']]

    if status:
        room_query = room_query.filter(VCRoom.status == VCRoomStatus.get(status))

    for room in room_query:
        table_data.append([unicode(room.id), room.name, room.status.name,
                           unicode(room.data['vidyo_id']), unicode(room.vidyo_extension.extension)])

    table = AsciiTable(table_data)
    for col in (0, 3, 4):
        table.justify_columns[col] = 'right'
    print table.table
227888
def refresh_rooms(self):
        """"""
        for room_id in self.user_api.get_joined_rooms()["joined_rooms"]:
            self._rooms[room_id] = MatrixRoom(room_id, self.user_api)
677881
def get_names(cs):
    """"""
    records = []
    for c in cs:
        records.extend(c.get('names', []))
    return records
960056
def get_private_rooms(self, **kwargs):
        
        return GetPrivateRooms(settings=self.settings, **kwargs).call(**kwargs)
1321108
function getIdColumns(idColumnNames, columns) {
  if (!defined(idColumnNames)) {
    return [];
  }
  return idColumnNames.map(name => getColumnWithNameIdOrIndex(name, columns));
}
353727
def list(self, teamId=None, rType=None, maxResults=C.MAX_RESULT_DEFAULT, limit=C.ALL):
    
    queryParams = {'teamId': teamId,
            'type': rType,
            'max': maxResults}
    queryParams = self.clean_query_Dict(queryParams)
    ret = self.send_request(C.GET, self.end, data=queryParams, limit=limit)
    return [Room(self.token, roomData) for roomData in ret['items']]
222368
def get_room_id(self, room_alias):
        
        content = self._send("GET", "/directory/room/{}".format(quote(room_alias)))
        return content.get("room_id", None)
111829
function( roomID, key ) {

		return this.getRoomIdForKey( key )
		.then( function( savedRoomId ) {

			if( savedRoomId == roomID ) {

				delete idToKey[ roomID ];
				delete keyToId[ key ];

				keys.push( key );

				return promise.resolve();
			} else {

				return promise.reject( 'roomID and roomID for key do not match' );
			}
		});
	}
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
225486
def get_true_rooms(self):
        """"""

        rooms = self.rooms.all()
        if len(rooms) > 0:
            return rooms
        else:
            return self.activity.rooms.all()
286868
def ids(self):
        
        if self._ids is None:
            if self._columns:
                if isinstance(self._columns, OrderedDict):
                    return [list(self._columns.keys())[0]]
                return [self._columns[0]]
        else:
            return self._ids
1278663
def get_private_room_info(self, room_id, **kwargs):
        
        return GetPrivateRoomInfo(settings=self.settings, **kwargs).call(
            room_id=room_id,
            **kwargs
        )
973015
def room_file(room_id, file_id, params = {})
      unless (value = params[:create_download_url]).nil?
        params[:create_download_url] = boolean_to_integer(value)
      end
      get("rooms/#{room_id}/files/#{file_id}", params)
    end