From d850c35356c25b021664ec7e6366a390ea44e34c Mon Sep 17 00:00:00 2001 From: Matthew Bernhardt Date: Wed, 14 Feb 2024 11:50:41 -0500 Subject: [PATCH 1/2] Add support for geobox searches to GraphQL ** Why are these changes being introduced: * We have enabled searching via a bounding box within OpenSearch, and need to extend that support to GraphQL in order to make it possible in the UI. ** Relevant ticket(s): * https://mitlibraries.atlassian.net/browse/gdt-184 ** How does this address that need: * This defines a GeoboxType, with four fields: two latitude and two longitude values, each expressed as floats. ** Document any side effects to this change: * I've tried to write tests to indicate the edges of what is possible - for example showing that you get results back if you provide both a geodistance and geobox (even if they don't result in overlapping regions - it seems like bbox is used in that case). * Similarly, I've written a test showing that it is valid to search using either order of the longitude values, because both results are valid - and different - bounding boxes. (If the latitude orders are reversed, the application errors in a way that is not captured via a cassette) --- app/graphql/types/geobox_type.rb | 10 + app/graphql/types/query_type.rb | 13 +- .../controllers/graphql_controller_v2_test.rb | 182 +++++++ test/vcr_cassettes/graphqlv2_geobox.yml | 77 +++ .../graphqlv2_geobox_eastern_hemisphere.yml | 448 ++++++++++++++++++ .../graphqlv2_geobox_western_hemisphere.yml | 436 +++++++++++++++++ .../graphqlv2_geobox_with_geodistance.yml | 32 ++ .../graphqlv2_geobox_with_keyword.yml | 34 ++ 8 files changed, 1227 insertions(+), 5 deletions(-) create mode 100644 app/graphql/types/geobox_type.rb create mode 100644 test/vcr_cassettes/graphqlv2_geobox.yml create mode 100644 test/vcr_cassettes/graphqlv2_geobox_eastern_hemisphere.yml create mode 100644 test/vcr_cassettes/graphqlv2_geobox_western_hemisphere.yml create mode 100644 test/vcr_cassettes/graphqlv2_geobox_with_geodistance.yml create mode 100644 test/vcr_cassettes/graphqlv2_geobox_with_keyword.yml diff --git a/app/graphql/types/geobox_type.rb b/app/graphql/types/geobox_type.rb new file mode 100644 index 00000000..1ffa1ec9 --- /dev/null +++ b/app/graphql/types/geobox_type.rb @@ -0,0 +1,10 @@ +module Types + class GeoboxType < Types::BaseInputObject + description 'Search within a box specified by pairs of latitudes and longitudes. Their order should be left, ' \ + 'bottom, right, top' + argument :min_longitude, Float, description: 'A decimal between -180.0 and 180.0 (Western hemisphere is negative)' + argument :min_latitude, Float, description: 'A decimal between -90.0 and 90.0 (Southern hemisphere is negative)' + argument :max_longitude, Float, description: 'A decimal between -180.0 and 180.0 (Western hemisphere is negative)' + argument :max_latitude, Float, description: 'A decimal between -90.0 and 90.0 (Southern hemisphere is negative)' + end +end diff --git a/app/graphql/types/query_type.rb b/app/graphql/types/query_type.rb index beb7146b..10ca2d68 100644 --- a/app/graphql/types/query_type.rb +++ b/app/graphql/types/query_type.rb @@ -43,6 +43,8 @@ def record_id(id:, index:) 'award name, etc.' argument :geodistance, GeodistanceType, required: false, default_value: nil, description: 'Search within a certain distance of a specific location' + argument :geobox, GeoboxType, required: false, default_value: nil, + description: 'Search within a specified box' argument :identifiers, String, required: false, default_value: nil, description: 'Search by unique indentifier; e.g., ISBN, DOI, etc.' argument :locations, String, required: false, default_value: nil, description: 'Search by locations' @@ -79,9 +81,9 @@ def record_id(id:, index:) 'for a list of possible values' end - def search(searchterm:, citation:, contributors:, funding_information:, geodistance:, identifiers:, locations:, - subjects:, title:, index:, source:, from:, **filters) - query = construct_query(searchterm, citation, contributors, funding_information, geodistance, identifiers, + def search(searchterm:, citation:, contributors:, funding_information:, geodistance:, geobox:, identifiers:, + locations:, subjects:, title:, index:, source:, from:, **filters) + query = construct_query(searchterm, citation, contributors, funding_information, geodistance, geobox, identifiers, locations, subjects, title, source, filters) results = Opensearch.new.search(from, query, Timdex::OSClient, highlight_requested?, index) @@ -111,14 +113,15 @@ def inject_hits_fields_into_source(hits) modded_sources end - def construct_query(searchterm, citation, contributors, funding_information, geodistance, identifiers, locations, - subjects, title, source, filters) + def construct_query(searchterm, citation, contributors, funding_information, geodistance, geobox, identifiers, + locations, subjects, title, source, filters) query = {} query[:q] = searchterm query[:citation] = citation query[:contributors] = contributors query[:funding_information] = funding_information query[:geodistance] = geodistance + query[:geobox] = geobox query[:identifiers] = identifiers query[:locations] = locations query[:subjects] = subjects diff --git a/test/controllers/graphql_controller_v2_test.rb b/test/controllers/graphql_controller_v2_test.rb index b3aed558..585a45bd 100644 --- a/test/controllers/graphql_controller_v2_test.rb +++ b/test/controllers/graphql_controller_v2_test.rb @@ -252,6 +252,188 @@ def setup end end + test 'graphqlv2 geobox search alone' do + VCR.use_cassette('graphqlv2 geobox') do + post '/graphql', params: { query: '{ + search(geobox: { + minLongitude: -73.507, + minLatitude: 41.239, + maxLongitude: -69.928, + maxLatitude: 42.886 + }) { + hits + records { + title + locations { + geoshape + kind + value + } + } + } + }' } + assert_equal(200, response.status) + json = JSON.parse(response.body) + + assert_nil(json['errors']) + assert(json['data']['search']['hits'].positive?) + end + end + + test 'graphqlv2 geobox search required arguments' do + post '/graphql', params: { query: '{ + search(geobox: { + minLongitude: -73.507, + minLatitude: 41.239, + maxLongitude: -69.928, + }) { + hits + records { + title + locations { + geoshape + kind + value + } + } + } + }' } + assert_equal(200, response.status) + json = JSON.parse(response.body) + + assert(json['errors'].length.positive?) + assert_equal( + "Argument 'maxLatitude' on InputObject 'Geobox' is required. Expected type Float!", + json['errors'].first['message'] + ) + end + + test 'graphqlv2 geobox search longitude order matters' do + # This is fragile to our collection having an equal number of records in both hemispheres. + eastern_hits = 0 + western_hits = 0 + VCR.use_cassette('graphqlv2 geobox eastern hemisphere') do + post '/graphql', params: { query: '{ + search(geobox: { + minLongitude: 0, + minLatitude: -90, + maxLongitude: 180, + maxLatitude: 90 + }) { + hits + records { + title + locations { + geoshape + kind + value + } + } + } + }' } + assert_equal(200, response.status) + json = JSON.parse(response.body) + + assert_nil(json['errors']) + eastern_hits = json['data']['search']['hits'] + assert(eastern_hits.positive?) + end + VCR.use_cassette('graphqlv2 geobox western hemisphere') do + post '/graphql', params: { query: '{ + search(geobox: { + minLongitude: 180, + minLatitude: -90, + maxLongitude: 0, + maxLatitude: 90 + }) { + hits + records { + title + locations { + geoshape + kind + value + } + } + } + }' } + assert_equal(200, response.status) + json = JSON.parse(response.body) + + assert_nil(json['errors']) + western_hits = json['data']['search']['hits'] + assert(western_hits.positive?) + end + refute_equal(eastern_hits, western_hits) + end + + test 'graphqlv2 geobox search with keyword search' do + VCR.use_cassette('graphqlv2 geobox with keyword') do + post '/graphql', params: { query: '{ + search( + searchterm: "train stations", + geobox: { + minLongitude: -73.507, + minLatitude: 41.239, + maxLongitude: -69.928, + maxLatitude: 42.886 + } + ) { + hits + records { + title + locations { + geoshape + kind + value + } + } + } + }' } + assert_equal(200, response.status) + json = JSON.parse(response.body) + + assert_nil(json['errors']) + assert(json['data']['search']['hits'].positive?) + end + end + + test 'graphqlv2 geobox search with geodistance search' do + # Should this work? It does. + VCR.use_cassette('graphqlv2 geobox with geodistance') do + post '/graphql', params: { query: '{ + search( + geodistance: { + distance: "1km", + latitude: 0, + longitude: 0 + }, + geobox: { + minLongitude: -73.507, + minLatitude: 41.239, + maxLongitude: -69.928, + maxLatitude: 42.886 + } + ) { + hits + records { + title + locations { + geoshape + kind + value + } + } + } + }' } + assert_equal(200, response.status) + json = JSON.parse(response.body) + + assert_nil(json['errors']) + assert(json['data']['search']['hits'].positive?) + end + end + test 'graphqlv2 search aggregations' do VCR.use_cassette('graphql v2 search data') do post '/graphql', params: { query: '{ diff --git a/test/vcr_cassettes/graphqlv2_geobox.yml b/test/vcr_cassettes/graphqlv2_geobox.yml new file mode 100644 index 00000000..729b7e6f --- /dev/null +++ b/test/vcr_cassettes/graphqlv2_geobox.yml @@ -0,0 +1,77 @@ +--- +http_interactions: +- request: + method: get + uri: http://localhost:9200/ + body: + encoding: US-ASCII + string: '' + headers: + User-Agent: + - 'opensearch-ruby/3.1.0 (RUBY_VERSION: 3.2.2; darwin arm64; Faraday v2.9.0)' + Content-Type: + - application/json + Accept-Encoding: + - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 + Accept: + - "*/*" + response: + status: + code: 200 + message: OK + headers: + Content-Type: + - application/json; charset=UTF-8 + Content-Length: + - '567' + body: + encoding: ASCII-8BIT + string: | + { + "name" : "57e0dc0fc53d", + "cluster_name" : "docker-cluster", + "cluster_uuid" : "DoZb5LNrT7eUN8gEh-aLJg", + "version" : { + "distribution" : "opensearch", + "number" : "2.11.1", + "build_type" : "tar", + "build_hash" : "6b1986e964d440be9137eba1413015c31c5a7752", + "build_date" : "2023-11-29T21:45:35.524809067Z", + "build_snapshot" : false, + "lucene_version" : "9.7.0", + "minimum_wire_compatibility_version" : "7.10.0", + "minimum_index_compatibility_version" : "7.0.0" + }, + "tagline" : "The OpenSearch Project: https://opensearch.org/" + } + recorded_at: Wed, 14 Feb 2024 16:30:39 GMT +- request: + method: post + uri: http://localhost:9200/timdex-prod/_search + body: + encoding: UTF-8 + string: '{"from":"0","size":20,"query":{"bool":{"should":null,"must":[{"bool":{"must":{"match_all":{}},"filter":{"geo_bounding_box":{"locations.geoshape":{"top":42.886,"bottom":41.239,"left":-73.507,"right":-69.928}}}}}],"filter":[]}},"aggregations":{"contributors":{"nested":{"path":"contributors"},"aggs":{"contributor_names":{"terms":{"field":"contributors.value.keyword"}}}},"content_type":{"terms":{"field":"content_type"}},"content_format":{"terms":{"field":"format"}},"languages":{"terms":{"field":"languages.keyword"}},"literary_form":{"terms":{"field":"literary_form"}},"source":{"terms":{"field":"source"}},"subjects":{"nested":{"path":"subjects"},"aggs":{"subject_names":{"terms":{"field":"subjects.value.keyword"}}}}},"sort":[{"_score":{"order":"desc"}},{"dates.value.as_date":{"order":"desc","nested":{"path":"dates"}}}]}' + headers: + User-Agent: + - 'opensearch-ruby/3.1.0 (RUBY_VERSION: 3.2.2; darwin arm64; Faraday v2.9.0)' + Content-Type: + - application/json + Accept-Encoding: + - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 + Accept: + - "*/*" + response: + status: + code: 200 + message: OK + headers: + Content-Type: + - application/json; charset=UTF-8 + Content-Length: + - '57546' + body: + encoding: ASCII-8BIT + string: !binary |- + {"took":56,"timed_out":false,"_shards":{"total":1,"successful":1,"skipped":0,"failed":0},"hits":{"total":{"value":825,"relation":"eq"},"max_score":null,"hits":[{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:us_ma_boston_g47parcels_2018","_score":1.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:us_ma_boston_g47parcels_2018","timdex_record_id":"gismit:us_ma_boston_g47parcels_2018","title":"Boston, MA (Land parcels, 2018)","citation":"City of Boston Assessing Department. Boston, MA (Land parcels, 2018). GIS Lab, MIT Libraries. Geospatial data. https://search.libraries.mit.edu/record/gismit:us_ma_boston_g47parcels_2018","content_type":["Geospatial data"],"contributors":[{"value":"City of Boston Assessing Department","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2018-01-01"},{"kind":"Coverage","value":"2015-01-01"},{"kind":"Coverage","value":"2015"}],"format":"Vector","identifiers":[{"value":"us_ma_boston_g47parcels_2018","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/us_ma_boston_g47parcels_2018.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/us_ma_boston_g47parcels_2018.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/us_ma_boston_g47parcels_2018.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-71.190913, -70.868654, 42.397012, 42.227864)"},{"kind":"Geometry","geoshape":"BBOX (-71.190913, -70.868654, 42.397012, 42.227864)"}],"publication_information":["GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"N/A"}],"subjects":[{"value":["Economy"],"kind":"DCAT; Theme"},{"value":["Boundaries"],"kind":"DCAT; Theme"},{"value":["Location"],"kind":"DCAT; Theme"},{"value":["Massachusetts--Boston"],"kind":"Dublin Core; Spatial"},{"value":["Land use"],"kind":"Dublin Core; Subject"},{"value":["Neighborhoods"],"kind":"Dublin Core; Subject"},{"value":["Administrative and political divisions"],"kind":"Dublin Core; Subject"},{"value":["Land value taxation"],"kind":"Dublin Core; Subject"},{"value":["Land tenure"],"kind":"Dublin Core; Subject"},{"value":["economy"],"kind":"Dublin Core; Subject"},{"value":["planningCadastre"],"kind":"Dublin Core; Subject"},{"value":["boundaries"],"kind":"Dublin Core; Subject"},{"value":["location"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["G-polygon"],"kind":"Subject scheme not provided"}],"summary":["City of Boston property parcel data from FY 2018 was joined with parcel boundaries from FY 2018. All data is from the City of Boston Assessor's office and represents data from 2017."]},"sort":[1.0,1514764800000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:us_ma_boston_g47parcels_2017","_score":1.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:us_ma_boston_g47parcels_2017","timdex_record_id":"gismit:us_ma_boston_g47parcels_2017","title":"Boston, MA (Land parcels, 2017)","citation":"City of Boston Assessing Department. Boston, MA (Land parcels, 2017). GIS Lab, MIT Libraries. Geospatial data. https://search.libraries.mit.edu/record/gismit:us_ma_boston_g47parcels_2017","content_type":["Geospatial data"],"contributors":[{"value":"City of Boston Assessing Department","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2017-01-01"},{"kind":"Coverage","value":"2017-01-01"},{"kind":"Coverage","value":"2017"}],"format":"Vector","identifiers":[{"value":"us_ma_boston_g47parcels_2017","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/us_ma_boston_g47parcels_2017.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/us_ma_boston_g47parcels_2017.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/us_ma_boston_g47parcels_2017.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-71.190913, -70.923055, 42.397004, 42.227856)"},{"kind":"Geometry","geoshape":"BBOX (-71.190913, -70.923055, 42.397004, 42.227856)"}],"publication_information":["GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"N/A"}],"subjects":[{"value":["Economy"],"kind":"DCAT; Theme"},{"value":["Boundaries"],"kind":"DCAT; Theme"},{"value":["Location"],"kind":"DCAT; Theme"},{"value":["Massachusetts--Boston"],"kind":"Dublin Core; Spatial"},{"value":["Land use"],"kind":"Dublin Core; Subject"},{"value":["Neighborhoods"],"kind":"Dublin Core; Subject"},{"value":["Administrative and political divisions"],"kind":"Dublin Core; Subject"},{"value":["Land value taxation"],"kind":"Dublin Core; Subject"},{"value":["Land tenure"],"kind":"Dublin Core; Subject"},{"value":["economy"],"kind":"Dublin Core; Subject"},{"value":["planningCadastre"],"kind":"Dublin Core; Subject"},{"value":["boundaries"],"kind":"Dublin Core; Subject"},{"value":["location"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["G-polygon"],"kind":"Subject scheme not provided"}],"summary":["City of Boston property parcel data from FY 2017 was joined with parcel boundaries from FY 2017. All data is from the City of Boston Assessor's office and represents data from 2016."]},"sort":[1.0,1483228800000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:US_MA_BOSTON_G47PARCELS_2016","_score":1.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:US_MA_BOSTON_G47PARCELS_2016","timdex_record_id":"gismit:US_MA_BOSTON_G47PARCELS_2016","title":"Boston, MA (Land parcels, 2016)","citation":"City of Boston Assessing Department. Boston, MA (Land parcels, 2016). GIS Lab, MIT Libraries. Geospatial data. https://search.libraries.mit.edu/record/gismit:US_MA_BOSTON_G47PARCELS_2016","content_type":["Geospatial data"],"contributors":[{"value":"City of Boston Assessing Department","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2017-01-01"},{"kind":"Coverage","value":"2016-01-01"},{"kind":"Coverage","value":"2016"}],"format":"Vector","identifiers":[{"value":"us_ma_boston_g47parcels_2016","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/US_MA_BOSTON_G47PARCELS_2016.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/US_MA_BOSTON_G47PARCELS_2016.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/US_MA_BOSTON_G47PARCELS_2016.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-71.190913, -70.923055, 42.397004, 42.227856)"},{"kind":"Geometry","geoshape":"BBOX (-71.190913, -70.923055, 42.397004, 42.227856)"}],"publication_information":["GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"N/A"}],"subjects":[{"value":["Economy"],"kind":"DCAT; Theme"},{"value":["Boundaries"],"kind":"DCAT; Theme"},{"value":["Location"],"kind":"DCAT; Theme"},{"value":["Boston"],"kind":"Dublin Core; Spatial"},{"value":["USA"],"kind":"Dublin Core; Spatial"},{"value":["Massachusetts"],"kind":"Dublin Core; Spatial"},{"value":["MA"],"kind":"Dublin Core; Spatial"},{"value":["parcels"],"kind":"Dublin Core; Subject"},{"value":["land parcels"],"kind":"Dublin Core; Subject"},{"value":["land use"],"kind":"Dublin Core; Subject"},{"value":["wards"],"kind":"Dublin Core; Subject"},{"value":["polygon"],"kind":"Dublin Core; Subject"},{"value":["tax"],"kind":"Dublin Core; Subject"},{"value":["land ownership"],"kind":"Dublin Core; Subject"},{"value":["improvements"],"kind":"Dublin Core; Subject"},{"value":["neighborhoods"],"kind":"Dublin Core; Subject"},{"value":["lot size"],"kind":"Dublin Core; Subject"},{"value":["economy"],"kind":"Dublin Core; Subject"},{"value":["planningCadastre"],"kind":"Dublin Core; Subject"},{"value":["boundaries"],"kind":"Dublin Core; Subject"},{"value":["location"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["G-polygon"],"kind":"Subject scheme not provided"}],"summary":["City of Boston property parcel data from FY 2016 was joined with parcel boundaries from FY 2016. All data is from the City of Boston Assessor's office and represents data from 2015."]},"sort":[1.0,1483228800000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:US_MA_BOSTON_G47PARCELS_2015","_score":1.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:US_MA_BOSTON_G47PARCELS_2015","timdex_record_id":"gismit:US_MA_BOSTON_G47PARCELS_2015","title":"Boston, MA (Land parcels, 2015)","citation":"City of Boston Assessing Department. Boston, MA (Land parcels, 2015). City of Boston Assessing Department. Geospatial data. https://search.libraries.mit.edu/record/gismit:US_MA_BOSTON_G47PARCELS_2015","content_type":["Geospatial data"],"contributors":[{"value":"City of Boston Assessing Department","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2015-01-01"},{"kind":"Coverage","value":"2015-01-01"},{"kind":"Coverage","value":"2015"}],"format":"Vector","identifiers":[{"value":"us_ma_boston_g47parcels_2015","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/US_MA_BOSTON_G47PARCELS_2015.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/US_MA_BOSTON_G47PARCELS_2015.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/US_MA_BOSTON_G47PARCELS_2015.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-71.190913, -70.953184, 42.397012, 42.227864)"},{"kind":"Geometry","geoshape":"BBOX (-71.190913, -70.953184, 42.397012, 42.227864)"}],"publication_information":["City of Boston Assessing Department","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"N/A"}],"subjects":[{"value":["Economy"],"kind":"DCAT; Theme"},{"value":["Boundaries"],"kind":"DCAT; Theme"},{"value":["Location"],"kind":"DCAT; Theme"},{"value":["Boston"],"kind":"Dublin Core; Spatial"},{"value":["USA"],"kind":"Dublin Core; Spatial"},{"value":["Massachusetts"],"kind":"Dublin Core; Spatial"},{"value":["MA"],"kind":"Dublin Core; Spatial"},{"value":["parcels"],"kind":"Dublin Core; Subject"},{"value":["land parcels"],"kind":"Dublin Core; Subject"},{"value":["land use"],"kind":"Dublin Core; Subject"},{"value":["wards"],"kind":"Dublin Core; Subject"},{"value":["polygon"],"kind":"Dublin Core; Subject"},{"value":["tax"],"kind":"Dublin Core; Subject"},{"value":["land ownership"],"kind":"Dublin Core; Subject"},{"value":["improvements"],"kind":"Dublin Core; Subject"},{"value":["neighborhoods"],"kind":"Dublin Core; Subject"},{"value":["lot size"],"kind":"Dublin Core; Subject"},{"value":["economy"],"kind":"Dublin Core; Subject"},{"value":["planningCadastre"],"kind":"Dublin Core; Subject"},{"value":["boundaries"],"kind":"Dublin Core; Subject"},{"value":["location"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["G-polygon"],"kind":"Subject scheme not provided"}],"summary":["City of Boston property parcel data from FY 2015 was joined with parcel boundaries from FY 2015. All data is from the City of Boston Assessor's office and represents data from 2014."]},"sort":[1.0,1420070400000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_INT_P94INCLUSIONS3G_2014","_score":1.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_INT_P94INCLUSIONS3G_2014","timdex_record_id":"gismit:SDE_DATA_INT_P94INCLUSIONS3G_2014","title":"World (3G Mobile Phone Coverage Inclusion, 2014)","citation":"Collins Bartholomew. World (3G Mobile Phone Coverage Inclusion, 2014). Collins Bartholomew. Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_INT_P94INCLUSIONS3G_2014","content_type":["Geospatial data"],"contributors":[{"value":"Collins Bartholomew","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2014-12-01"},{"kind":"Coverage","value":"2014-12-01"},{"kind":"Coverage","value":"2014"}],"format":"Vector","identifiers":[{"value":"INT_P94INCLUSIONS3G_2014","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_INT_P94INCLUSIONS3G_2014.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_INT_P94INCLUSIONS3G_2014.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/SDE_DATA_INT_P94INCLUSIONS3G_2014.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-150.000000, 177.972000, 64.793404, -40.000000)"},{"kind":"Geometry","geoshape":"BBOX (-150.000000, 177.972000, 64.793404, -40.000000)"}],"publication_information":["Collins Bartholomew","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"}],"subjects":[{"value":["Earth (Planet)"],"kind":"Dublin Core; Spatial"},{"value":["utilitiesCommunication"],"kind":"Dublin Core; Subject"},{"value":["Public utilities"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity point"],"kind":"Subject scheme not provided"}],"summary":["These inclusion metadata files for GSM, 3G, and 4G mobile coverage are an attempt at listing all the networks which are included in the separate world mobile phone coverage datasets. Unfortunately the lists cannot be comprehensive because legacy datasets did not maintain the information required to make them complete."]},"sort":[1.0,1417392000000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_INT_P94INCLUSIONS4G_2014","_score":1.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_INT_P94INCLUSIONS4G_2014","timdex_record_id":"gismit:SDE_DATA_INT_P94INCLUSIONS4G_2014","title":"World (4G Mobile Phone Coverage Inclusion, 2014)","citation":"Collins Bartholomew. World (4G Mobile Phone Coverage Inclusion, 2014). Collins Bartholomew. Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_INT_P94INCLUSIONS4G_2014","content_type":["Geospatial data"],"contributors":[{"value":"Collins Bartholomew","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2014-12-01"},{"kind":"Coverage","value":"2014-12-01"},{"kind":"Coverage","value":"2014"}],"format":"Vector","identifiers":[{"value":"INT_P94INCLUSIONS4G_2014","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_INT_P94INCLUSIONS4G_2014.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_INT_P94INCLUSIONS4G_2014.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/SDE_DATA_INT_P94INCLUSIONS4G_2014.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-100.000000, 170.481070, 64.518784, -40.000000)"},{"kind":"Geometry","geoshape":"BBOX (-100.000000, 170.481070, 64.518784, -40.000000)"}],"publication_information":["Collins Bartholomew","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"}],"subjects":[{"value":["Earth (Planet)"],"kind":"Dublin Core; Spatial"},{"value":["utilitiesCommunication"],"kind":"Dublin Core; Subject"},{"value":["Public utilities"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity point"],"kind":"Subject scheme not provided"}],"summary":["These inclusion metadata files for GSM, 3G, and 4G mobile coverage are an attempt at listing all the networks which are included in the separate world mobile phone coverage datasets. Unfortunately the lists cannot be comprehensive because legacy datasets did not maintain the information required to make them complete."]},"sort":[1.0,1417392000000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_INT_P944G_2014","_score":1.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_INT_P944G_2014","timdex_record_id":"gismit:SDE_DATA_INT_P944G_2014","title":"World (4G Mobile Phone Coverage, 2014)","citation":"Collins Bartholomew. World (4G Mobile Phone Coverage, 2014). Collins Bartholomew. Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_INT_P944G_2014","content_type":["Geospatial data"],"contributors":[{"value":"Collins Bartholomew","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2014-12-01"},{"kind":"Coverage","value":"2014-12-01"},{"kind":"Coverage","value":"2014"}],"format":"Vector","identifiers":[{"value":"INT_P944G_2014","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_INT_P944G_2014.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_INT_P944G_2014.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/SDE_DATA_INT_P944G_2014.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-135.373169, 178.145985, 68.532066, -46.186684)"},{"kind":"Geometry","geoshape":"BBOX (-135.373169, 178.145985, 68.532066, -46.186684)"}],"publication_information":["Collins Bartholomew","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"}],"subjects":[{"value":["Earth (Planet)"],"kind":"Dublin Core; Spatial"},{"value":["utilitiesCommunication"],"kind":"Dublin Core; Subject"},{"value":["Public utilities"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["G-polygon"],"kind":"Subject scheme not provided"}],"summary":["Collins Mobile Coverage Explorer is a representation of the area covered by mobile communications around the world. The data is created from submissions, made directly to Collins Bartholomew or the GSMA from mobile operators, which provide roaming detail for inclusion in the online mapping application known as Collins Mobile Coverage Web."]},"sort":[1.0,1417392000000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_INT_P94INCLUSIONSGSM_2014","_score":1.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_INT_P94INCLUSIONSGSM_2014","timdex_record_id":"gismit:SDE_DATA_INT_P94INCLUSIONSGSM_2014","title":"World (GSM Mobile Phone Coverage Inclusion, 2014)","citation":"Collins Bartholomew. World (GSM Mobile Phone Coverage Inclusion, 2014). Collins Bartholomew. Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_INT_P94INCLUSIONSGSM_2014","content_type":["Geospatial data"],"contributors":[{"value":"Collins Bartholomew","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2014-12-01"},{"kind":"Coverage","value":"2014-12-01"},{"kind":"Coverage","value":"2014"}],"format":"Vector","identifiers":[{"value":"INT_P94INCLUSIONSGSM_2014","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_INT_P94INCLUSIONSGSM_2014.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_INT_P94INCLUSIONSGSM_2014.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/SDE_DATA_INT_P94INCLUSIONSGSM_2014.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-180.000000, 177.972000, 74.786049, -50.000000)"},{"kind":"Geometry","geoshape":"BBOX (-180.000000, 177.972000, 74.786049, -50.000000)"}],"publication_information":["Collins Bartholomew","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"}],"subjects":[{"value":["Earth (Planet)"],"kind":"Dublin Core; Spatial"},{"value":["utilitiesCommunication"],"kind":"Dublin Core; Subject"},{"value":["Cell phones"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity point"],"kind":"Subject scheme not provided"}],"summary":["These inclusion metadata files for GSM, 3G, and 4G mobile coverage are an attempt at listing all the networks which are included in the separate world mobile phone coverage datasets. Unfortunately the lists cannot be comprehensive because legacy datasets did not maintain the information required to make them complete."]},"sort":[1.0,1417392000000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_US_MA_BOSTON_G47PARCELS_2014","_score":1.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_BOSTON_G47PARCELS_2014","timdex_record_id":"gismit:SDE_DATA_US_MA_BOSTON_G47PARCELS_2014","title":"Boston, MA (Land Parcels, 2014)","citation":"Boston (Mass.) Assessing Department. Boston, MA (Land Parcels, 2014). Boston (Mass.) Assessing Department. Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_BOSTON_G47PARCELS_2014","content_type":["Geospatial data"],"contributors":[{"value":"Boston (Mass.) Assessing Department","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2014-01-01"},{"kind":"Coverage","value":"2014-01-01"},{"kind":"Coverage","value":"2014"}],"format":"Vector","identifiers":[{"value":"US_MA_BOSTON_G47PARCELS_2014","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_BOSTON_G47PARCELS_2014.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_BOSTON_G47PARCELS_2014.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/SDE_DATA_US_MA_BOSTON_G47PARCELS_2014.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-71.191182, -70.922635, 42.397678, 42.227005)"},{"kind":"Geometry","geoshape":"BBOX (-71.191182, -70.922635, 42.397678, 42.227005)"}],"publication_information":["Boston (Mass.) Assessing Department","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"N/A"}],"subjects":[{"value":["Economy"],"kind":"DCAT; Theme"},{"value":["Boundaries"],"kind":"DCAT; Theme"},{"value":["Location"],"kind":"DCAT; Theme"},{"value":["Massachusetts--Boston"],"kind":"Dublin Core; Spatial"},{"value":["Land use"],"kind":"Dublin Core; Subject"},{"value":["Neighborhoods"],"kind":"Dublin Core; Subject"},{"value":["Administrative and political divisions"],"kind":"Dublin Core; Subject"},{"value":["Land value taxation"],"kind":"Dublin Core; Subject"},{"value":["Land tenure"],"kind":"Dublin Core; Subject"},{"value":["economy"],"kind":"Dublin Core; Subject"},{"value":["planningCadastre"],"kind":"Dublin Core; Subject"},{"value":["boundaries"],"kind":"Dublin Core; Subject"},{"value":["location"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["G-polygon"],"kind":"Subject scheme not provided"}],"summary":["City of Boston property parcel data from FY 2014 was joined with parcel boundaries from FY 2014. All data is from the City of Boston Assessor's office and represents data from 2013."]},"sort":[1.0,1388534400000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_US_MA_BOSTON_G47PARCELS_2013","_score":1.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_BOSTON_G47PARCELS_2013","timdex_record_id":"gismit:SDE_DATA_US_MA_BOSTON_G47PARCELS_2013","title":"Boston, MA (Land Parcels, 2013)","citation":"Boston (Mass). Assessing Department. Boston, MA (Land Parcels, 2013). Boston (Mass.) Assessing Department. Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_BOSTON_G47PARCELS_2013","content_type":["Geospatial data"],"contributors":[{"value":"Boston (Mass). Assessing Department","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2013-01-01"},{"kind":"Coverage","value":"2013-01-01"},{"kind":"Coverage","value":"2013"}],"format":"Vector","identifiers":[{"value":"US_MA_BOSTON_G47PARCELS_2013","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_BOSTON_G47PARCELS_2013.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_BOSTON_G47PARCELS_2013.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/SDE_DATA_US_MA_BOSTON_G47PARCELS_2013.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-71.191182, -70.922635, 42.397678, 42.227005)"},{"kind":"Geometry","geoshape":"BBOX (-71.191182, -70.922635, 42.397678, 42.227005)"}],"publication_information":["Boston (Mass.) Assessing Department","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"N/A"}],"subjects":[{"value":["Economy"],"kind":"DCAT; Theme"},{"value":["Boundaries"],"kind":"DCAT; Theme"},{"value":["Location"],"kind":"DCAT; Theme"},{"value":["Massachusetts--Boston"],"kind":"Dublin Core; Spatial"},{"value":["Land use"],"kind":"Dublin Core; Subject"},{"value":["Neighborhoods"],"kind":"Dublin Core; Subject"},{"value":["Administrative and political divisions"],"kind":"Dublin Core; Subject"},{"value":["Land value taxation"],"kind":"Dublin Core; Subject"},{"value":["Land tenure"],"kind":"Dublin Core; Subject"},{"value":["planningCadastre"],"kind":"Dublin Core; Subject"},{"value":["economy"],"kind":"Dublin Core; Subject"},{"value":["boundaries"],"kind":"Dublin Core; Subject"},{"value":["location"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["G-polygon"],"kind":"Subject scheme not provided"}],"summary":["City of Boston property parcel data from FY 2013 was joined with parcel boundaries from FY 2013. All data is from the City of Boston Assessor's office and represents data from 2012."]},"sort":[1.0,1356998400000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:GISPORTAL_GISOWNER01_CAMBRIDGEMEMPOLES09","_score":1.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:GISPORTAL_GISOWNER01_CAMBRIDGEMEMPOLES09","timdex_record_id":"gismit:GISPORTAL_GISOWNER01_CAMBRIDGEMEMPOLES09","title":"Memorial Poles Cambridge MA 2009","citation":"Cambridge (Mass.). Geographic Information Systems. Memorial Poles Cambridge MA 2009. GIS Lab, MIT Libraries. Geospatial data. https://search.libraries.mit.edu/record/gismit:GISPORTAL_GISOWNER01_CAMBRIDGEMEMPOLES09","content_type":["Geospatial data"],"contributors":[{"value":"Cambridge (Mass.). Geographic Information Systems","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2012-09-20"}],"format":"Vector","identifiers":[{"value":"CambridgeMemPoles09","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/GISPORTAL_GISOWNER01_CAMBRIDGEMEMPOLES09.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/GISPORTAL_GISOWNER01_CAMBRIDGEMEMPOLES09.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/GISPORTAL_GISOWNER01_CAMBRIDGEMEMPOLES09.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-71.157950, -71.076669, 42.402572, 42.355089)"},{"kind":"Geometry","geoshape":"BBOX (-71.157950, -71.076669, 42.402572, 42.355089)"}],"publication_information":["GIS Lab, MIT Libraries"],"rights":[{"description":"Public","kind":"Access"},{"description":"For educational noncommercial use only."}],"subjects":[{"value":["Structure"],"kind":"DCAT; Theme"},{"value":["Massachusetts--Cambridge"],"kind":"Dublin Core; Spatial"},{"value":["Memorials"],"kind":"Dublin Core; Subject"},{"value":["structure"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity point"],"kind":"Subject scheme not provided"}],"summary":["This point dataset contains memorial poles, markers, and plaques installed in Cambridge, MA that commemorate extraordinary citizens and those who have died or been reported missing in combat."]},"sort":[1.0,1348099200000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_US_MA_C32FLOODHAZARDS_2012","_score":1.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_C32FLOODHAZARDS_2012","timdex_record_id":"gismit:SDE_DATA_US_MA_C32FLOODHAZARDS_2012","title":"Massachusetts, USA (Flood Hazards, 2012)","citation":"United States. Federal Emergency Management Agency. Massachusetts, USA (Flood Hazards, 2012). United States. Federal Emergency Management Agency. Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_C32FLOODHAZARDS_2012","content_type":["Geospatial data"],"contributors":[{"value":"United States. Federal Emergency Management Agency","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2012-08-16"},{"kind":"Coverage","value":"2012-08-16"},{"kind":"Coverage","value":"2012"}],"format":"Vector","identifiers":[{"value":"US_MA_C32FLOODHAZARDS_2012","kind":"Not specified"}],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_C32FLOODHAZARDS_2012.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_C32FLOODHAZARDS_2012.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/SDE_DATA_US_MA_C32FLOODHAZARDS_2012.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-72.315879, -70.443474, 42.886818, 41.249267)"},{"kind":"Geometry","geoshape":"BBOX (-72.315879, -70.443474, 42.886818, 41.249267)"}],"publication_information":["United States. Federal Emergency Management Agency","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"No warranty expressed or implied is made by FEMA regarding the utility of the data on any other system nor shall the act of distribution constitute any such warranty. FEMA will warrant the delivery of this product in a computer-readable format, and will offer appropriate adjustment of credit when the product is determined unreadable by correctly adjusted computer input peripherals, or when the physical medium is delivered in damaged condition. Requests for adjustment of credit must be made within 90 days from the date of this shipment from the ordering site."}],"subjects":[{"value":["Environment"],"kind":"DCAT; Theme"},{"value":["Structure"],"kind":"DCAT; Theme"},{"value":["Elevation"],"kind":"DCAT; Theme"},{"value":["Transportation"],"kind":"DCAT; Theme"},{"value":["Massachusetts"],"kind":"Dublin Core; Spatial"},{"value":["environment"],"kind":"Dublin Core; Subject"},{"value":["structure"],"kind":"Dublin Core; Subject"},{"value":["hydrology"],"kind":"Dublin Core; Subject"},{"value":["elevation"],"kind":"Dublin Core; Subject"},{"value":["inlandWaters"],"kind":"Dublin Core; Subject"},{"value":["transportation"],"kind":"Dublin Core; Subject"},{"value":["Flood insurance--Rates"],"kind":"Dublin Core; Subject"},{"value":["Flood damage prevention"],"kind":"Dublin Core; Subject"},{"value":["Flood control--Planning"],"kind":"Dublin Core; Subject"},{"value":["Storm surges"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["GT-polygon composed of chains"],"kind":"Subject scheme not provided"}],"summary":["The National Flood Hazard Layer (NFHL) data incorporates all Digital Flood Insurance Rate Map(DFIRM) databases published by FEMA, and any Letters Of Map Revision (LOMRs) that have been issued against those databases since their publication date. The DFIRM Database is the digital, geospatial version of the flood hazard information shown on the published paper Flood Insurance Rate Maps(FIRMs). The primary risk classifications used are the 1-percent-annual-chance flood event, the 0.2-percent-annual-chance flood event, and areas of minimal flood risk. The NFHL data are derived from Flood Insurance Studies (FISs), previously published Flood Insurance Rate Maps (FIRMs), flood hazard analyses performed in support of the FISs and FIRMs, and new mapping data where available. The FISs and FIRMs are published by the Federal Emergency Management Agency (FEMA). The specifications for the horizontal control of DFIRM data are consistent with those required for mapping at a scale of 1:12,000. The NFHL data contain layers in the Standard DFIRM datasets except for S_Label_Pt and S_Label_Ld. The NFHL is available as State or US Territory data sets. Each State or Territory data set consists of all DFIRMs and corresponding LOMRs available on the publication date of the data set."]},"sort":[1.0,1345075200000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_US_MA_N2DAMS_2012","_score":1.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_N2DAMS_2012","timdex_record_id":"gismit:SDE_DATA_US_MA_N2DAMS_2012","title":"Massachusetts (Dams, 2012)","citation":"Massachusetts. Department of Conservation. Massachusetts (Dams, 2012). MassGIS (Office : Mass.). Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_N2DAMS_2012","content_type":["Geospatial data"],"contributors":[{"value":"Massachusetts. Department of Conservation","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2012-02-03"}],"format":"Vector","identifiers":[{"value":"US_MA_N2DAMS_2012","kind":"Not specified"}],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_N2DAMS_2012.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_N2DAMS_2012.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_N2DAMS_2012.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-73.495093, -69.973216, 42.866832, 41.338518)"},{"kind":"Geometry","geoshape":"BBOX (-73.495093, -69.973216, 42.866832, 41.338518)"}],"publication_information":["MassGIS (Office : Mass.)","GIS Lab, MIT Libraries"],"rights":[{"description":"Public","kind":"Access"}],"subjects":[{"value":["Economy"],"kind":"DCAT; Theme"},{"value":["Environment"],"kind":"DCAT; Theme"},{"value":["Structure"],"kind":"DCAT; Theme"},{"value":["Massachusetts"],"kind":"Dublin Core; Spatial"},{"value":["Dams"],"kind":"Dublin Core; Subject"},{"value":["economy"],"kind":"Dublin Core; Subject"},{"value":["environment"],"kind":"Dublin Core; Subject"},{"value":["inlandWaters"],"kind":"Dublin Core; Subject"},{"value":["structure"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity point"],"kind":"Subject scheme not provided"}],"summary":["The ODS maintains a database that includes detailed information about each dam for operational purposes. Most of the location information was derived from historic data and has been ground-truthed against inspection and ownership reports that are maintained by the ODS. The locations of some dams have not been confirmed. These are pending verification and can be identified through the field 'LocStatus.’Dams regulated by the ODS in accordance with regulation CMR 302 10.00 are listed as ‘Office of Dam Safety’ in the field ‘RegAuth’.Please report any data errors or inconsistencies to the Office of Dam Safety (dam.safety@state.ma.us) or DCR-GIS (chandreyee.lahiri@state.ma.us)"]},"sort":[1.0,1328227200000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:US_MA_BOSTON_G46BLDGS_2012","_score":1.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:US_MA_BOSTON_G46BLDGS_2012","timdex_record_id":"gismit:US_MA_BOSTON_G46BLDGS_2012","title":"us_ma_boston_g46bldgs_2012","citation":"Boston (Mass.). Dept. of Innovation and Technology. us_ma_boston_g46bldgs_2012. Boston Department of Innovation and Technology (DoIT). Geospatial data. https://search.libraries.mit.edu/record/gismit:US_MA_BOSTON_G46BLDGS_2012","content_type":["Geospatial data"],"contributors":[{"value":"Boston (Mass.). Dept. of Innovation and Technology.","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2012-01-19"},{"kind":"Coverage","value":"2012-01-01"},{"kind":"Coverage","value":"2012"}],"format":"Vector","identifiers":[{"value":"us_ma_boston_g46bldgs_2012","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/US_MA_BOSTON_G46BLDGS_2012.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/US_MA_BOSTON_G46BLDGS_2012.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/US_MA_BOSTON_G46BLDGS_2012.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-71.186110, -70.924810, 42.398736, 42.229271)"},{"kind":"Geometry","geoshape":"BBOX (-71.186110, -70.924810, 42.398736, 42.229271)"}],"publication_information":["Boston Department of Innovation and Technology (DoIT)","GIS Lab, MIT Libraries"],"rights":[{"description":"Public","kind":"Access"},{"description":"For educational noncommercial use only."}],"subjects":[{"value":["Structure"],"kind":"DCAT; Theme"},{"value":["Boston"],"kind":"Dublin Core; Spatial"},{"value":["Massachusetts"],"kind":"Dublin Core; Spatial"},{"value":["Suffolk"],"kind":"Dublin Core; Spatial"},{"value":["New England"],"kind":"Dublin Core; Spatial"},{"value":["US"],"kind":"Dublin Core; Spatial"},{"value":["MA"],"kind":"Dublin Core; Spatial"},{"value":["Eastern Massachusetts"],"kind":"Dublin Core; Spatial"},{"value":["Northern Hemisphere"],"kind":"Dublin Core; Spatial"},{"value":["Western Hemisphere"],"kind":"Dublin Core; Spatial"},{"value":["United States"],"kind":"Dublin Core; Spatial"},{"value":["polygon"],"kind":"Dublin Core; Subject"},{"value":["structure"],"kind":"Dublin Core; Subject"},{"value":["Buildings"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["G-polygon"],"kind":"Subject scheme not provided"}],"summary":["This polygon layer represents building footprints in Boston, MA"]},"sort":[1.0,1326931200000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_US_MA_BOSTON_G47PARCELS_2012","_score":1.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_BOSTON_G47PARCELS_2012","timdex_record_id":"gismit:SDE_DATA_US_MA_BOSTON_G47PARCELS_2012","title":"Boston, MA (Land Parcels, 2012)","citation":"Boston (Mass.) Assessing Department. Boston, MA (Land Parcels, 2012). City of Boston Assessing Department. Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_BOSTON_G47PARCELS_2012","content_type":["Geospatial data"],"contributors":[{"value":"Boston (Mass.) Assessing Department","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2012-01-01"},{"kind":"Coverage","value":"2012-01-01"},{"kind":"Coverage","value":"2012"}],"format":"Vector","identifiers":[{"value":"US_MA_BOSTON_G47PARCELS_2012","kind":"Not specified"}],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_BOSTON_G47PARCELS_2012.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_BOSTON_G47PARCELS_2012.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/SDE_DATA_US_MA_BOSTON_G47PARCELS_2012.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-71.191182, -70.922637, 42.397564, 42.227005)"},{"kind":"Geometry","geoshape":"BBOX (-71.191182, -70.922637, 42.397564, 42.227005)"}],"publication_information":["City of Boston Assessing Department","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"N/A"}],"subjects":[{"value":["Boundaries"],"kind":"DCAT; Theme"},{"value":["Location"],"kind":"DCAT; Theme"},{"value":["Massachusetts--Boston"],"kind":"Dublin Core; Spatial"},{"value":["Land use"],"kind":"Dublin Core; Subject"},{"value":["Administrative and political divisions"],"kind":"Dublin Core; Subject"},{"value":["Land value taxation"],"kind":"Dublin Core; Subject"},{"value":["Land tenure"],"kind":"Dublin Core; Subject"},{"value":["Neighborhoods"],"kind":"Dublin Core; Subject"},{"value":["boundaries"],"kind":"Dublin Core; Subject"},{"value":["location"],"kind":"Dublin Core; Subject"},{"value":["planningCadastre"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["GT-polygon composed of chains"],"kind":"Subject scheme not provided"}],"summary":["City of Boston property parcel data from FY 2012 was joined with parcel boundaries from FY 2012. All data is from the City of Boston Assessor's office and represents data from 2011."]},"sort":[1.0,1325376000000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:GISPORTAL_GISOWNER01_CAMBRIDGENHOODCONSVDIST07","_score":1.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:GISPORTAL_GISOWNER01_CAMBRIDGENHOODCONSVDIST07","timdex_record_id":"gismit:GISPORTAL_GISOWNER01_CAMBRIDGENHOODCONSVDIST07","title":"Neighborhood Conservation Districts Cambridge MA 2007","citation":"Cambridge (Mass.). Geographic Information Systems. Neighborhood Conservation Districts Cambridge MA 2007. GIS Lab, MIT Libraries. Geospatial data. https://search.libraries.mit.edu/record/gismit:GISPORTAL_GISOWNER01_CAMBRIDGENHOODCONSVDIST07","content_type":["Geospatial data"],"contributors":[{"value":"Cambridge (Mass.). Geographic Information Systems","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2011-07-20"}],"format":"Vector","identifiers":[{"value":"CambridgeNhoodConsvDist07","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/GISPORTAL_GISOWNER01_CAMBRIDGENHOODCONSVDIST07.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/GISPORTAL_GISOWNER01_CAMBRIDGENHOODCONSVDIST07.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/GISPORTAL_GISOWNER01_CAMBRIDGENHOODCONSVDIST07.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-71.134050, -71.099268, 42.388156, 42.366734)"},{"kind":"Geometry","geoshape":"BBOX (-71.134050, -71.099268, 42.388156, 42.366734)"}],"publication_information":["GIS Lab, MIT Libraries"],"rights":[{"description":"Public","kind":"Access"},{"description":"For educational noncommercial use only."}],"subjects":[{"value":["Boundaries"],"kind":"DCAT; Theme"},{"value":["Society"],"kind":"DCAT; Theme"},{"value":["Structure"],"kind":"DCAT; Theme"},{"value":["Massachusetts--Cambridge"],"kind":"Dublin Core; Spatial"},{"value":["Historic districts--Conservation and restoration"],"kind":"Dublin Core; Subject"},{"value":["boundaries"],"kind":"Dublin Core; Subject"},{"value":["society"],"kind":"Dublin Core; Subject"},{"value":["structure"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["G-polygon"],"kind":"Subject scheme not provided"}],"summary":["This dataset contains five polygons representing Neighborhood Conservation Districts (NCDs) in Cambridge, MA. Conservation districts are groups of buildings and their surroundings that are architecturally and historically distinctive."]},"sort":[1.0,1311120000000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_US_P2MAJRDS_2005","_score":1.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_P2MAJRDS_2005","timdex_record_id":"gismit:SDE_DATA_US_P2MAJRDS_2005","title":"USA (Major Roads, 2005)","citation":"Tele Atlas North America, Inc./Geographic Data Technology, Inc., ESRI. USA (Major Roads, 2005). Environmental Systems Research Institute (ESRI). Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_P2MAJRDS_2005","content_type":["Geospatial data"],"contributors":[{"value":"Tele Atlas North America, Inc./Geographic Data Technology, Inc.","kind":"Creator"},{"value":"ESRI","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2005-04-01"},{"kind":"Coverage","value":"2004-01-01"},{"kind":"Coverage","value":"2005-01-01"},{"kind":"Coverage","value":"2011-04-20"},{"kind":"Coverage","value":"2001-05-20"},{"kind":"Coverage","value":"2004"},{"kind":"Coverage","value":"2005"},{"kind":"Coverage","value":"2011"},{"kind":"Coverage","value":"2001"}],"format":"Vector","identifiers":[{"value":"SDE_DATA.US_P2MAJRDS_2005","kind":"Not specified"},{"value":"US_P2MAJRDS_2005","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_P2MAJRDS_2005.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_P2MAJRDS_2005.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/SDE_DATA_US_P2MAJRDS_2005.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-166.556498, -65.259590, 71.306880, 17.949201)"},{"kind":"Geometry","geoshape":"BBOX (-166.556498, -65.259590, 71.306880, 17.949201)"}],"publication_information":["Environmental Systems Research Institute (ESRI)","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"}],"subjects":[{"value":["Transportation"],"kind":"DCAT; Theme"},{"value":["United States"],"kind":"Dublin Core; Spatial"},{"value":["Transportation"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["String"],"kind":"Subject scheme not provided"}],"summary":["U.S. Major Roads represents interstate, U.S. and state highways, major streets, and other major thoroughfares within the United States."]},"sort":[1.0,1303257600000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_US_P1TRANSTERMS_2005","_score":1.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_P1TRANSTERMS_2005","timdex_record_id":"gismit:SDE_DATA_US_P1TRANSTERMS_2005","title":"USA (Transportation Terminals, 2005)","citation":"Tele Atlas North America, Inc./Geographic Data Technology, Inc., ESRI. USA (Transportation Terminals, 2005). Environmental Systems Research Institute (ESRI). Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_P1TRANSTERMS_2005","content_type":["Geospatial data"],"contributors":[{"value":"Tele Atlas North America, Inc./Geographic Data Technology, Inc.","kind":"Creator"},{"value":"ESRI","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2005-04-01"},{"kind":"Coverage","value":"2004-01-01"},{"kind":"Coverage","value":"2005-01-01"},{"kind":"Coverage","value":"2011-04-20"},{"kind":"Coverage","value":"2001-05-20"},{"kind":"Coverage","value":"2004"},{"kind":"Coverage","value":"2005"},{"kind":"Coverage","value":"2011"},{"kind":"Coverage","value":"2001"}],"format":"Vector","identifiers":[{"value":"SDE_DATA.US_P1TRANSTERMS_2005","kind":"Not specified"},{"value":"US_P1TRANSTERMS_2005","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_P1TRANSTERMS_2005.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_P1TRANSTERMS_2005.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/SDE_DATA_US_P1TRANSTERMS_2005.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-166.498692, -65.302143, 61.122378, 18.152193)"},{"kind":"Geometry","geoshape":"BBOX (-166.498692, -65.302143, 61.122378, 18.152193)"}],"publication_information":["Environmental Systems Research Institute (ESRI)","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"}],"subjects":[{"value":["Transportation"],"kind":"DCAT; Theme"},{"value":["United States"],"kind":"Dublin Core; Spatial"},{"value":["Transportation"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity point"],"kind":"Subject scheme not provided"}],"summary":["U.S. TANA/GDT Transportation Terminals represents locations within United States for transportation terminals such as bus terminals, train stations, marine terminals, and other significant transportation nodes."]},"sort":[1.0,1303257600000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_CA_F7REGNMUNI_2005","_score":1.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_CA_F7REGNMUNI_2005","timdex_record_id":"gismit:SDE_DATA_CA_F7REGNMUNI_2005","title":"Canada (Regional Municipalities, 2005)","citation":"DMTI Spatial Inc., Environmental Systems Research Institute (Redlands, Calif.). Canada (Regional Municipalities, 2005). Environmental Systems Research Institute (Redlands, Calif.). Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_CA_F7REGNMUNI_2005","content_type":["Geospatial data"],"contributors":[{"value":"DMTI Spatial Inc.","kind":"Creator"},{"value":"Environmental Systems Research Institute (Redlands, Calif.)","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2005-04-01"},{"kind":"Coverage","value":"2004-01-01"},{"kind":"Coverage","value":"2001-01-01"},{"kind":"Coverage","value":"2011-04-20"},{"kind":"Coverage","value":"2004"},{"kind":"Coverage","value":"2001"},{"kind":"Coverage","value":"2011"}],"format":"Vector","identifiers":[{"value":"SDE_DATA.CA_F7REGNMUNI_2005","kind":"Not specified"},{"value":"CA_F7REGNMUNI_2005","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_CA_F7REGNMUNI_2005.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_CA_F7REGNMUNI_2005.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/SDE_DATA_CA_F7REGNMUNI_2005.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-141.001870, -52.619170, 83.115063, 41.687973)"},{"kind":"Geometry","geoshape":"BBOX (-141.001870, -52.619170, 83.115063, 41.687973)"}],"publication_information":["Environmental Systems Research Institute (Redlands, Calif.)","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"}],"subjects":[{"value":["Boundaries"],"kind":"DCAT; Theme"},{"value":["Canada"],"kind":"Dublin Core; Spatial"},{"value":["Administrative and political divisions"],"kind":"Dublin Core; Subject"},{"value":["Cities and towns"],"kind":"Dublin Core; Subject"},{"value":["boundaries"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["G-polygon"],"kind":"Subject scheme not provided"}],"summary":["Canada Regional Municipalities represents the regional municipalities (counties) within Canada including regional districts and municipalities, counties, communauté, regions, and districts. The boundaries are digitized from CanMap®."]},"sort":[1.0,1303257600000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_CA_F7MUNI_2005","_score":1.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_CA_F7MUNI_2005","timdex_record_id":"gismit:SDE_DATA_CA_F7MUNI_2005","title":"Canada (Municipalities, 2005)","citation":"DMTI Spatial Inc., Environmental Systems Research Institute (Redlands, Calif.). Canada (Municipalities, 2005). Environmental Systems Research Institute (Redlands, Calif.). Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_CA_F7MUNI_2005","content_type":["Geospatial data"],"contributors":[{"value":"DMTI Spatial Inc.","kind":"Creator"},{"value":"Environmental Systems Research Institute (Redlands, Calif.)","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2005-04-01"},{"kind":"Coverage","value":"2004-01-01"},{"kind":"Coverage","value":"2001-01-01"},{"kind":"Coverage","value":"2011-04-20"},{"kind":"Coverage","value":"2004"},{"kind":"Coverage","value":"2001"},{"kind":"Coverage","value":"2011"}],"format":"Vector","identifiers":[{"value":"SDE_DATA.CA_F7MUNI_2005","kind":"Not specified"},{"value":"CA_F7MUNI_2005","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_CA_F7MUNI_2005.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_CA_F7MUNI_2005.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/SDE_DATA_CA_F7MUNI_2005.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-141.001870, -52.619173, 83.115063, 41.687973)"},{"kind":"Geometry","geoshape":"BBOX (-141.001870, -52.619173, 83.115063, 41.687973)"}],"publication_information":["Environmental Systems Research Institute (Redlands, Calif.)","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"}],"subjects":[{"value":["Boundaries"],"kind":"DCAT; Theme"},{"value":["Canada"],"kind":"Dublin Core; Spatial"},{"value":["Cities and towns"],"kind":"Dublin Core; Subject"},{"value":["Villages"],"kind":"Dublin Core; Subject"},{"value":["Parishes (Local government)"],"kind":"Dublin Core; Subject"},{"value":["Administrative and political divisions"],"kind":"Dublin Core; Subject"},{"value":["Inuit--Land tenure"],"kind":"Dublin Core; Subject"},{"value":["boundaries"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["G-polygon"],"kind":"Subject scheme not provided"}],"summary":["Canada Municipalities represents the municipalities (townships) within Canada of types including cities, cantons, hamlets, towns/ville, villages, Indian reserves, parishes/paroisse, communities, unorganized, districts, and terre Inuite. The boundaries are digitized from CanMap®."]},"sort":[1.0,1303257600000]}]},"aggregations":{"languages":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[{"key":"eng","doc_count":808}]},"content_type":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[{"key":"geospatial data","doc_count":825}]},"subjects":{"doc_count":7447,"subject_names":{"doc_count_error_upper_bound":0,"sum_other_doc_count":4183,"buckets":[{"key":"datasets","doc_count":825},{"key":"g-polygon","doc_count":416},{"key":"boundaries","doc_count":376},{"key":"transportation","doc_count":348},{"key":"united states","doc_count":270},{"key":"entity point","doc_count":256},{"key":"society","doc_count":246},{"key":"massachusetts--cambridge","doc_count":197},{"key":"structure","doc_count":166},{"key":"location","doc_count":164}]}},"content_format":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[{"key":"vector","doc_count":824},{"key":"point","doc_count":1}]},"literary_form":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[]},"source":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[{"key":"mit gis resources","doc_count":825}]},"contributors":{"doc_count":1011,"contributor_names":{"doc_count_error_upper_bound":0,"sum_other_doc_count":427,"buckets":[{"key":"massgis (office : mass.)","doc_count":134},{"key":"esri","doc_count":84},{"key":"city of cambridge gis","doc_count":82},{"key":"platts","doc_count":64},{"key":"environmental systems research institute (redlands, calif.)","doc_count":49},{"key":"environmental systems research institute, inc. (esri)","doc_count":44},{"key":"cambridge (mass.). geographic information systems","doc_count":41},{"key":"tele atlas b.v.","doc_count":32},{"key":"usgs","doc_count":28},{"key":"city of newton gis","doc_count":26}]}}}} + recorded_at: Wed, 14 Feb 2024 16:30:39 GMT +recorded_with: VCR 6.2.0 diff --git a/test/vcr_cassettes/graphqlv2_geobox_eastern_hemisphere.yml b/test/vcr_cassettes/graphqlv2_geobox_eastern_hemisphere.yml new file mode 100644 index 00000000..7681067a --- /dev/null +++ b/test/vcr_cassettes/graphqlv2_geobox_eastern_hemisphere.yml @@ -0,0 +1,448 @@ +--- +http_interactions: +- request: + method: get + uri: http://localhost:9200/ + body: + encoding: US-ASCII + string: '' + headers: + User-Agent: + - 'opensearch-ruby/3.1.0 (RUBY_VERSION: 3.2.2; darwin arm64; Faraday v2.9.0)' + Content-Type: + - application/json + Accept-Encoding: + - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 + Accept: + - "*/*" + response: + status: + code: 200 + message: OK + headers: + Content-Type: + - application/json; charset=UTF-8 + Content-Length: + - '567' + body: + encoding: ASCII-8BIT + string: | + { + "name" : "57e0dc0fc53d", + "cluster_name" : "docker-cluster", + "cluster_uuid" : "DoZb5LNrT7eUN8gEh-aLJg", + "version" : { + "distribution" : "opensearch", + "number" : "2.11.1", + "build_type" : "tar", + "build_hash" : "6b1986e964d440be9137eba1413015c31c5a7752", + "build_date" : "2023-11-29T21:45:35.524809067Z", + "build_snapshot" : false, + "lucene_version" : "9.7.0", + "minimum_wire_compatibility_version" : "7.10.0", + "minimum_index_compatibility_version" : "7.0.0" + }, + "tagline" : "The OpenSearch Project: https://opensearch.org/" + } + recorded_at: Wed, 14 Feb 2024 16:37:53 GMT +- request: + method: post + uri: http://localhost:9200/timdex-prod/_search + body: + encoding: UTF-8 + string: '{"from":"0","size":20,"query":{"bool":{"should":null,"must":[{"bool":{"must":{"match_all":{}},"filter":{"geo_bounding_box":{"locations.geoshape":{"top":90.0,"bottom":-90.0,"left":0.0,"right":180.0}}}}}],"filter":[]}},"aggregations":{"contributors":{"nested":{"path":"contributors"},"aggs":{"contributor_names":{"terms":{"field":"contributors.value.keyword"}}}},"content_type":{"terms":{"field":"content_type"}},"content_format":{"terms":{"field":"format"}},"languages":{"terms":{"field":"languages.keyword"}},"literary_form":{"terms":{"field":"literary_form"}},"source":{"terms":{"field":"source"}},"subjects":{"nested":{"path":"subjects"},"aggs":{"subject_names":{"terms":{"field":"subjects.value.keyword"}}}}},"sort":[{"_score":{"order":"desc"}},{"dates.value.as_date":{"order":"desc","nested":{"path":"dates"}}}]}' + headers: + User-Agent: + - 'opensearch-ruby/3.1.0 (RUBY_VERSION: 3.2.2; darwin arm64; Faraday v2.9.0)' + Content-Type: + - application/json + Accept-Encoding: + - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 + Accept: + - "*/*" + response: + status: + code: 200 + message: OK + headers: + Content-Type: + - application/json; charset=UTF-8 + Content-Length: + - '44752' + body: + encoding: ASCII-8BIT + string: '{"took":29,"timed_out":false,"_shards":{"total":1,"successful":1,"skipped":0,"failed":0},"hits":{"total":{"value":893,"relation":"eq"},"max_score":null,"hits":[{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:in_mumbai_uf8firestations_2017","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:in_mumbai_uf8firestations_2017","timdex_record_id":"gismit:in_mumbai_uf8firestations_2017","title":"Mumbai, + India (Fire Stations, 2017)","citation":"ML Infomap Pvt Ltd. Mumbai, India + (Fire Stations, 2017). GIS Lab, MIT Libraries. Geospatial data. https://search.libraries.mit.edu/record/gismit:in_mumbai_uf8firestations_2017","content_type":["Geospatial + data"],"contributors":[{"value":"ML Infomap Pvt Ltd","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2017-08-17"}],"format":"Vector","identifiers":[{"value":"in_mumbai_uf8firestations_2017","kind":"Not + specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/in_mumbai_uf8firestations_2017.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/in_mumbai_uf8firestations_2017.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/in_mumbai_uf8firestations_2017.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (72.812690, + 72.966334, 19.247477, 18.915476)"},{"kind":"Geometry","geoshape":"BBOX (72.812690, + 72.966334, 19.247477, 18.915476)"}],"publication_information":["GIS Lab, MIT + Libraries"],"rights":[{"description":"Restricted","kind":"Access"}],"subjects":[{"value":["Structure"],"kind":"DCAT; + Theme"},{"value":["India--Mumbai"],"kind":"Dublin Core; Spatial"},{"value":["Fire + stations"],"kind":"Dublin Core; Subject"},{"value":["structure"],"kind":"Dublin + Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity + point"],"kind":"Subject scheme not provided"}],"summary":["Points of all fire + stations are shown."]},"sort":[1.0,1502928000000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:dz_a1cities_10k20k_2016","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:dz_a1cities_10k20k_2016","timdex_record_id":"gismit:dz_a1cities_10k20k_2016","title":"Algeria + (Cities (10k-20k), 2016)","citation":"GfK GeoMarketing GmbH. Algeria (Cities + (10k-20k), 2016). GIS Lab, MIT Libraries. Geospatial data. https://search.libraries.mit.edu/record/gismit:dz_a1cities_10k20k_2016","content_type":["Geospatial + data"],"contributors":[{"value":"GfK GeoMarketing GmbH","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2016-12-01"}],"format":"Vector","identifiers":[{"value":"dz_a1cities_10k20k_2016","kind":"Not + specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_a1cities_10k20k_2016.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_a1cities_10k20k_2016.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/dz_a1cities_10k20k_2016.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-1.423186, + 8.313771, 36.917160, 29.388636)"},{"kind":"Geometry","geoshape":"BBOX (-1.423186, + 8.313771, 36.917160, 29.388636)"}],"publication_information":["GIS Lab, MIT + Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"License + required"}],"subjects":[{"value":["Location"],"kind":"DCAT; Theme"},{"value":["Algeria"],"kind":"Dublin + Core; Spatial"},{"value":["Cities and towns"],"kind":"Dublin Core; Subject"},{"value":["location"],"kind":"Dublin + Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity + point"],"kind":"Subject scheme not provided"}]},"sort":[1.0,1480550400000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:dz_c28hydline_2016","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:dz_c28hydline_2016","timdex_record_id":"gismit:dz_c28hydline_2016","title":"Algeria + (Hydrographic Features (line), 2016)","citation":"GfK GeoMarketing GmbH. Algeria + (Hydrographic Features (line), 2016). GIS Lab, MIT Libraries. Geospatial data. + https://search.libraries.mit.edu/record/gismit:dz_c28hydline_2016","content_type":["Geospatial + data"],"contributors":[{"value":"GfK GeoMarketing GmbH","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2016-12-01"}],"format":"Vector","identifiers":[{"value":"dz_c28hydline_2016","kind":"Not + specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_c28hydline_2016.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_c28hydline_2016.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/dz_c28hydline_2016.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (0.132726, + 5.076599, 36.733252, 33.898693)"},{"kind":"Geometry","geoshape":"BBOX (0.132726, + 5.076599, 36.733252, 33.898693)"}],"publication_information":["GIS Lab, MIT + Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"License + required"}],"subjects":[{"value":["Algeria"],"kind":"Dublin Core; Spatial"},{"value":["Hydrology"],"kind":"Dublin + Core; Subject"},{"value":["inlandWaters"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject + scheme not provided"},{"value":["String"],"kind":"Subject scheme not provided"}]},"sort":[1.0,1480550400000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:dz_a1cities_20k50k_2016","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:dz_a1cities_20k50k_2016","timdex_record_id":"gismit:dz_a1cities_20k50k_2016","title":"Algeria + (Cities (20k-50k), 2016)","citation":"GfK GeoMarketing GmbH. Algeria (Cities + (20k-50k), 2016). GIS Lab, MIT Libraries. Geospatial data. https://search.libraries.mit.edu/record/gismit:dz_a1cities_20k50k_2016","content_type":["Geospatial + data"],"contributors":[{"value":"GfK GeoMarketing GmbH","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2016-12-01"}],"format":"Vector","identifiers":[{"value":"dz_a1cities_20k50k_2016","kind":"Not + specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_a1cities_20k50k_2016.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_a1cities_20k50k_2016.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/dz_a1cities_20k50k_2016.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-1.856799, + 8.443333, 37.007167, 19.573696)"},{"kind":"Geometry","geoshape":"BBOX (-1.856799, + 8.443333, 37.007167, 19.573696)"}],"publication_information":["GIS Lab, MIT + Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"License + required"}],"subjects":[{"value":["Location"],"kind":"DCAT; Theme"},{"value":["Algeria"],"kind":"Dublin + Core; Spatial"},{"value":["Cities and towns"],"kind":"Dublin Core; Subject"},{"value":["location"],"kind":"Dublin + Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity + point"],"kind":"Subject scheme not provided"}]},"sort":[1.0,1480550400000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:dz_a1cities_50k100k_2016","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:dz_a1cities_50k100k_2016","timdex_record_id":"gismit:dz_a1cities_50k100k_2016","title":"Algeria + (Cities (50k-100k), 2016)","citation":"GfK GeoMarketing GmbH. Algeria (Cities + (50k-100k), 2016). GIS Lab, MIT Libraries. Geospatial data. https://search.libraries.mit.edu/record/gismit:dz_a1cities_50k100k_2016","content_type":["Geospatial + data"],"contributors":[{"value":"GfK GeoMarketing GmbH","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2016-12-01"}],"format":"Vector","identifiers":[{"value":"dz_a1cities_50k100k_2016","kind":"Not + specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_a1cities_50k100k_2016.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_a1cities_50k100k_2016.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/dz_a1cities_50k100k_2016.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-8.147435, + 8.129167, 36.823460, 22.785000)"},{"kind":"Geometry","geoshape":"BBOX (-8.147435, + 8.129167, 36.823460, 22.785000)"}],"publication_information":["GIS Lab, MIT + Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"License + required"}],"subjects":[{"value":["Location"],"kind":"DCAT; Theme"},{"value":["Algeria"],"kind":"Dublin + Core; Spatial"},{"value":["Cities and towns"],"kind":"Dublin Core; Subject"},{"value":["location"],"kind":"Dublin + Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity + point"],"kind":"Subject scheme not provided"}]},"sort":[1.0,1480550400000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:dz_p2hig_2016","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:dz_p2hig_2016","timdex_record_id":"gismit:dz_p2hig_2016","title":"Algeria + (Cities (100k-500k), 2016)","citation":"GfK GeoMarketing GmbH. Algeria (Cities + (100k-500k), 2016). GIS Lab, MIT Libraries. Geospatial data. https://search.libraries.mit.edu/record/gismit:dz_p2hig_2016","content_type":["Geospatial + data"],"contributors":[{"value":"GfK GeoMarketing GmbH","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2016-12-01"}],"format":"Vector","identifiers":[{"value":"dz_a1cities_100k500k_2016","kind":"Not + specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_p2hig_2016.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_p2hig_2016.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/dz_p2hig_2016.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-2.216667, + 8.124167, 36.900000, 31.616667)"},{"kind":"Geometry","geoshape":"BBOX (-2.216667, + 8.124167, 36.900000, 31.616667)"}],"publication_information":["GIS Lab, MIT + Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"License + required"}],"subjects":[{"value":["Transportation"],"kind":"DCAT; Theme"},{"value":["Algeria"],"kind":"Dublin + Core; Spatial"},{"value":["Roads"],"kind":"Dublin Core; Subject"},{"value":["transportation"],"kind":"Dublin + Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity + point"],"kind":"Subject scheme not provided"}]},"sort":[1.0,1480550400000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:dz_c28hydpoly_2016","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:dz_c28hydpoly_2016","timdex_record_id":"gismit:dz_c28hydpoly_2016","title":"Algeria + (Cities (10k-20k), 2016)","citation":"GfK GeoMarketing GmbH. Algeria (Cities + (10k-20k), 2016). GIS Lab, MIT Libraries. Geospatial data. https://search.libraries.mit.edu/record/gismit:dz_c28hydpoly_2016","content_type":["Geospatial + data"],"contributors":[{"value":"GfK GeoMarketing GmbH","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2016-12-01"}],"format":"Vector","identifiers":[{"value":"dz_a1cities_10k20k_2016","kind":"Not + specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_c28hydpoly_2016.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_c28hydpoly_2016.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/dz_c28hydpoly_2016.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-1.423186, + 8.313771, 36.917160, 29.388636)"},{"kind":"Geometry","geoshape":"BBOX (-1.423186, + 8.313771, 36.917160, 29.388636)"}],"publication_information":["GIS Lab, MIT + Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"License + required"}],"subjects":[{"value":["Algeria"],"kind":"Dublin Core; Spatial"},{"value":["Hydrology"],"kind":"Dublin + Core; Subject"},{"value":["inlandWaters"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject + scheme not provided"},{"value":["Entity point"],"kind":"Subject scheme not + provided"}]},"sort":[1.0,1480550400000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:dz_p2roads_2016","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:dz_p2roads_2016","timdex_record_id":"gismit:dz_p2roads_2016","title":"Algeria + (Roads, 2016)","citation":"GfK GeoMarketing GmbH. Algeria (Roads, 2016). GIS + Lab, MIT Libraries. Geospatial data. https://search.libraries.mit.edu/record/gismit:dz_p2roads_2016","content_type":["Geospatial + data"],"contributors":[{"value":"GfK GeoMarketing GmbH","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2016-12-01"}],"format":"Vector","identifiers":[{"value":"dz_p2roads_2016","kind":"Not + specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_p2roads_2016.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_p2roads_2016.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/dz_p2roads_2016.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-8.154491, + 10.548201, 36.919383, 19.442285)"},{"kind":"Geometry","geoshape":"BBOX (-8.154491, + 10.548201, 36.919383, 19.442285)"}],"publication_information":["GIS Lab, MIT + Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"License + required"}],"subjects":[{"value":["Transportation"],"kind":"DCAT; Theme"},{"value":["Algeria"],"kind":"Dublin + Core; Spatial"},{"value":["Roads"],"kind":"Dublin Core; Subject"},{"value":["transportation"],"kind":"Dublin + Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["String"],"kind":"Subject + scheme not provided"}]},"sort":[1.0,1480550400000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:dz_a1cities_100k500k_2016","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:dz_a1cities_100k500k_2016","timdex_record_id":"gismit:dz_a1cities_100k500k_2016","title":"Algeria + (Cities (100k-500k), 2016)","citation":"GfK GeoMarketing GmbH. Algeria (Cities + (100k-500k), 2016). GIS Lab, MIT Libraries. Geospatial data. https://search.libraries.mit.edu/record/gismit:dz_a1cities_100k500k_2016","content_type":["Geospatial + data"],"contributors":[{"value":"GfK GeoMarketing GmbH","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2016-12-01"}],"format":"Vector","identifiers":[{"value":"dz_a1cities_100k500k_2016","kind":"Not + specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_a1cities_100k500k_2016.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_a1cities_100k500k_2016.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/dz_a1cities_100k500k_2016.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-2.216667, + 8.124167, 36.900000, 31.616667)"},{"kind":"Geometry","geoshape":"BBOX (-2.216667, + 8.124167, 36.900000, 31.616667)"}],"publication_information":["GIS Lab, MIT + Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"License + required"}],"subjects":[{"value":["Location"],"kind":"DCAT; Theme"},{"value":["Algeria"],"kind":"Dublin + Core; Spatial"},{"value":["Cities and towns"],"kind":"Dublin Core; Subject"},{"value":["location"],"kind":"Dublin + Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity + point"],"kind":"Subject scheme not provided"}]},"sort":[1.0,1480550400000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:dz_p61airports_2016","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:dz_p61airports_2016","timdex_record_id":"gismit:dz_p61airports_2016","title":"Algeria + (Airports, 2016)","citation":"GfK GeoMarketing GmbH. Algeria (Airports, 2016). + GfK GeoMarketing GmbH. Geospatial data. https://search.libraries.mit.edu/record/gismit:dz_p61airports_2016","content_type":["Geospatial + data"],"contributors":[{"value":"GfK GeoMarketing GmbH","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2016-12-01"}],"format":"Vector","identifiers":[{"value":"dz_p61airports_2016","kind":"Not + specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_p61airports_2016.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_p61airports_2016.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/dz_p61airports_2016.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-8.166223, + 9.638056, 29.236944, 22.816967)"},{"kind":"Geometry","geoshape":"BBOX (-8.166223, + 9.638056, 29.236944, 22.816967)"}],"publication_information":["GfK GeoMarketing + GmbH","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"Access + is limited to members of the MIT community only -- maps may not be given to + anyone not officially and currently affiliated with MIT. Maps may be used + only for research, educational, and other scholarly purposes; it is permissible + to use images created from the software and data in scholarly publications + and dissertations. Any other use, unless it falls within the Fair Use provisions + of U.S. copyright law, is not permitted.The copyright of GfK GeoMarketing + must be placed on the maps.The data can be published as a Bitmap or comparable + format."}],"subjects":[{"value":["Transportation"],"kind":"DCAT; Theme"},{"value":["Algeria"],"kind":"Dublin + Core; Spatial"},{"value":["Airports"],"kind":"Dublin Core; Subject"},{"value":["transportation"],"kind":"Dublin + Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity + point"],"kind":"Subject scheme not provided"}]},"sort":[1.0,1480550400000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:dz_a1cities_0k10k_2016","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:dz_a1cities_0k10k_2016","timdex_record_id":"gismit:dz_a1cities_0k10k_2016","title":"Algeria + (Cities (<10k), 2016)","citation":"GfK GeoMarketing GmbH. Algeria (Cities + (<10k), 2016). GIS Lab, MIT Libraries. Geospatial data. https://search.libraries.mit.edu/record/gismit:dz_a1cities_0k10k_2016","content_type":["Geospatial + data"],"contributors":[{"value":"GfK GeoMarketing GmbH","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2016-12-01"}],"format":"Vector","identifiers":[{"value":"dz_a1cities_0k10k_2016","kind":"Not + specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_a1cities_0k10k_2016.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_a1cities_0k10k_2016.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/dz_a1cities_0k10k_2016.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-7.843005, + 11.241667, 37.075000, 19.166667)"},{"kind":"Geometry","geoshape":"BBOX (-7.843005, + 11.241667, 37.075000, 19.166667)"}],"publication_information":["GIS Lab, MIT + Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"License + required"}],"subjects":[{"value":["Location"],"kind":"DCAT; Theme"},{"value":["Algeria"],"kind":"Dublin + Core; Spatial"},{"value":["Cities and towns"],"kind":"Dublin Core; Subject"},{"value":["location"],"kind":"Dublin + Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity + point"],"kind":"Subject scheme not provided"}]},"sort":[1.0,1480550400000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:in_jabalpur_f7ward_2011","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:in_jabalpur_f7ward_2011","timdex_record_id":"gismit:in_jabalpur_f7ward_2011","title":"Jabalpur, + India (Ward Census Data, 2011)","citation":"ML INFOMAP. Jabalpur, India (Ward + Census Data, 2011). ML Infomap. Geospatial data. https://search.libraries.mit.edu/record/gismit:in_jabalpur_f7ward_2011","content_type":["Geospatial + data"],"contributors":[{"value":"ML INFOMAP","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2016-04-25"},{"kind":"Coverage","value":"2011-01-01"},{"kind":"Coverage","value":"2011"}],"format":"Vector","links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/in_jabalpur_f7ward_2011.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/in_jabalpur_f7ward_2011.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/in_jabalpur_f7ward_2011.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (79.846140, + 80.022830, 23.229930, 23.090740)"},{"kind":"Geometry","geoshape":"BBOX (79.846140, + 80.022830, 23.229930, 23.090740)"}],"publication_information":["ML Infomap","GIS + Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"}],"subjects":[{"value":["Society"],"kind":"DCAT; + Theme"},{"value":["Boundaries"],"kind":"DCAT; Theme"},{"value":["India--Jabalpur"],"kind":"Dublin + Core; Spatial"},{"value":["Administrative and political divisions"],"kind":"Dublin + Core; Subject"},{"value":["Election districts"],"kind":"Dublin Core; Subject"},{"value":["Demographic + surveys"],"kind":"Dublin Core; Subject"},{"value":["society"],"kind":"Dublin + Core; Subject"},{"value":["boundaries"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject + scheme not provided"},{"value":["G-polygon"],"kind":"Subject scheme not provided"}],"summary":["This + layer shows the ward boundaries in Jabalpur (City in Madhya Pradesh, India) + in 2011. It includes demographic and socio-economic data linked to the 2011 + Primary Census Abstract."]},"sort":[1.0,1461542400000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:in_varanasi_f7ward_2011","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:in_varanasi_f7ward_2011","timdex_record_id":"gismit:in_varanasi_f7ward_2011","title":"Varanasi, + India (Ward Census Data, 2011)","citation":"ML INFOMAP. Varanasi, India (Ward + Census Data, 2011). ML Infomap. Geospatial data. https://search.libraries.mit.edu/record/gismit:in_varanasi_f7ward_2011","content_type":["Geospatial + data"],"contributors":[{"value":"ML INFOMAP","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2016-04-25"},{"kind":"Coverage","value":"2011-01-01"},{"kind":"Coverage","value":"2011"}],"format":"Vector","links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/in_varanasi_f7ward_2011.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/in_varanasi_f7ward_2011.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/in_varanasi_f7ward_2011.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (82.926800, + 83.048200, 25.403860, 25.246710)"},{"kind":"Geometry","geoshape":"BBOX (82.926800, + 83.048200, 25.403860, 25.246710)"}],"publication_information":["ML Infomap","GIS + Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"}],"subjects":[{"value":["Society"],"kind":"DCAT; + Theme"},{"value":["Boundaries"],"kind":"DCAT; Theme"},{"value":["India--Va?ra?nasi + (District)"],"kind":"Dublin Core; Spatial"},{"value":["Administrative and + political divisions"],"kind":"Dublin Core; Subject"},{"value":["Election districts"],"kind":"Dublin + Core; Subject"},{"value":["Demographic surveys"],"kind":"Dublin Core; Subject"},{"value":["society"],"kind":"Dublin + Core; Subject"},{"value":["boundaries"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject + scheme not provided"},{"value":["G-polygon"],"kind":"Subject scheme not provided"}],"summary":["This + layer shows the ward boundaries in Varanasi (City in Uttar Pradesh, India) + in 2011. It includes demographic and socio-economic data linked to the 2011 + Primary Census Abstract."]},"sort":[1.0,1461542400000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:in_visakhapatnam_f7ward_2011","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:in_visakhapatnam_f7ward_2011","timdex_record_id":"gismit:in_visakhapatnam_f7ward_2011","title":"Visakhapatnam, + India (Ward Census Data, 2011)","citation":"ML INFOMAP. Visakhapatnam, India + (Ward Census Data, 2011). ML Infomap. Geospatial data. https://search.libraries.mit.edu/record/gismit:in_visakhapatnam_f7ward_2011","content_type":["Geospatial + data"],"contributors":[{"value":"ML INFOMAP","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2016-04-25"},{"kind":"Coverage","value":"2011-01-01"},{"kind":"Coverage","value":"2011"}],"format":"Vector","links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/in_visakhapatnam_f7ward_2011.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/in_visakhapatnam_f7ward_2011.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/in_visakhapatnam_f7ward_2011.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (83.084050, + 83.408650, 17.874250, 17.547400)"},{"kind":"Geometry","geoshape":"BBOX (83.084050, + 83.408650, 17.874250, 17.547400)"}],"publication_information":["ML Infomap","GIS + Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"}],"subjects":[{"value":["Society"],"kind":"DCAT; + Theme"},{"value":["Boundaries"],"kind":"DCAT; Theme"},{"value":["India--Vishakhapatnam"],"kind":"Dublin + Core; Spatial"},{"value":["Administrative and political divisions"],"kind":"Dublin + Core; Subject"},{"value":["Election districts"],"kind":"Dublin Core; Subject"},{"value":["Demographic + surveys"],"kind":"Dublin Core; Subject"},{"value":["society"],"kind":"Dublin + Core; Subject"},{"value":["boundaries"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject + scheme not provided"},{"value":["G-polygon"],"kind":"Subject scheme not provided"}],"summary":["This + layer shows the ward boundaries in Visakhapatnam (City in Andhra Pradesh, + India) in 2011. It includes demographic and socio-economic data linked to + the 2011 Primary Census Abstract."]},"sort":[1.0,1461542400000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:in_bhopal_f7ward_2011","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:in_bhopal_f7ward_2011","timdex_record_id":"gismit:in_bhopal_f7ward_2011","title":"Bhopal, + India (Ward Census Data, 2011)","citation":"ML INFOMAP. Bhopal, India (Ward + Census Data, 2011). ML Infomap. Geospatial data. https://search.libraries.mit.edu/record/gismit:in_bhopal_f7ward_2011","content_type":["Geospatial + data"],"contributors":[{"value":"ML INFOMAP","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2016-04-25"},{"kind":"Coverage","value":"2011-01-01"},{"kind":"Coverage","value":"2011"}],"format":"Vector","links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/in_bhopal_f7ward_2011.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/in_bhopal_f7ward_2011.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/in_bhopal_f7ward_2011.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (77.258670, + 77.503260, 23.342680, 23.143850)"},{"kind":"Geometry","geoshape":"BBOX (77.258670, + 77.503260, 23.342680, 23.143850)"}],"publication_information":["ML Infomap","GIS + Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"}],"subjects":[{"value":["Society"],"kind":"DCAT; + Theme"},{"value":["Boundaries"],"kind":"DCAT; Theme"},{"value":["India--Bhopal"],"kind":"Dublin + Core; Spatial"},{"value":["Administrative and political divisions"],"kind":"Dublin + Core; Subject"},{"value":["Election districts"],"kind":"Dublin Core; Subject"},{"value":["Demographic + surveys"],"kind":"Dublin Core; Subject"},{"value":["society"],"kind":"Dublin + Core; Subject"},{"value":["boundaries"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject + scheme not provided"},{"value":["G-polygon"],"kind":"Subject scheme not provided"}],"summary":["This + layer shows the ward boundaries in Bhopal (Capital of Madhya Pradesh, India) + in 2011. It includes demographic and socio-economic data linked to the 2011 + Primary Census Abstract."]},"sort":[1.0,1461542400000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:in_meerut_f7ward_2011","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:in_meerut_f7ward_2011","timdex_record_id":"gismit:in_meerut_f7ward_2011","title":"Meerut, + India (Ward Census Data, 2011)","citation":"ML INFOMAP. Meerut, India (Ward + Census Data, 2011). ML Infomap. Geospatial data. https://search.libraries.mit.edu/record/gismit:in_meerut_f7ward_2011","content_type":["Geospatial + data"],"contributors":[{"value":"ML INFOMAP","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2016-04-25"},{"kind":"Coverage","value":"2011-01-01"},{"kind":"Coverage","value":"2011"}],"format":"Vector","links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/in_meerut_f7ward_2011.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/in_meerut_f7ward_2011.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/in_meerut_f7ward_2011.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (77.617350, + 77.775680, 29.076860, 28.904870)"},{"kind":"Geometry","geoshape":"BBOX (77.617350, + 77.775680, 29.076860, 28.904870)"}],"publication_information":["ML Infomap","GIS + Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"}],"subjects":[{"value":["Society"],"kind":"DCAT; + Theme"},{"value":["Boundaries"],"kind":"DCAT; Theme"},{"value":["India--Meerut"],"kind":"Dublin + Core; Spatial"},{"value":["Administrative and political divisions"],"kind":"Dublin + Core; Subject"},{"value":["Election districts"],"kind":"Dublin Core; Subject"},{"value":["Demographic + surveys"],"kind":"Dublin Core; Subject"},{"value":["society"],"kind":"Dublin + Core; Subject"},{"value":["boundaries"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject + scheme not provided"},{"value":["G-polygon"],"kind":"Subject scheme not provided"}],"summary":["This + layer shows the ward boundaries in Meerut (City in Uttar Pradesh, India) in + 2011. It includes demographic and socio-economic data linked to the 2011 Primary + Census Abstract."]},"sort":[1.0,1461542400000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:dz_f7regions_2016","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:dz_f7regions_2016","timdex_record_id":"gismit:dz_f7regions_2016","title":"Algeria + (2-Digit Postal Code Areas, 2016)","citation":"GfK GeoMarketing GmbH. Algeria + (2-Digit Postal Code Areas, 2016). GfK GeoMarketing GmbH. Geospatial data. + https://search.libraries.mit.edu/record/gismit:dz_f7regions_2016","content_type":["Geospatial + data"],"contributors":[{"value":"GfK GeoMarketing GmbH","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2016-01-01"}],"format":"Vector","identifiers":[{"value":"Algeria + 2-digit postcode areas 2016Copy","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_f7regions_2016.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_f7regions_2016.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/dz_f7regions_2016.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-8.667992, + 11.994246, 37.089704, 18.956237)"},{"kind":"Geometry","geoshape":"BBOX (-8.667992, + 11.994246, 37.089704, 18.956237)"}],"publication_information":["GfK GeoMarketing + GmbH","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"Access + is limited to members of the MIT community only -- maps may not be given to + anyone not officially and currently affiliated with MIT. Maps may be used + only for research, educational, and other scholarly purposes; it is permissible + to use images created from the software and data in scholarly publications + and dissertations. Any other use, unless it falls within the Fair Use provisions + of U.S. copyright law, is not permitted.The copyright of GfK GeoMarketing + must be placed on the maps.The data can be published as a Bitmap or comparable + format."}],"subjects":[{"value":["Location"],"kind":"DCAT; Theme"},{"value":["Algeria"],"kind":"Dublin + Core; Spatial"},{"value":["Postal codes"],"kind":"Dublin Core; Subject"},{"value":["location"],"kind":"Dublin + Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["G-polygon"],"kind":"Subject + scheme not provided"}]},"sort":[1.0,1451606400000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:dz_p8postcode2dig_2016","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:dz_p8postcode2dig_2016","timdex_record_id":"gismit:dz_p8postcode2dig_2016","title":"Algeria + (2-Digit Postal Code Areas, 2016)","citation":"GfK GeoMarketing GmbH. Algeria + (2-Digit Postal Code Areas, 2016). GfK GeoMarketing GmbH. Geospatial data. + https://search.libraries.mit.edu/record/gismit:dz_p8postcode2dig_2016","content_type":["Geospatial + data"],"contributors":[{"value":"GfK GeoMarketing GmbH","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2016-01-01"}],"format":"Vector","identifiers":[{"value":"Algeria + 2-digit postcode areas 2016Copy","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_p8postcode2dig_2016.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_p8postcode2dig_2016.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/dz_p8postcode2dig_2016.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-8.667992, + 11.994246, 37.089704, 18.956237)"},{"kind":"Geometry","geoshape":"BBOX (-8.667992, + 11.994246, 37.089704, 18.956237)"}],"publication_information":["GfK GeoMarketing + GmbH","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"Access + is limited to members of the MIT community only -- maps may not be given to + anyone not officially and currently affiliated with MIT. Maps may be used + only for research, educational, and other scholarly purposes; it is permissible + to use images created from the software and data in scholarly publications + and dissertations. Any other use, unless it falls within the Fair Use provisions + of U.S. copyright law, is not permitted.The copyright of GfK GeoMarketing + must be placed on the maps.The data can be published as a Bitmap or comparable + format."}],"subjects":[{"value":["Location"],"kind":"DCAT; Theme"},{"value":["Algeria"],"kind":"Dublin + Core; Spatial"},{"value":["Postal codes"],"kind":"Dublin Core; Subject"},{"value":["location"],"kind":"Dublin + Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["G-polygon"],"kind":"Subject + scheme not provided"}]},"sort":[1.0,1451606400000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_IN_RAURKELA_F7WARD_2011","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_IN_RAURKELA_F7WARD_2011","timdex_record_id":"gismit:SDE_DATA_IN_RAURKELA_F7WARD_2011","title":"India, + Raurkela (Ward Census Data, 2011)","citation":"Registrar General and Census + Commissioner of India. India, Raurkela (Ward Census Data, 2011). ML Infomap. + Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_IN_RAURKELA_F7WARD_2011","content_type":["Geospatial + data"],"contributors":[{"value":"Registrar General and Census Commissioner + of India","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2015-12-04"},{"kind":"Coverage","value":"2015-12-04"},{"kind":"Coverage","value":"2015"}],"format":"Vector","identifiers":[{"value":"IN_RAURKELA_F7WARD_2011","kind":"Not + specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_IN_RAURKELA_F7WARD_2011.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_IN_RAURKELA_F7WARD_2011.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/SDE_DATA_IN_RAURKELA_F7WARD_2011.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (84.789650, + 84.940826, 22.275810, 22.179729)"},{"kind":"Geometry","geoshape":"BBOX (84.789650, + 84.940826, 22.275810, 22.179729)"}],"publication_information":["ML Infomap","GIS + Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"}],"subjects":[{"value":["Boundaries"],"kind":"DCAT; + Theme"},{"value":["Economy"],"kind":"DCAT; Theme"},{"value":["Society"],"kind":"DCAT; + Theme"},{"value":["India--Raurkela"],"kind":"Dublin Core; Spatial"},{"value":["Administrative + and political divisions"],"kind":"Dublin Core; Subject"},{"value":["Demographic + surveys"],"kind":"Dublin Core; Subject"},{"value":["Tribes"],"kind":"Dublin + Core; Subject"},{"value":["Caste"],"kind":"Dublin Core; Subject"},{"value":["Literacy"],"kind":"Dublin + Core; Subject"},{"value":["Population"],"kind":"Dublin Core; Subject"},{"value":["boundaries"],"kind":"Dublin + Core; Subject"},{"value":["economy"],"kind":"Dublin Core; Subject"},{"value":["society"],"kind":"Dublin + Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["G-polygon"],"kind":"Subject + scheme not provided"}],"summary":["This layer shows the ward boundaries in + Raurkela (city in Odisha, India) in 2011, linked to India''s 2011 Primary + Census Abstract."]},"sort":[1.0,1449187200000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_IN_ODISHA_F7VILLAGE_2011","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_IN_ODISHA_F7VILLAGE_2011","timdex_record_id":"gismit:SDE_DATA_IN_ODISHA_F7VILLAGE_2011","title":"India, + Odisha (Village Census Data, 2011)","citation":"Registrar General and Census + Commissioner of India. India, Odisha (Village Census Data, 2011). ML Infomap. + Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_IN_ODISHA_F7VILLAGE_2011","content_type":["Geospatial + data"],"contributors":[{"value":"Registrar General and Census Commissioner + of India","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2015-12-04"},{"kind":"Coverage","value":"2015-12-04"},{"kind":"Coverage","value":"2015"}],"format":"Vector","identifiers":[{"value":"IN_ODISHA_F7VILLAGE_2011","kind":"Not + specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_IN_ODISHA_F7VILLAGE_2011.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_IN_ODISHA_F7VILLAGE_2011.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/SDE_DATA_IN_ODISHA_F7VILLAGE_2011.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (81.390770, + 87.488937, 22.564871, 17.821276)"},{"kind":"Geometry","geoshape":"BBOX (81.390770, + 87.488937, 22.564871, 17.821276)"}],"publication_information":["ML Infomap","GIS + Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"}],"subjects":[{"value":["Boundaries"],"kind":"DCAT; + Theme"},{"value":["Economy"],"kind":"DCAT; Theme"},{"value":["Society"],"kind":"DCAT; + Theme"},{"value":["India--Odisha"],"kind":"Dublin Core; Spatial"},{"value":["Villages"],"kind":"Dublin + Core; Subject"},{"value":["Administrative and political divisions"],"kind":"Dublin + Core; Subject"},{"value":["Demographic surveys"],"kind":"Dublin Core; Subject"},{"value":["Tribes"],"kind":"Dublin + Core; Subject"},{"value":["Caste"],"kind":"Dublin Core; Subject"},{"value":["Literacy"],"kind":"Dublin + Core; Subject"},{"value":["Population"],"kind":"Dublin Core; Subject"},{"value":["boundaries"],"kind":"Dublin + Core; Subject"},{"value":["economy"],"kind":"Dublin Core; Subject"},{"value":["society"],"kind":"Dublin + Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["G-polygon"],"kind":"Subject + scheme not provided"}],"summary":["This layer shows the village boundaries + in Odisha, India in 2011, linked to India''s 2011 Primary Census Abstract."]},"sort":[1.0,1449187200000]}]},"aggregations":{"languages":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[{"key":"eng","doc_count":873}]},"content_type":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[{"key":"geospatial + data","doc_count":893}]},"subjects":{"doc_count":6871,"subject_names":{"doc_count_error_upper_bound":0,"sum_other_doc_count":2998,"buckets":[{"key":"datasets","doc_count":891},{"key":"boundaries","doc_count":764},{"key":"g-polygon","doc_count":475},{"key":"location","doc_count":406},{"key":"entity + point","doc_count":315},{"key":"administrative and political divisions","doc_count":262},{"key":"society","doc_count":220},{"key":"transportation","doc_count":220},{"key":"names, + geographical","doc_count":174},{"key":"economy","doc_count":146}]}},"content_format":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[{"key":"vector","doc_count":884},{"key":"point","doc_count":7},{"key":"raster","doc_count":2}]},"literary_form":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[]},"source":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[{"key":"mit + gis resources","doc_count":893}]},"contributors":{"doc_count":1083,"contributor_names":{"doc_count_error_upper_bound":0,"sum_other_doc_count":381,"buckets":[{"key":"gfk + geomarketing gmbh","doc_count":216},{"key":"united states. national imagery + and mapping agency","doc_count":104},{"key":"environmental systems research + institute (redlands, calif.)","doc_count":98},{"key":"national imagery and + mapping agency","doc_count":60},{"key":"surveyor general, cape town, department + of land affairs","doc_count":45},{"key":"esri","doc_count":41},{"key":"tele + atlas b.v.","doc_count":41},{"key":"and international publishers n.v.","doc_count":36},{"key":"ml + infomap","doc_count":32},{"key":"usgs","doc_count":29}]}}}}' + recorded_at: Wed, 14 Feb 2024 16:37:54 GMT +recorded_with: VCR 6.2.0 diff --git a/test/vcr_cassettes/graphqlv2_geobox_western_hemisphere.yml b/test/vcr_cassettes/graphqlv2_geobox_western_hemisphere.yml new file mode 100644 index 00000000..0c616e1c --- /dev/null +++ b/test/vcr_cassettes/graphqlv2_geobox_western_hemisphere.yml @@ -0,0 +1,436 @@ +--- +http_interactions: +- request: + method: post + uri: http://localhost:9200/timdex-prod/_search + body: + encoding: UTF-8 + string: '{"from":"0","size":20,"query":{"bool":{"should":null,"must":[{"bool":{"must":{"match_all":{}},"filter":{"geo_bounding_box":{"locations.geoshape":{"top":90.0,"bottom":-90.0,"left":180.0,"right":0.0}}}}}],"filter":[]}},"aggregations":{"contributors":{"nested":{"path":"contributors"},"aggs":{"contributor_names":{"terms":{"field":"contributors.value.keyword"}}}},"content_type":{"terms":{"field":"content_type"}},"content_format":{"terms":{"field":"format"}},"languages":{"terms":{"field":"languages.keyword"}},"literary_form":{"terms":{"field":"literary_form"}},"source":{"terms":{"field":"source"}},"subjects":{"nested":{"path":"subjects"},"aggs":{"subject_names":{"terms":{"field":"subjects.value.keyword"}}}}},"sort":[{"_score":{"order":"desc"}},{"dates.value.as_date":{"order":"desc","nested":{"path":"dates"}}}]}' + headers: + User-Agent: + - 'opensearch-ruby/3.1.0 (RUBY_VERSION: 3.2.2; darwin arm64; Faraday v2.9.0)' + Content-Type: + - application/json + Accept-Encoding: + - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 + Accept: + - "*/*" + response: + status: + code: 200 + message: OK + headers: + Content-Type: + - application/json; charset=UTF-8 + Content-Length: + - '48052' + body: + encoding: ASCII-8BIT + string: '{"took":10,"timed_out":false,"_shards":{"total":1,"successful":1,"skipped":0,"failed":0},"hits":{"total":{"value":1449,"relation":"eq"},"max_score":null,"hits":[{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:us_ma_boston_g47parcels_2018","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:us_ma_boston_g47parcels_2018","timdex_record_id":"gismit:us_ma_boston_g47parcels_2018","title":"Boston, + MA (Land parcels, 2018)","citation":"City of Boston Assessing Department. + Boston, MA (Land parcels, 2018). GIS Lab, MIT Libraries. Geospatial data. + https://search.libraries.mit.edu/record/gismit:us_ma_boston_g47parcels_2018","content_type":["Geospatial + data"],"contributors":[{"value":"City of Boston Assessing Department","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2018-01-01"},{"kind":"Coverage","value":"2015-01-01"},{"kind":"Coverage","value":"2015"}],"format":"Vector","identifiers":[{"value":"us_ma_boston_g47parcels_2018","kind":"Not + specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/us_ma_boston_g47parcels_2018.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/us_ma_boston_g47parcels_2018.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/us_ma_boston_g47parcels_2018.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-71.190913, + -70.868654, 42.397012, 42.227864)"},{"kind":"Geometry","geoshape":"BBOX (-71.190913, + -70.868654, 42.397012, 42.227864)"}],"publication_information":["GIS Lab, + MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"N/A"}],"subjects":[{"value":["Economy"],"kind":"DCAT; + Theme"},{"value":["Boundaries"],"kind":"DCAT; Theme"},{"value":["Location"],"kind":"DCAT; + Theme"},{"value":["Massachusetts--Boston"],"kind":"Dublin Core; Spatial"},{"value":["Land + use"],"kind":"Dublin Core; Subject"},{"value":["Neighborhoods"],"kind":"Dublin + Core; Subject"},{"value":["Administrative and political divisions"],"kind":"Dublin + Core; Subject"},{"value":["Land value taxation"],"kind":"Dublin Core; Subject"},{"value":["Land + tenure"],"kind":"Dublin Core; Subject"},{"value":["economy"],"kind":"Dublin + Core; Subject"},{"value":["planningCadastre"],"kind":"Dublin Core; Subject"},{"value":["boundaries"],"kind":"Dublin + Core; Subject"},{"value":["location"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject + scheme not provided"},{"value":["G-polygon"],"kind":"Subject scheme not provided"}],"summary":["City + of Boston property parcel data from FY 2018 was joined with parcel boundaries + from FY 2018. All data is from the City of Boston Assessor''s office and represents + data from 2017."]},"sort":[1.0,1514764800000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:us_ma_boston_g47parcels_2017","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:us_ma_boston_g47parcels_2017","timdex_record_id":"gismit:us_ma_boston_g47parcels_2017","title":"Boston, + MA (Land parcels, 2017)","citation":"City of Boston Assessing Department. + Boston, MA (Land parcels, 2017). GIS Lab, MIT Libraries. Geospatial data. + https://search.libraries.mit.edu/record/gismit:us_ma_boston_g47parcels_2017","content_type":["Geospatial + data"],"contributors":[{"value":"City of Boston Assessing Department","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2017-01-01"},{"kind":"Coverage","value":"2017-01-01"},{"kind":"Coverage","value":"2017"}],"format":"Vector","identifiers":[{"value":"us_ma_boston_g47parcels_2017","kind":"Not + specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/us_ma_boston_g47parcels_2017.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/us_ma_boston_g47parcels_2017.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/us_ma_boston_g47parcels_2017.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-71.190913, + -70.923055, 42.397004, 42.227856)"},{"kind":"Geometry","geoshape":"BBOX (-71.190913, + -70.923055, 42.397004, 42.227856)"}],"publication_information":["GIS Lab, + MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"N/A"}],"subjects":[{"value":["Economy"],"kind":"DCAT; + Theme"},{"value":["Boundaries"],"kind":"DCAT; Theme"},{"value":["Location"],"kind":"DCAT; + Theme"},{"value":["Massachusetts--Boston"],"kind":"Dublin Core; Spatial"},{"value":["Land + use"],"kind":"Dublin Core; Subject"},{"value":["Neighborhoods"],"kind":"Dublin + Core; Subject"},{"value":["Administrative and political divisions"],"kind":"Dublin + Core; Subject"},{"value":["Land value taxation"],"kind":"Dublin Core; Subject"},{"value":["Land + tenure"],"kind":"Dublin Core; Subject"},{"value":["economy"],"kind":"Dublin + Core; Subject"},{"value":["planningCadastre"],"kind":"Dublin Core; Subject"},{"value":["boundaries"],"kind":"Dublin + Core; Subject"},{"value":["location"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject + scheme not provided"},{"value":["G-polygon"],"kind":"Subject scheme not provided"}],"summary":["City + of Boston property parcel data from FY 2017 was joined with parcel boundaries + from FY 2017. All data is from the City of Boston Assessor''s office and represents + data from 2016."]},"sort":[1.0,1483228800000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:US_MA_BOSTON_G47PARCELS_2016","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:US_MA_BOSTON_G47PARCELS_2016","timdex_record_id":"gismit:US_MA_BOSTON_G47PARCELS_2016","title":"Boston, + MA (Land parcels, 2016)","citation":"City of Boston Assessing Department. + Boston, MA (Land parcels, 2016). GIS Lab, MIT Libraries. Geospatial data. + https://search.libraries.mit.edu/record/gismit:US_MA_BOSTON_G47PARCELS_2016","content_type":["Geospatial + data"],"contributors":[{"value":"City of Boston Assessing Department","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2017-01-01"},{"kind":"Coverage","value":"2016-01-01"},{"kind":"Coverage","value":"2016"}],"format":"Vector","identifiers":[{"value":"us_ma_boston_g47parcels_2016","kind":"Not + specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/US_MA_BOSTON_G47PARCELS_2016.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/US_MA_BOSTON_G47PARCELS_2016.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/US_MA_BOSTON_G47PARCELS_2016.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-71.190913, + -70.923055, 42.397004, 42.227856)"},{"kind":"Geometry","geoshape":"BBOX (-71.190913, + -70.923055, 42.397004, 42.227856)"}],"publication_information":["GIS Lab, + MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"N/A"}],"subjects":[{"value":["Economy"],"kind":"DCAT; + Theme"},{"value":["Boundaries"],"kind":"DCAT; Theme"},{"value":["Location"],"kind":"DCAT; + Theme"},{"value":["Boston"],"kind":"Dublin Core; Spatial"},{"value":["USA"],"kind":"Dublin + Core; Spatial"},{"value":["Massachusetts"],"kind":"Dublin Core; Spatial"},{"value":["MA"],"kind":"Dublin + Core; Spatial"},{"value":["parcels"],"kind":"Dublin Core; Subject"},{"value":["land + parcels"],"kind":"Dublin Core; Subject"},{"value":["land use"],"kind":"Dublin + Core; Subject"},{"value":["wards"],"kind":"Dublin Core; Subject"},{"value":["polygon"],"kind":"Dublin + Core; Subject"},{"value":["tax"],"kind":"Dublin Core; Subject"},{"value":["land + ownership"],"kind":"Dublin Core; Subject"},{"value":["improvements"],"kind":"Dublin + Core; Subject"},{"value":["neighborhoods"],"kind":"Dublin Core; Subject"},{"value":["lot + size"],"kind":"Dublin Core; Subject"},{"value":["economy"],"kind":"Dublin + Core; Subject"},{"value":["planningCadastre"],"kind":"Dublin Core; Subject"},{"value":["boundaries"],"kind":"Dublin + Core; Subject"},{"value":["location"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject + scheme not provided"},{"value":["G-polygon"],"kind":"Subject scheme not provided"}],"summary":["City + of Boston property parcel data from FY 2016 was joined with parcel boundaries + from FY 2016. All data is from the City of Boston Assessor''s office and represents + data from 2015."]},"sort":[1.0,1483228800000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:dz_a1cities_10k20k_2016","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:dz_a1cities_10k20k_2016","timdex_record_id":"gismit:dz_a1cities_10k20k_2016","title":"Algeria + (Cities (10k-20k), 2016)","citation":"GfK GeoMarketing GmbH. Algeria (Cities + (10k-20k), 2016). GIS Lab, MIT Libraries. Geospatial data. https://search.libraries.mit.edu/record/gismit:dz_a1cities_10k20k_2016","content_type":["Geospatial + data"],"contributors":[{"value":"GfK GeoMarketing GmbH","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2016-12-01"}],"format":"Vector","identifiers":[{"value":"dz_a1cities_10k20k_2016","kind":"Not + specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_a1cities_10k20k_2016.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_a1cities_10k20k_2016.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/dz_a1cities_10k20k_2016.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-1.423186, + 8.313771, 36.917160, 29.388636)"},{"kind":"Geometry","geoshape":"BBOX (-1.423186, + 8.313771, 36.917160, 29.388636)"}],"publication_information":["GIS Lab, MIT + Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"License + required"}],"subjects":[{"value":["Location"],"kind":"DCAT; Theme"},{"value":["Algeria"],"kind":"Dublin + Core; Spatial"},{"value":["Cities and towns"],"kind":"Dublin Core; Subject"},{"value":["location"],"kind":"Dublin + Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity + point"],"kind":"Subject scheme not provided"}]},"sort":[1.0,1480550400000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:dz_a1cities_20k50k_2016","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:dz_a1cities_20k50k_2016","timdex_record_id":"gismit:dz_a1cities_20k50k_2016","title":"Algeria + (Cities (20k-50k), 2016)","citation":"GfK GeoMarketing GmbH. Algeria (Cities + (20k-50k), 2016). GIS Lab, MIT Libraries. Geospatial data. https://search.libraries.mit.edu/record/gismit:dz_a1cities_20k50k_2016","content_type":["Geospatial + data"],"contributors":[{"value":"GfK GeoMarketing GmbH","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2016-12-01"}],"format":"Vector","identifiers":[{"value":"dz_a1cities_20k50k_2016","kind":"Not + specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_a1cities_20k50k_2016.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_a1cities_20k50k_2016.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/dz_a1cities_20k50k_2016.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-1.856799, + 8.443333, 37.007167, 19.573696)"},{"kind":"Geometry","geoshape":"BBOX (-1.856799, + 8.443333, 37.007167, 19.573696)"}],"publication_information":["GIS Lab, MIT + Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"License + required"}],"subjects":[{"value":["Location"],"kind":"DCAT; Theme"},{"value":["Algeria"],"kind":"Dublin + Core; Spatial"},{"value":["Cities and towns"],"kind":"Dublin Core; Subject"},{"value":["location"],"kind":"Dublin + Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity + point"],"kind":"Subject scheme not provided"}]},"sort":[1.0,1480550400000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:dz_a1cities_50k100k_2016","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:dz_a1cities_50k100k_2016","timdex_record_id":"gismit:dz_a1cities_50k100k_2016","title":"Algeria + (Cities (50k-100k), 2016)","citation":"GfK GeoMarketing GmbH. Algeria (Cities + (50k-100k), 2016). GIS Lab, MIT Libraries. Geospatial data. https://search.libraries.mit.edu/record/gismit:dz_a1cities_50k100k_2016","content_type":["Geospatial + data"],"contributors":[{"value":"GfK GeoMarketing GmbH","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2016-12-01"}],"format":"Vector","identifiers":[{"value":"dz_a1cities_50k100k_2016","kind":"Not + specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_a1cities_50k100k_2016.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_a1cities_50k100k_2016.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/dz_a1cities_50k100k_2016.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-8.147435, + 8.129167, 36.823460, 22.785000)"},{"kind":"Geometry","geoshape":"BBOX (-8.147435, + 8.129167, 36.823460, 22.785000)"}],"publication_information":["GIS Lab, MIT + Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"License + required"}],"subjects":[{"value":["Location"],"kind":"DCAT; Theme"},{"value":["Algeria"],"kind":"Dublin + Core; Spatial"},{"value":["Cities and towns"],"kind":"Dublin Core; Subject"},{"value":["location"],"kind":"Dublin + Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity + point"],"kind":"Subject scheme not provided"}]},"sort":[1.0,1480550400000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:dz_p2hig_2016","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:dz_p2hig_2016","timdex_record_id":"gismit:dz_p2hig_2016","title":"Algeria + (Cities (100k-500k), 2016)","citation":"GfK GeoMarketing GmbH. Algeria (Cities + (100k-500k), 2016). GIS Lab, MIT Libraries. Geospatial data. https://search.libraries.mit.edu/record/gismit:dz_p2hig_2016","content_type":["Geospatial + data"],"contributors":[{"value":"GfK GeoMarketing GmbH","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2016-12-01"}],"format":"Vector","identifiers":[{"value":"dz_a1cities_100k500k_2016","kind":"Not + specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_p2hig_2016.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_p2hig_2016.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/dz_p2hig_2016.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-2.216667, + 8.124167, 36.900000, 31.616667)"},{"kind":"Geometry","geoshape":"BBOX (-2.216667, + 8.124167, 36.900000, 31.616667)"}],"publication_information":["GIS Lab, MIT + Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"License + required"}],"subjects":[{"value":["Transportation"],"kind":"DCAT; Theme"},{"value":["Algeria"],"kind":"Dublin + Core; Spatial"},{"value":["Roads"],"kind":"Dublin Core; Subject"},{"value":["transportation"],"kind":"Dublin + Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity + point"],"kind":"Subject scheme not provided"}]},"sort":[1.0,1480550400000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:dz_c28hydpoly_2016","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:dz_c28hydpoly_2016","timdex_record_id":"gismit:dz_c28hydpoly_2016","title":"Algeria + (Cities (10k-20k), 2016)","citation":"GfK GeoMarketing GmbH. Algeria (Cities + (10k-20k), 2016). GIS Lab, MIT Libraries. Geospatial data. https://search.libraries.mit.edu/record/gismit:dz_c28hydpoly_2016","content_type":["Geospatial + data"],"contributors":[{"value":"GfK GeoMarketing GmbH","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2016-12-01"}],"format":"Vector","identifiers":[{"value":"dz_a1cities_10k20k_2016","kind":"Not + specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_c28hydpoly_2016.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_c28hydpoly_2016.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/dz_c28hydpoly_2016.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-1.423186, + 8.313771, 36.917160, 29.388636)"},{"kind":"Geometry","geoshape":"BBOX (-1.423186, + 8.313771, 36.917160, 29.388636)"}],"publication_information":["GIS Lab, MIT + Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"License + required"}],"subjects":[{"value":["Algeria"],"kind":"Dublin Core; Spatial"},{"value":["Hydrology"],"kind":"Dublin + Core; Subject"},{"value":["inlandWaters"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject + scheme not provided"},{"value":["Entity point"],"kind":"Subject scheme not + provided"}]},"sort":[1.0,1480550400000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:dz_p2roads_2016","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:dz_p2roads_2016","timdex_record_id":"gismit:dz_p2roads_2016","title":"Algeria + (Roads, 2016)","citation":"GfK GeoMarketing GmbH. Algeria (Roads, 2016). GIS + Lab, MIT Libraries. Geospatial data. https://search.libraries.mit.edu/record/gismit:dz_p2roads_2016","content_type":["Geospatial + data"],"contributors":[{"value":"GfK GeoMarketing GmbH","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2016-12-01"}],"format":"Vector","identifiers":[{"value":"dz_p2roads_2016","kind":"Not + specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_p2roads_2016.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_p2roads_2016.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/dz_p2roads_2016.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-8.154491, + 10.548201, 36.919383, 19.442285)"},{"kind":"Geometry","geoshape":"BBOX (-8.154491, + 10.548201, 36.919383, 19.442285)"}],"publication_information":["GIS Lab, MIT + Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"License + required"}],"subjects":[{"value":["Transportation"],"kind":"DCAT; Theme"},{"value":["Algeria"],"kind":"Dublin + Core; Spatial"},{"value":["Roads"],"kind":"Dublin Core; Subject"},{"value":["transportation"],"kind":"Dublin + Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["String"],"kind":"Subject + scheme not provided"}]},"sort":[1.0,1480550400000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:dz_a1cities_100k500k_2016","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:dz_a1cities_100k500k_2016","timdex_record_id":"gismit:dz_a1cities_100k500k_2016","title":"Algeria + (Cities (100k-500k), 2016)","citation":"GfK GeoMarketing GmbH. Algeria (Cities + (100k-500k), 2016). GIS Lab, MIT Libraries. Geospatial data. https://search.libraries.mit.edu/record/gismit:dz_a1cities_100k500k_2016","content_type":["Geospatial + data"],"contributors":[{"value":"GfK GeoMarketing GmbH","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2016-12-01"}],"format":"Vector","identifiers":[{"value":"dz_a1cities_100k500k_2016","kind":"Not + specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_a1cities_100k500k_2016.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_a1cities_100k500k_2016.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/dz_a1cities_100k500k_2016.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-2.216667, + 8.124167, 36.900000, 31.616667)"},{"kind":"Geometry","geoshape":"BBOX (-2.216667, + 8.124167, 36.900000, 31.616667)"}],"publication_information":["GIS Lab, MIT + Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"License + required"}],"subjects":[{"value":["Location"],"kind":"DCAT; Theme"},{"value":["Algeria"],"kind":"Dublin + Core; Spatial"},{"value":["Cities and towns"],"kind":"Dublin Core; Subject"},{"value":["location"],"kind":"Dublin + Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity + point"],"kind":"Subject scheme not provided"}]},"sort":[1.0,1480550400000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:dz_p61airports_2016","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:dz_p61airports_2016","timdex_record_id":"gismit:dz_p61airports_2016","title":"Algeria + (Airports, 2016)","citation":"GfK GeoMarketing GmbH. Algeria (Airports, 2016). + GfK GeoMarketing GmbH. Geospatial data. https://search.libraries.mit.edu/record/gismit:dz_p61airports_2016","content_type":["Geospatial + data"],"contributors":[{"value":"GfK GeoMarketing GmbH","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2016-12-01"}],"format":"Vector","identifiers":[{"value":"dz_p61airports_2016","kind":"Not + specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_p61airports_2016.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_p61airports_2016.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/dz_p61airports_2016.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-8.166223, + 9.638056, 29.236944, 22.816967)"},{"kind":"Geometry","geoshape":"BBOX (-8.166223, + 9.638056, 29.236944, 22.816967)"}],"publication_information":["GfK GeoMarketing + GmbH","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"Access + is limited to members of the MIT community only -- maps may not be given to + anyone not officially and currently affiliated with MIT. Maps may be used + only for research, educational, and other scholarly purposes; it is permissible + to use images created from the software and data in scholarly publications + and dissertations. Any other use, unless it falls within the Fair Use provisions + of U.S. copyright law, is not permitted.The copyright of GfK GeoMarketing + must be placed on the maps.The data can be published as a Bitmap or comparable + format."}],"subjects":[{"value":["Transportation"],"kind":"DCAT; Theme"},{"value":["Algeria"],"kind":"Dublin + Core; Spatial"},{"value":["Airports"],"kind":"Dublin Core; Subject"},{"value":["transportation"],"kind":"Dublin + Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity + point"],"kind":"Subject scheme not provided"}]},"sort":[1.0,1480550400000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:dz_a1cities_0k10k_2016","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:dz_a1cities_0k10k_2016","timdex_record_id":"gismit:dz_a1cities_0k10k_2016","title":"Algeria + (Cities (<10k), 2016)","citation":"GfK GeoMarketing GmbH. Algeria (Cities + (<10k), 2016). GIS Lab, MIT Libraries. Geospatial data. https://search.libraries.mit.edu/record/gismit:dz_a1cities_0k10k_2016","content_type":["Geospatial + data"],"contributors":[{"value":"GfK GeoMarketing GmbH","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2016-12-01"}],"format":"Vector","identifiers":[{"value":"dz_a1cities_0k10k_2016","kind":"Not + specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_a1cities_0k10k_2016.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_a1cities_0k10k_2016.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/dz_a1cities_0k10k_2016.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-7.843005, + 11.241667, 37.075000, 19.166667)"},{"kind":"Geometry","geoshape":"BBOX (-7.843005, + 11.241667, 37.075000, 19.166667)"}],"publication_information":["GIS Lab, MIT + Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"License + required"}],"subjects":[{"value":["Location"],"kind":"DCAT; Theme"},{"value":["Algeria"],"kind":"Dublin + Core; Spatial"},{"value":["Cities and towns"],"kind":"Dublin Core; Subject"},{"value":["location"],"kind":"Dublin + Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity + point"],"kind":"Subject scheme not provided"}]},"sort":[1.0,1480550400000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:dz_f7regions_2016","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:dz_f7regions_2016","timdex_record_id":"gismit:dz_f7regions_2016","title":"Algeria + (2-Digit Postal Code Areas, 2016)","citation":"GfK GeoMarketing GmbH. Algeria + (2-Digit Postal Code Areas, 2016). GfK GeoMarketing GmbH. Geospatial data. + https://search.libraries.mit.edu/record/gismit:dz_f7regions_2016","content_type":["Geospatial + data"],"contributors":[{"value":"GfK GeoMarketing GmbH","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2016-01-01"}],"format":"Vector","identifiers":[{"value":"Algeria + 2-digit postcode areas 2016Copy","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_f7regions_2016.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_f7regions_2016.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/dz_f7regions_2016.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-8.667992, + 11.994246, 37.089704, 18.956237)"},{"kind":"Geometry","geoshape":"BBOX (-8.667992, + 11.994246, 37.089704, 18.956237)"}],"publication_information":["GfK GeoMarketing + GmbH","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"Access + is limited to members of the MIT community only -- maps may not be given to + anyone not officially and currently affiliated with MIT. Maps may be used + only for research, educational, and other scholarly purposes; it is permissible + to use images created from the software and data in scholarly publications + and dissertations. Any other use, unless it falls within the Fair Use provisions + of U.S. copyright law, is not permitted.The copyright of GfK GeoMarketing + must be placed on the maps.The data can be published as a Bitmap or comparable + format."}],"subjects":[{"value":["Location"],"kind":"DCAT; Theme"},{"value":["Algeria"],"kind":"Dublin + Core; Spatial"},{"value":["Postal codes"],"kind":"Dublin Core; Subject"},{"value":["location"],"kind":"Dublin + Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["G-polygon"],"kind":"Subject + scheme not provided"}]},"sort":[1.0,1451606400000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:dz_p8postcode2dig_2016","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:dz_p8postcode2dig_2016","timdex_record_id":"gismit:dz_p8postcode2dig_2016","title":"Algeria + (2-Digit Postal Code Areas, 2016)","citation":"GfK GeoMarketing GmbH. Algeria + (2-Digit Postal Code Areas, 2016). GfK GeoMarketing GmbH. Geospatial data. + https://search.libraries.mit.edu/record/gismit:dz_p8postcode2dig_2016","content_type":["Geospatial + data"],"contributors":[{"value":"GfK GeoMarketing GmbH","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2016-01-01"}],"format":"Vector","identifiers":[{"value":"Algeria + 2-digit postcode areas 2016Copy","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_p8postcode2dig_2016.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/dz_p8postcode2dig_2016.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/dz_p8postcode2dig_2016.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-8.667992, + 11.994246, 37.089704, 18.956237)"},{"kind":"Geometry","geoshape":"BBOX (-8.667992, + 11.994246, 37.089704, 18.956237)"}],"publication_information":["GfK GeoMarketing + GmbH","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"Access + is limited to members of the MIT community only -- maps may not be given to + anyone not officially and currently affiliated with MIT. Maps may be used + only for research, educational, and other scholarly purposes; it is permissible + to use images created from the software and data in scholarly publications + and dissertations. Any other use, unless it falls within the Fair Use provisions + of U.S. copyright law, is not permitted.The copyright of GfK GeoMarketing + must be placed on the maps.The data can be published as a Bitmap or comparable + format."}],"subjects":[{"value":["Location"],"kind":"DCAT; Theme"},{"value":["Algeria"],"kind":"Dublin + Core; Spatial"},{"value":["Postal codes"],"kind":"Dublin Core; Subject"},{"value":["location"],"kind":"Dublin + Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["G-polygon"],"kind":"Subject + scheme not provided"}]},"sort":[1.0,1451606400000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:US_MA_BOSTON_G47PARCELS_2015","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:US_MA_BOSTON_G47PARCELS_2015","timdex_record_id":"gismit:US_MA_BOSTON_G47PARCELS_2015","title":"Boston, + MA (Land parcels, 2015)","citation":"City of Boston Assessing Department. + Boston, MA (Land parcels, 2015). City of Boston Assessing Department. Geospatial + data. https://search.libraries.mit.edu/record/gismit:US_MA_BOSTON_G47PARCELS_2015","content_type":["Geospatial + data"],"contributors":[{"value":"City of Boston Assessing Department","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2015-01-01"},{"kind":"Coverage","value":"2015-01-01"},{"kind":"Coverage","value":"2015"}],"format":"Vector","identifiers":[{"value":"us_ma_boston_g47parcels_2015","kind":"Not + specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/US_MA_BOSTON_G47PARCELS_2015.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/US_MA_BOSTON_G47PARCELS_2015.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/US_MA_BOSTON_G47PARCELS_2015.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-71.190913, + -70.953184, 42.397012, 42.227864)"},{"kind":"Geometry","geoshape":"BBOX (-71.190913, + -70.953184, 42.397012, 42.227864)"}],"publication_information":["City of Boston + Assessing Department","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"N/A"}],"subjects":[{"value":["Economy"],"kind":"DCAT; + Theme"},{"value":["Boundaries"],"kind":"DCAT; Theme"},{"value":["Location"],"kind":"DCAT; + Theme"},{"value":["Boston"],"kind":"Dublin Core; Spatial"},{"value":["USA"],"kind":"Dublin + Core; Spatial"},{"value":["Massachusetts"],"kind":"Dublin Core; Spatial"},{"value":["MA"],"kind":"Dublin + Core; Spatial"},{"value":["parcels"],"kind":"Dublin Core; Subject"},{"value":["land + parcels"],"kind":"Dublin Core; Subject"},{"value":["land use"],"kind":"Dublin + Core; Subject"},{"value":["wards"],"kind":"Dublin Core; Subject"},{"value":["polygon"],"kind":"Dublin + Core; Subject"},{"value":["tax"],"kind":"Dublin Core; Subject"},{"value":["land + ownership"],"kind":"Dublin Core; Subject"},{"value":["improvements"],"kind":"Dublin + Core; Subject"},{"value":["neighborhoods"],"kind":"Dublin Core; Subject"},{"value":["lot + size"],"kind":"Dublin Core; Subject"},{"value":["economy"],"kind":"Dublin + Core; Subject"},{"value":["planningCadastre"],"kind":"Dublin Core; Subject"},{"value":["boundaries"],"kind":"Dublin + Core; Subject"},{"value":["location"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject + scheme not provided"},{"value":["G-polygon"],"kind":"Subject scheme not provided"}],"summary":["City + of Boston property parcel data from FY 2015 was joined with parcel boundaries + from FY 2015. All data is from the City of Boston Assessor''s office and represents + data from 2014."]},"sort":[1.0,1420070400000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_INT_P94INCLUSIONS3G_2014","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_INT_P94INCLUSIONS3G_2014","timdex_record_id":"gismit:SDE_DATA_INT_P94INCLUSIONS3G_2014","title":"World + (3G Mobile Phone Coverage Inclusion, 2014)","citation":"Collins Bartholomew. + World (3G Mobile Phone Coverage Inclusion, 2014). Collins Bartholomew. Geospatial + data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_INT_P94INCLUSIONS3G_2014","content_type":["Geospatial + data"],"contributors":[{"value":"Collins Bartholomew","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2014-12-01"},{"kind":"Coverage","value":"2014-12-01"},{"kind":"Coverage","value":"2014"}],"format":"Vector","identifiers":[{"value":"INT_P94INCLUSIONS3G_2014","kind":"Not + specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_INT_P94INCLUSIONS3G_2014.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_INT_P94INCLUSIONS3G_2014.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/SDE_DATA_INT_P94INCLUSIONS3G_2014.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-150.000000, + 177.972000, 64.793404, -40.000000)"},{"kind":"Geometry","geoshape":"BBOX (-150.000000, + 177.972000, 64.793404, -40.000000)"}],"publication_information":["Collins + Bartholomew","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"}],"subjects":[{"value":["Earth + (Planet)"],"kind":"Dublin Core; Spatial"},{"value":["utilitiesCommunication"],"kind":"Dublin + Core; Subject"},{"value":["Public utilities"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject + scheme not provided"},{"value":["Entity point"],"kind":"Subject scheme not + provided"}],"summary":["These inclusion metadata files for GSM, 3G, and 4G + mobile coverage are an attempt at listing all the networks which are included + in the separate world mobile phone coverage datasets. Unfortunately the lists + cannot be comprehensive because legacy datasets did not maintain the information + required to make them complete."]},"sort":[1.0,1417392000000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_INT_P94INCLUSIONS4G_2014","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_INT_P94INCLUSIONS4G_2014","timdex_record_id":"gismit:SDE_DATA_INT_P94INCLUSIONS4G_2014","title":"World + (4G Mobile Phone Coverage Inclusion, 2014)","citation":"Collins Bartholomew. + World (4G Mobile Phone Coverage Inclusion, 2014). Collins Bartholomew. Geospatial + data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_INT_P94INCLUSIONS4G_2014","content_type":["Geospatial + data"],"contributors":[{"value":"Collins Bartholomew","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2014-12-01"},{"kind":"Coverage","value":"2014-12-01"},{"kind":"Coverage","value":"2014"}],"format":"Vector","identifiers":[{"value":"INT_P94INCLUSIONS4G_2014","kind":"Not + specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_INT_P94INCLUSIONS4G_2014.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_INT_P94INCLUSIONS4G_2014.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/SDE_DATA_INT_P94INCLUSIONS4G_2014.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-100.000000, + 170.481070, 64.518784, -40.000000)"},{"kind":"Geometry","geoshape":"BBOX (-100.000000, + 170.481070, 64.518784, -40.000000)"}],"publication_information":["Collins + Bartholomew","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"}],"subjects":[{"value":["Earth + (Planet)"],"kind":"Dublin Core; Spatial"},{"value":["utilitiesCommunication"],"kind":"Dublin + Core; Subject"},{"value":["Public utilities"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject + scheme not provided"},{"value":["Entity point"],"kind":"Subject scheme not + provided"}],"summary":["These inclusion metadata files for GSM, 3G, and 4G + mobile coverage are an attempt at listing all the networks which are included + in the separate world mobile phone coverage datasets. Unfortunately the lists + cannot be comprehensive because legacy datasets did not maintain the information + required to make them complete."]},"sort":[1.0,1417392000000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_INT_P944G_2014","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_INT_P944G_2014","timdex_record_id":"gismit:SDE_DATA_INT_P944G_2014","title":"World + (4G Mobile Phone Coverage, 2014)","citation":"Collins Bartholomew. World (4G + Mobile Phone Coverage, 2014). Collins Bartholomew. Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_INT_P944G_2014","content_type":["Geospatial + data"],"contributors":[{"value":"Collins Bartholomew","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2014-12-01"},{"kind":"Coverage","value":"2014-12-01"},{"kind":"Coverage","value":"2014"}],"format":"Vector","identifiers":[{"value":"INT_P944G_2014","kind":"Not + specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_INT_P944G_2014.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_INT_P944G_2014.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/SDE_DATA_INT_P944G_2014.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-135.373169, + 178.145985, 68.532066, -46.186684)"},{"kind":"Geometry","geoshape":"BBOX (-135.373169, + 178.145985, 68.532066, -46.186684)"}],"publication_information":["Collins + Bartholomew","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"}],"subjects":[{"value":["Earth + (Planet)"],"kind":"Dublin Core; Spatial"},{"value":["utilitiesCommunication"],"kind":"Dublin + Core; Subject"},{"value":["Public utilities"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject + scheme not provided"},{"value":["G-polygon"],"kind":"Subject scheme not provided"}],"summary":["Collins + Mobile Coverage Explorer is a representation of the area covered by mobile + communications around the world. The data is created from submissions, made + directly to Collins Bartholomew or the GSMA from mobile operators, which provide + roaming detail for inclusion in the online mapping application known as Collins + Mobile Coverage Web."]},"sort":[1.0,1417392000000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_INT_P94INCLUSIONSGSM_2014","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_INT_P94INCLUSIONSGSM_2014","timdex_record_id":"gismit:SDE_DATA_INT_P94INCLUSIONSGSM_2014","title":"World + (GSM Mobile Phone Coverage Inclusion, 2014)","citation":"Collins Bartholomew. + World (GSM Mobile Phone Coverage Inclusion, 2014). Collins Bartholomew. Geospatial + data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_INT_P94INCLUSIONSGSM_2014","content_type":["Geospatial + data"],"contributors":[{"value":"Collins Bartholomew","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2014-12-01"},{"kind":"Coverage","value":"2014-12-01"},{"kind":"Coverage","value":"2014"}],"format":"Vector","identifiers":[{"value":"INT_P94INCLUSIONSGSM_2014","kind":"Not + specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_INT_P94INCLUSIONSGSM_2014.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_INT_P94INCLUSIONSGSM_2014.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/SDE_DATA_INT_P94INCLUSIONSGSM_2014.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-180.000000, + 177.972000, 74.786049, -50.000000)"},{"kind":"Geometry","geoshape":"BBOX (-180.000000, + 177.972000, 74.786049, -50.000000)"}],"publication_information":["Collins + Bartholomew","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"}],"subjects":[{"value":["Earth + (Planet)"],"kind":"Dublin Core; Spatial"},{"value":["utilitiesCommunication"],"kind":"Dublin + Core; Subject"},{"value":["Cell phones"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject + scheme not provided"},{"value":["Entity point"],"kind":"Subject scheme not + provided"}],"summary":["These inclusion metadata files for GSM, 3G, and 4G + mobile coverage are an attempt at listing all the networks which are included + in the separate world mobile phone coverage datasets. Unfortunately the lists + cannot be comprehensive because legacy datasets did not maintain the information + required to make them complete."]},"sort":[1.0,1417392000000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_US_MA_BOSTON_G47PARCELS_2014","_score":1.0,"_source":{"source":"MIT + GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_BOSTON_G47PARCELS_2014","timdex_record_id":"gismit:SDE_DATA_US_MA_BOSTON_G47PARCELS_2014","title":"Boston, + MA (Land Parcels, 2014)","citation":"Boston (Mass.) Assessing Department. + Boston, MA (Land Parcels, 2014). Boston (Mass.) Assessing Department. Geospatial + data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_BOSTON_G47PARCELS_2014","content_type":["Geospatial + data"],"contributors":[{"value":"Boston (Mass.) Assessing Department","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2014-01-01"},{"kind":"Coverage","value":"2014-01-01"},{"kind":"Coverage","value":"2014"}],"format":"Vector","identifiers":[{"value":"US_MA_BOSTON_G47PARCELS_2014","kind":"Not + specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_BOSTON_G47PARCELS_2014.source.fgdc.xml","kind":"Download","text":"Source + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_BOSTON_G47PARCELS_2014.normalized.aardvark.json","kind":"Download","text":"Normalized + Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/SDE_DATA_US_MA_BOSTON_G47PARCELS_2014.zip","kind":"Download","text":"Data + Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-71.191182, + -70.922635, 42.397678, 42.227005)"},{"kind":"Geometry","geoshape":"BBOX (-71.191182, + -70.922635, 42.397678, 42.227005)"}],"publication_information":["Boston (Mass.) + Assessing Department","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"N/A"}],"subjects":[{"value":["Economy"],"kind":"DCAT; + Theme"},{"value":["Boundaries"],"kind":"DCAT; Theme"},{"value":["Location"],"kind":"DCAT; + Theme"},{"value":["Massachusetts--Boston"],"kind":"Dublin Core; Spatial"},{"value":["Land + use"],"kind":"Dublin Core; Subject"},{"value":["Neighborhoods"],"kind":"Dublin + Core; Subject"},{"value":["Administrative and political divisions"],"kind":"Dublin + Core; Subject"},{"value":["Land value taxation"],"kind":"Dublin Core; Subject"},{"value":["Land + tenure"],"kind":"Dublin Core; Subject"},{"value":["economy"],"kind":"Dublin + Core; Subject"},{"value":["planningCadastre"],"kind":"Dublin Core; Subject"},{"value":["boundaries"],"kind":"Dublin + Core; Subject"},{"value":["location"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject + scheme not provided"},{"value":["G-polygon"],"kind":"Subject scheme not provided"}],"summary":["City + of Boston property parcel data from FY 2014 was joined with parcel boundaries + from FY 2014. All data is from the City of Boston Assessor''s office and represents + data from 2013."]},"sort":[1.0,1388534400000]}]},"aggregations":{"languages":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[{"key":"eng","doc_count":1431}]},"content_type":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[{"key":"geospatial + data","doc_count":1449}]},"subjects":{"doc_count":12404,"subject_names":{"doc_count_error_upper_bound":0,"sum_other_doc_count":6798,"buckets":[{"key":"datasets","doc_count":1449},{"key":"boundaries","doc_count":880},{"key":"g-polygon","doc_count":772},{"key":"transportation","doc_count":530},{"key":"entity + point","doc_count":418},{"key":"location","doc_count":410},{"key":"society","doc_count":376},{"key":"united + states","doc_count":278},{"key":"structure","doc_count":252},{"key":"string","doc_count":241}]}},"content_format":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[{"key":"vector","doc_count":1427},{"key":"point","doc_count":18},{"key":"raster","doc_count":4}]},"literary_form":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[]},"source":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[{"key":"mit + gis resources","doc_count":1449}]},"contributors":{"doc_count":1745,"contributor_names":{"doc_count_error_upper_bound":0,"sum_other_doc_count":849,"buckets":[{"key":"environmental + systems research institute (redlands, calif.)","doc_count":163},{"key":"massgis + (office : mass.)","doc_count":134},{"key":"latin force group llc","doc_count":112},{"key":"esri","doc_count":91},{"key":"city + of cambridge gis","doc_count":82},{"key":"platts","doc_count":80},{"key":"gfk + geomarketing gmbh","doc_count":66},{"key":"tele atlas b.v.","doc_count":61},{"key":"new + york (n.y.). department of city planning","doc_count":55},{"key":"snohomish + county geographic information system (gis), dept. of information services","doc_count":52}]}}}}' + recorded_at: Wed, 14 Feb 2024 16:37:54 GMT +recorded_with: VCR 6.2.0 diff --git a/test/vcr_cassettes/graphqlv2_geobox_with_geodistance.yml b/test/vcr_cassettes/graphqlv2_geobox_with_geodistance.yml new file mode 100644 index 00000000..b4fde1b9 --- /dev/null +++ b/test/vcr_cassettes/graphqlv2_geobox_with_geodistance.yml @@ -0,0 +1,32 @@ +--- +http_interactions: +- request: + method: post + uri: http://localhost:9200/timdex-prod/_search + body: + encoding: UTF-8 + string: '{"from":"0","size":20,"query":{"bool":{"should":null,"must":[{"bool":{"must":{"match_all":{}},"filter":{"geo_distance":{"distance":"100000km","locations.geoshape":{"lat":0.0,"lon":0.0}}}}},{"bool":{"must":{"match_all":{}},"filter":{"geo_bounding_box":{"locations.geoshape":{"top":42.886,"bottom":41.239,"left":-73.507,"right":-69.928}}}}}],"filter":[]}},"aggregations":{"contributors":{"nested":{"path":"contributors"},"aggs":{"contributor_names":{"terms":{"field":"contributors.value.keyword"}}}},"content_type":{"terms":{"field":"content_type"}},"content_format":{"terms":{"field":"format"}},"languages":{"terms":{"field":"languages.keyword"}},"literary_form":{"terms":{"field":"literary_form"}},"source":{"terms":{"field":"source"}},"subjects":{"nested":{"path":"subjects"},"aggs":{"subject_names":{"terms":{"field":"subjects.value.keyword"}}}}},"sort":[{"_score":{"order":"desc"}},{"dates.value.as_date":{"order":"desc","nested":{"path":"dates"}}}]}' + headers: + User-Agent: + - 'opensearch-ruby/3.1.0 (RUBY_VERSION: 3.2.2; darwin arm64; Faraday v2.9.0)' + Content-Type: + - application/json + Accept-Encoding: + - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 + Accept: + - "*/*" + response: + status: + code: 200 + message: OK + headers: + Content-Type: + - application/json; charset=UTF-8 + Content-Length: + - '57546' + body: + encoding: ASCII-8BIT + string: !binary |- + {"took":54,"timed_out":false,"_shards":{"total":1,"successful":1,"skipped":0,"failed":0},"hits":{"total":{"value":825,"relation":"eq"},"max_score":null,"hits":[{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:us_ma_boston_g47parcels_2018","_score":2.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:us_ma_boston_g47parcels_2018","timdex_record_id":"gismit:us_ma_boston_g47parcels_2018","title":"Boston, MA (Land parcels, 2018)","citation":"City of Boston Assessing Department. Boston, MA (Land parcels, 2018). GIS Lab, MIT Libraries. Geospatial data. https://search.libraries.mit.edu/record/gismit:us_ma_boston_g47parcels_2018","content_type":["Geospatial data"],"contributors":[{"value":"City of Boston Assessing Department","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2018-01-01"},{"kind":"Coverage","value":"2015-01-01"},{"kind":"Coverage","value":"2015"}],"format":"Vector","identifiers":[{"value":"us_ma_boston_g47parcels_2018","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/us_ma_boston_g47parcels_2018.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/us_ma_boston_g47parcels_2018.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/us_ma_boston_g47parcels_2018.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-71.190913, -70.868654, 42.397012, 42.227864)"},{"kind":"Geometry","geoshape":"BBOX (-71.190913, -70.868654, 42.397012, 42.227864)"}],"publication_information":["GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"N/A"}],"subjects":[{"value":["Economy"],"kind":"DCAT; Theme"},{"value":["Boundaries"],"kind":"DCAT; Theme"},{"value":["Location"],"kind":"DCAT; Theme"},{"value":["Massachusetts--Boston"],"kind":"Dublin Core; Spatial"},{"value":["Land use"],"kind":"Dublin Core; Subject"},{"value":["Neighborhoods"],"kind":"Dublin Core; Subject"},{"value":["Administrative and political divisions"],"kind":"Dublin Core; Subject"},{"value":["Land value taxation"],"kind":"Dublin Core; Subject"},{"value":["Land tenure"],"kind":"Dublin Core; Subject"},{"value":["economy"],"kind":"Dublin Core; Subject"},{"value":["planningCadastre"],"kind":"Dublin Core; Subject"},{"value":["boundaries"],"kind":"Dublin Core; Subject"},{"value":["location"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["G-polygon"],"kind":"Subject scheme not provided"}],"summary":["City of Boston property parcel data from FY 2018 was joined with parcel boundaries from FY 2018. All data is from the City of Boston Assessor's office and represents data from 2017."]},"sort":[2.0,1514764800000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:us_ma_boston_g47parcels_2017","_score":2.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:us_ma_boston_g47parcels_2017","timdex_record_id":"gismit:us_ma_boston_g47parcels_2017","title":"Boston, MA (Land parcels, 2017)","citation":"City of Boston Assessing Department. Boston, MA (Land parcels, 2017). GIS Lab, MIT Libraries. Geospatial data. https://search.libraries.mit.edu/record/gismit:us_ma_boston_g47parcels_2017","content_type":["Geospatial data"],"contributors":[{"value":"City of Boston Assessing Department","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2017-01-01"},{"kind":"Coverage","value":"2017-01-01"},{"kind":"Coverage","value":"2017"}],"format":"Vector","identifiers":[{"value":"us_ma_boston_g47parcels_2017","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/us_ma_boston_g47parcels_2017.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/us_ma_boston_g47parcels_2017.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/us_ma_boston_g47parcels_2017.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-71.190913, -70.923055, 42.397004, 42.227856)"},{"kind":"Geometry","geoshape":"BBOX (-71.190913, -70.923055, 42.397004, 42.227856)"}],"publication_information":["GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"N/A"}],"subjects":[{"value":["Economy"],"kind":"DCAT; Theme"},{"value":["Boundaries"],"kind":"DCAT; Theme"},{"value":["Location"],"kind":"DCAT; Theme"},{"value":["Massachusetts--Boston"],"kind":"Dublin Core; Spatial"},{"value":["Land use"],"kind":"Dublin Core; Subject"},{"value":["Neighborhoods"],"kind":"Dublin Core; Subject"},{"value":["Administrative and political divisions"],"kind":"Dublin Core; Subject"},{"value":["Land value taxation"],"kind":"Dublin Core; Subject"},{"value":["Land tenure"],"kind":"Dublin Core; Subject"},{"value":["economy"],"kind":"Dublin Core; Subject"},{"value":["planningCadastre"],"kind":"Dublin Core; Subject"},{"value":["boundaries"],"kind":"Dublin Core; Subject"},{"value":["location"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["G-polygon"],"kind":"Subject scheme not provided"}],"summary":["City of Boston property parcel data from FY 2017 was joined with parcel boundaries from FY 2017. All data is from the City of Boston Assessor's office and represents data from 2016."]},"sort":[2.0,1483228800000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:US_MA_BOSTON_G47PARCELS_2016","_score":2.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:US_MA_BOSTON_G47PARCELS_2016","timdex_record_id":"gismit:US_MA_BOSTON_G47PARCELS_2016","title":"Boston, MA (Land parcels, 2016)","citation":"City of Boston Assessing Department. Boston, MA (Land parcels, 2016). GIS Lab, MIT Libraries. Geospatial data. https://search.libraries.mit.edu/record/gismit:US_MA_BOSTON_G47PARCELS_2016","content_type":["Geospatial data"],"contributors":[{"value":"City of Boston Assessing Department","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2017-01-01"},{"kind":"Coverage","value":"2016-01-01"},{"kind":"Coverage","value":"2016"}],"format":"Vector","identifiers":[{"value":"us_ma_boston_g47parcels_2016","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/US_MA_BOSTON_G47PARCELS_2016.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/US_MA_BOSTON_G47PARCELS_2016.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/US_MA_BOSTON_G47PARCELS_2016.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-71.190913, -70.923055, 42.397004, 42.227856)"},{"kind":"Geometry","geoshape":"BBOX (-71.190913, -70.923055, 42.397004, 42.227856)"}],"publication_information":["GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"N/A"}],"subjects":[{"value":["Economy"],"kind":"DCAT; Theme"},{"value":["Boundaries"],"kind":"DCAT; Theme"},{"value":["Location"],"kind":"DCAT; Theme"},{"value":["Boston"],"kind":"Dublin Core; Spatial"},{"value":["USA"],"kind":"Dublin Core; Spatial"},{"value":["Massachusetts"],"kind":"Dublin Core; Spatial"},{"value":["MA"],"kind":"Dublin Core; Spatial"},{"value":["parcels"],"kind":"Dublin Core; Subject"},{"value":["land parcels"],"kind":"Dublin Core; Subject"},{"value":["land use"],"kind":"Dublin Core; Subject"},{"value":["wards"],"kind":"Dublin Core; Subject"},{"value":["polygon"],"kind":"Dublin Core; Subject"},{"value":["tax"],"kind":"Dublin Core; Subject"},{"value":["land ownership"],"kind":"Dublin Core; Subject"},{"value":["improvements"],"kind":"Dublin Core; Subject"},{"value":["neighborhoods"],"kind":"Dublin Core; Subject"},{"value":["lot size"],"kind":"Dublin Core; Subject"},{"value":["economy"],"kind":"Dublin Core; Subject"},{"value":["planningCadastre"],"kind":"Dublin Core; Subject"},{"value":["boundaries"],"kind":"Dublin Core; Subject"},{"value":["location"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["G-polygon"],"kind":"Subject scheme not provided"}],"summary":["City of Boston property parcel data from FY 2016 was joined with parcel boundaries from FY 2016. All data is from the City of Boston Assessor's office and represents data from 2015."]},"sort":[2.0,1483228800000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:US_MA_BOSTON_G47PARCELS_2015","_score":2.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:US_MA_BOSTON_G47PARCELS_2015","timdex_record_id":"gismit:US_MA_BOSTON_G47PARCELS_2015","title":"Boston, MA (Land parcels, 2015)","citation":"City of Boston Assessing Department. Boston, MA (Land parcels, 2015). City of Boston Assessing Department. Geospatial data. https://search.libraries.mit.edu/record/gismit:US_MA_BOSTON_G47PARCELS_2015","content_type":["Geospatial data"],"contributors":[{"value":"City of Boston Assessing Department","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2015-01-01"},{"kind":"Coverage","value":"2015-01-01"},{"kind":"Coverage","value":"2015"}],"format":"Vector","identifiers":[{"value":"us_ma_boston_g47parcels_2015","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/US_MA_BOSTON_G47PARCELS_2015.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/US_MA_BOSTON_G47PARCELS_2015.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/US_MA_BOSTON_G47PARCELS_2015.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-71.190913, -70.953184, 42.397012, 42.227864)"},{"kind":"Geometry","geoshape":"BBOX (-71.190913, -70.953184, 42.397012, 42.227864)"}],"publication_information":["City of Boston Assessing Department","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"N/A"}],"subjects":[{"value":["Economy"],"kind":"DCAT; Theme"},{"value":["Boundaries"],"kind":"DCAT; Theme"},{"value":["Location"],"kind":"DCAT; Theme"},{"value":["Boston"],"kind":"Dublin Core; Spatial"},{"value":["USA"],"kind":"Dublin Core; Spatial"},{"value":["Massachusetts"],"kind":"Dublin Core; Spatial"},{"value":["MA"],"kind":"Dublin Core; Spatial"},{"value":["parcels"],"kind":"Dublin Core; Subject"},{"value":["land parcels"],"kind":"Dublin Core; Subject"},{"value":["land use"],"kind":"Dublin Core; Subject"},{"value":["wards"],"kind":"Dublin Core; Subject"},{"value":["polygon"],"kind":"Dublin Core; Subject"},{"value":["tax"],"kind":"Dublin Core; Subject"},{"value":["land ownership"],"kind":"Dublin Core; Subject"},{"value":["improvements"],"kind":"Dublin Core; Subject"},{"value":["neighborhoods"],"kind":"Dublin Core; Subject"},{"value":["lot size"],"kind":"Dublin Core; Subject"},{"value":["economy"],"kind":"Dublin Core; Subject"},{"value":["planningCadastre"],"kind":"Dublin Core; Subject"},{"value":["boundaries"],"kind":"Dublin Core; Subject"},{"value":["location"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["G-polygon"],"kind":"Subject scheme not provided"}],"summary":["City of Boston property parcel data from FY 2015 was joined with parcel boundaries from FY 2015. All data is from the City of Boston Assessor's office and represents data from 2014."]},"sort":[2.0,1420070400000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_INT_P94INCLUSIONS3G_2014","_score":2.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_INT_P94INCLUSIONS3G_2014","timdex_record_id":"gismit:SDE_DATA_INT_P94INCLUSIONS3G_2014","title":"World (3G Mobile Phone Coverage Inclusion, 2014)","citation":"Collins Bartholomew. World (3G Mobile Phone Coverage Inclusion, 2014). Collins Bartholomew. Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_INT_P94INCLUSIONS3G_2014","content_type":["Geospatial data"],"contributors":[{"value":"Collins Bartholomew","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2014-12-01"},{"kind":"Coverage","value":"2014-12-01"},{"kind":"Coverage","value":"2014"}],"format":"Vector","identifiers":[{"value":"INT_P94INCLUSIONS3G_2014","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_INT_P94INCLUSIONS3G_2014.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_INT_P94INCLUSIONS3G_2014.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/SDE_DATA_INT_P94INCLUSIONS3G_2014.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-150.000000, 177.972000, 64.793404, -40.000000)"},{"kind":"Geometry","geoshape":"BBOX (-150.000000, 177.972000, 64.793404, -40.000000)"}],"publication_information":["Collins Bartholomew","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"}],"subjects":[{"value":["Earth (Planet)"],"kind":"Dublin Core; Spatial"},{"value":["utilitiesCommunication"],"kind":"Dublin Core; Subject"},{"value":["Public utilities"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity point"],"kind":"Subject scheme not provided"}],"summary":["These inclusion metadata files for GSM, 3G, and 4G mobile coverage are an attempt at listing all the networks which are included in the separate world mobile phone coverage datasets. Unfortunately the lists cannot be comprehensive because legacy datasets did not maintain the information required to make them complete."]},"sort":[2.0,1417392000000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_INT_P94INCLUSIONS4G_2014","_score":2.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_INT_P94INCLUSIONS4G_2014","timdex_record_id":"gismit:SDE_DATA_INT_P94INCLUSIONS4G_2014","title":"World (4G Mobile Phone Coverage Inclusion, 2014)","citation":"Collins Bartholomew. World (4G Mobile Phone Coverage Inclusion, 2014). Collins Bartholomew. Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_INT_P94INCLUSIONS4G_2014","content_type":["Geospatial data"],"contributors":[{"value":"Collins Bartholomew","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2014-12-01"},{"kind":"Coverage","value":"2014-12-01"},{"kind":"Coverage","value":"2014"}],"format":"Vector","identifiers":[{"value":"INT_P94INCLUSIONS4G_2014","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_INT_P94INCLUSIONS4G_2014.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_INT_P94INCLUSIONS4G_2014.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/SDE_DATA_INT_P94INCLUSIONS4G_2014.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-100.000000, 170.481070, 64.518784, -40.000000)"},{"kind":"Geometry","geoshape":"BBOX (-100.000000, 170.481070, 64.518784, -40.000000)"}],"publication_information":["Collins Bartholomew","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"}],"subjects":[{"value":["Earth (Planet)"],"kind":"Dublin Core; Spatial"},{"value":["utilitiesCommunication"],"kind":"Dublin Core; Subject"},{"value":["Public utilities"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity point"],"kind":"Subject scheme not provided"}],"summary":["These inclusion metadata files for GSM, 3G, and 4G mobile coverage are an attempt at listing all the networks which are included in the separate world mobile phone coverage datasets. Unfortunately the lists cannot be comprehensive because legacy datasets did not maintain the information required to make them complete."]},"sort":[2.0,1417392000000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_INT_P944G_2014","_score":2.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_INT_P944G_2014","timdex_record_id":"gismit:SDE_DATA_INT_P944G_2014","title":"World (4G Mobile Phone Coverage, 2014)","citation":"Collins Bartholomew. World (4G Mobile Phone Coverage, 2014). Collins Bartholomew. Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_INT_P944G_2014","content_type":["Geospatial data"],"contributors":[{"value":"Collins Bartholomew","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2014-12-01"},{"kind":"Coverage","value":"2014-12-01"},{"kind":"Coverage","value":"2014"}],"format":"Vector","identifiers":[{"value":"INT_P944G_2014","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_INT_P944G_2014.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_INT_P944G_2014.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/SDE_DATA_INT_P944G_2014.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-135.373169, 178.145985, 68.532066, -46.186684)"},{"kind":"Geometry","geoshape":"BBOX (-135.373169, 178.145985, 68.532066, -46.186684)"}],"publication_information":["Collins Bartholomew","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"}],"subjects":[{"value":["Earth (Planet)"],"kind":"Dublin Core; Spatial"},{"value":["utilitiesCommunication"],"kind":"Dublin Core; Subject"},{"value":["Public utilities"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["G-polygon"],"kind":"Subject scheme not provided"}],"summary":["Collins Mobile Coverage Explorer is a representation of the area covered by mobile communications around the world. The data is created from submissions, made directly to Collins Bartholomew or the GSMA from mobile operators, which provide roaming detail for inclusion in the online mapping application known as Collins Mobile Coverage Web."]},"sort":[2.0,1417392000000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_INT_P94INCLUSIONSGSM_2014","_score":2.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_INT_P94INCLUSIONSGSM_2014","timdex_record_id":"gismit:SDE_DATA_INT_P94INCLUSIONSGSM_2014","title":"World (GSM Mobile Phone Coverage Inclusion, 2014)","citation":"Collins Bartholomew. World (GSM Mobile Phone Coverage Inclusion, 2014). Collins Bartholomew. Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_INT_P94INCLUSIONSGSM_2014","content_type":["Geospatial data"],"contributors":[{"value":"Collins Bartholomew","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2014-12-01"},{"kind":"Coverage","value":"2014-12-01"},{"kind":"Coverage","value":"2014"}],"format":"Vector","identifiers":[{"value":"INT_P94INCLUSIONSGSM_2014","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_INT_P94INCLUSIONSGSM_2014.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_INT_P94INCLUSIONSGSM_2014.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/SDE_DATA_INT_P94INCLUSIONSGSM_2014.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-180.000000, 177.972000, 74.786049, -50.000000)"},{"kind":"Geometry","geoshape":"BBOX (-180.000000, 177.972000, 74.786049, -50.000000)"}],"publication_information":["Collins Bartholomew","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"}],"subjects":[{"value":["Earth (Planet)"],"kind":"Dublin Core; Spatial"},{"value":["utilitiesCommunication"],"kind":"Dublin Core; Subject"},{"value":["Cell phones"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity point"],"kind":"Subject scheme not provided"}],"summary":["These inclusion metadata files for GSM, 3G, and 4G mobile coverage are an attempt at listing all the networks which are included in the separate world mobile phone coverage datasets. Unfortunately the lists cannot be comprehensive because legacy datasets did not maintain the information required to make them complete."]},"sort":[2.0,1417392000000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_US_MA_BOSTON_G47PARCELS_2014","_score":2.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_BOSTON_G47PARCELS_2014","timdex_record_id":"gismit:SDE_DATA_US_MA_BOSTON_G47PARCELS_2014","title":"Boston, MA (Land Parcels, 2014)","citation":"Boston (Mass.) Assessing Department. Boston, MA (Land Parcels, 2014). Boston (Mass.) Assessing Department. Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_BOSTON_G47PARCELS_2014","content_type":["Geospatial data"],"contributors":[{"value":"Boston (Mass.) Assessing Department","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2014-01-01"},{"kind":"Coverage","value":"2014-01-01"},{"kind":"Coverage","value":"2014"}],"format":"Vector","identifiers":[{"value":"US_MA_BOSTON_G47PARCELS_2014","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_BOSTON_G47PARCELS_2014.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_BOSTON_G47PARCELS_2014.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/SDE_DATA_US_MA_BOSTON_G47PARCELS_2014.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-71.191182, -70.922635, 42.397678, 42.227005)"},{"kind":"Geometry","geoshape":"BBOX (-71.191182, -70.922635, 42.397678, 42.227005)"}],"publication_information":["Boston (Mass.) Assessing Department","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"N/A"}],"subjects":[{"value":["Economy"],"kind":"DCAT; Theme"},{"value":["Boundaries"],"kind":"DCAT; Theme"},{"value":["Location"],"kind":"DCAT; Theme"},{"value":["Massachusetts--Boston"],"kind":"Dublin Core; Spatial"},{"value":["Land use"],"kind":"Dublin Core; Subject"},{"value":["Neighborhoods"],"kind":"Dublin Core; Subject"},{"value":["Administrative and political divisions"],"kind":"Dublin Core; Subject"},{"value":["Land value taxation"],"kind":"Dublin Core; Subject"},{"value":["Land tenure"],"kind":"Dublin Core; Subject"},{"value":["economy"],"kind":"Dublin Core; Subject"},{"value":["planningCadastre"],"kind":"Dublin Core; Subject"},{"value":["boundaries"],"kind":"Dublin Core; Subject"},{"value":["location"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["G-polygon"],"kind":"Subject scheme not provided"}],"summary":["City of Boston property parcel data from FY 2014 was joined with parcel boundaries from FY 2014. All data is from the City of Boston Assessor's office and represents data from 2013."]},"sort":[2.0,1388534400000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_US_MA_BOSTON_G47PARCELS_2013","_score":2.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_BOSTON_G47PARCELS_2013","timdex_record_id":"gismit:SDE_DATA_US_MA_BOSTON_G47PARCELS_2013","title":"Boston, MA (Land Parcels, 2013)","citation":"Boston (Mass). Assessing Department. Boston, MA (Land Parcels, 2013). Boston (Mass.) Assessing Department. Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_BOSTON_G47PARCELS_2013","content_type":["Geospatial data"],"contributors":[{"value":"Boston (Mass). Assessing Department","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2013-01-01"},{"kind":"Coverage","value":"2013-01-01"},{"kind":"Coverage","value":"2013"}],"format":"Vector","identifiers":[{"value":"US_MA_BOSTON_G47PARCELS_2013","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_BOSTON_G47PARCELS_2013.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_BOSTON_G47PARCELS_2013.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/SDE_DATA_US_MA_BOSTON_G47PARCELS_2013.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-71.191182, -70.922635, 42.397678, 42.227005)"},{"kind":"Geometry","geoshape":"BBOX (-71.191182, -70.922635, 42.397678, 42.227005)"}],"publication_information":["Boston (Mass.) Assessing Department","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"N/A"}],"subjects":[{"value":["Economy"],"kind":"DCAT; Theme"},{"value":["Boundaries"],"kind":"DCAT; Theme"},{"value":["Location"],"kind":"DCAT; Theme"},{"value":["Massachusetts--Boston"],"kind":"Dublin Core; Spatial"},{"value":["Land use"],"kind":"Dublin Core; Subject"},{"value":["Neighborhoods"],"kind":"Dublin Core; Subject"},{"value":["Administrative and political divisions"],"kind":"Dublin Core; Subject"},{"value":["Land value taxation"],"kind":"Dublin Core; Subject"},{"value":["Land tenure"],"kind":"Dublin Core; Subject"},{"value":["planningCadastre"],"kind":"Dublin Core; Subject"},{"value":["economy"],"kind":"Dublin Core; Subject"},{"value":["boundaries"],"kind":"Dublin Core; Subject"},{"value":["location"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["G-polygon"],"kind":"Subject scheme not provided"}],"summary":["City of Boston property parcel data from FY 2013 was joined with parcel boundaries from FY 2013. All data is from the City of Boston Assessor's office and represents data from 2012."]},"sort":[2.0,1356998400000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:GISPORTAL_GISOWNER01_CAMBRIDGEMEMPOLES09","_score":2.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:GISPORTAL_GISOWNER01_CAMBRIDGEMEMPOLES09","timdex_record_id":"gismit:GISPORTAL_GISOWNER01_CAMBRIDGEMEMPOLES09","title":"Memorial Poles Cambridge MA 2009","citation":"Cambridge (Mass.). Geographic Information Systems. Memorial Poles Cambridge MA 2009. GIS Lab, MIT Libraries. Geospatial data. https://search.libraries.mit.edu/record/gismit:GISPORTAL_GISOWNER01_CAMBRIDGEMEMPOLES09","content_type":["Geospatial data"],"contributors":[{"value":"Cambridge (Mass.). Geographic Information Systems","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2012-09-20"}],"format":"Vector","identifiers":[{"value":"CambridgeMemPoles09","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/GISPORTAL_GISOWNER01_CAMBRIDGEMEMPOLES09.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/GISPORTAL_GISOWNER01_CAMBRIDGEMEMPOLES09.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/GISPORTAL_GISOWNER01_CAMBRIDGEMEMPOLES09.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-71.157950, -71.076669, 42.402572, 42.355089)"},{"kind":"Geometry","geoshape":"BBOX (-71.157950, -71.076669, 42.402572, 42.355089)"}],"publication_information":["GIS Lab, MIT Libraries"],"rights":[{"description":"Public","kind":"Access"},{"description":"For educational noncommercial use only."}],"subjects":[{"value":["Structure"],"kind":"DCAT; Theme"},{"value":["Massachusetts--Cambridge"],"kind":"Dublin Core; Spatial"},{"value":["Memorials"],"kind":"Dublin Core; Subject"},{"value":["structure"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity point"],"kind":"Subject scheme not provided"}],"summary":["This point dataset contains memorial poles, markers, and plaques installed in Cambridge, MA that commemorate extraordinary citizens and those who have died or been reported missing in combat."]},"sort":[2.0,1348099200000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_US_MA_C32FLOODHAZARDS_2012","_score":2.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_C32FLOODHAZARDS_2012","timdex_record_id":"gismit:SDE_DATA_US_MA_C32FLOODHAZARDS_2012","title":"Massachusetts, USA (Flood Hazards, 2012)","citation":"United States. Federal Emergency Management Agency. Massachusetts, USA (Flood Hazards, 2012). United States. Federal Emergency Management Agency. Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_C32FLOODHAZARDS_2012","content_type":["Geospatial data"],"contributors":[{"value":"United States. Federal Emergency Management Agency","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2012-08-16"},{"kind":"Coverage","value":"2012-08-16"},{"kind":"Coverage","value":"2012"}],"format":"Vector","identifiers":[{"value":"US_MA_C32FLOODHAZARDS_2012","kind":"Not specified"}],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_C32FLOODHAZARDS_2012.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_C32FLOODHAZARDS_2012.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/SDE_DATA_US_MA_C32FLOODHAZARDS_2012.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-72.315879, -70.443474, 42.886818, 41.249267)"},{"kind":"Geometry","geoshape":"BBOX (-72.315879, -70.443474, 42.886818, 41.249267)"}],"publication_information":["United States. Federal Emergency Management Agency","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"No warranty expressed or implied is made by FEMA regarding the utility of the data on any other system nor shall the act of distribution constitute any such warranty. FEMA will warrant the delivery of this product in a computer-readable format, and will offer appropriate adjustment of credit when the product is determined unreadable by correctly adjusted computer input peripherals, or when the physical medium is delivered in damaged condition. Requests for adjustment of credit must be made within 90 days from the date of this shipment from the ordering site."}],"subjects":[{"value":["Environment"],"kind":"DCAT; Theme"},{"value":["Structure"],"kind":"DCAT; Theme"},{"value":["Elevation"],"kind":"DCAT; Theme"},{"value":["Transportation"],"kind":"DCAT; Theme"},{"value":["Massachusetts"],"kind":"Dublin Core; Spatial"},{"value":["environment"],"kind":"Dublin Core; Subject"},{"value":["structure"],"kind":"Dublin Core; Subject"},{"value":["hydrology"],"kind":"Dublin Core; Subject"},{"value":["elevation"],"kind":"Dublin Core; Subject"},{"value":["inlandWaters"],"kind":"Dublin Core; Subject"},{"value":["transportation"],"kind":"Dublin Core; Subject"},{"value":["Flood insurance--Rates"],"kind":"Dublin Core; Subject"},{"value":["Flood damage prevention"],"kind":"Dublin Core; Subject"},{"value":["Flood control--Planning"],"kind":"Dublin Core; Subject"},{"value":["Storm surges"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["GT-polygon composed of chains"],"kind":"Subject scheme not provided"}],"summary":["The National Flood Hazard Layer (NFHL) data incorporates all Digital Flood Insurance Rate Map(DFIRM) databases published by FEMA, and any Letters Of Map Revision (LOMRs) that have been issued against those databases since their publication date. The DFIRM Database is the digital, geospatial version of the flood hazard information shown on the published paper Flood Insurance Rate Maps(FIRMs). The primary risk classifications used are the 1-percent-annual-chance flood event, the 0.2-percent-annual-chance flood event, and areas of minimal flood risk. The NFHL data are derived from Flood Insurance Studies (FISs), previously published Flood Insurance Rate Maps (FIRMs), flood hazard analyses performed in support of the FISs and FIRMs, and new mapping data where available. The FISs and FIRMs are published by the Federal Emergency Management Agency (FEMA). The specifications for the horizontal control of DFIRM data are consistent with those required for mapping at a scale of 1:12,000. The NFHL data contain layers in the Standard DFIRM datasets except for S_Label_Pt and S_Label_Ld. The NFHL is available as State or US Territory data sets. Each State or Territory data set consists of all DFIRMs and corresponding LOMRs available on the publication date of the data set."]},"sort":[2.0,1345075200000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_US_MA_N2DAMS_2012","_score":2.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_N2DAMS_2012","timdex_record_id":"gismit:SDE_DATA_US_MA_N2DAMS_2012","title":"Massachusetts (Dams, 2012)","citation":"Massachusetts. Department of Conservation. Massachusetts (Dams, 2012). MassGIS (Office : Mass.). Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_N2DAMS_2012","content_type":["Geospatial data"],"contributors":[{"value":"Massachusetts. Department of Conservation","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2012-02-03"}],"format":"Vector","identifiers":[{"value":"US_MA_N2DAMS_2012","kind":"Not specified"}],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_N2DAMS_2012.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_N2DAMS_2012.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_N2DAMS_2012.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-73.495093, -69.973216, 42.866832, 41.338518)"},{"kind":"Geometry","geoshape":"BBOX (-73.495093, -69.973216, 42.866832, 41.338518)"}],"publication_information":["MassGIS (Office : Mass.)","GIS Lab, MIT Libraries"],"rights":[{"description":"Public","kind":"Access"}],"subjects":[{"value":["Economy"],"kind":"DCAT; Theme"},{"value":["Environment"],"kind":"DCAT; Theme"},{"value":["Structure"],"kind":"DCAT; Theme"},{"value":["Massachusetts"],"kind":"Dublin Core; Spatial"},{"value":["Dams"],"kind":"Dublin Core; Subject"},{"value":["economy"],"kind":"Dublin Core; Subject"},{"value":["environment"],"kind":"Dublin Core; Subject"},{"value":["inlandWaters"],"kind":"Dublin Core; Subject"},{"value":["structure"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity point"],"kind":"Subject scheme not provided"}],"summary":["The ODS maintains a database that includes detailed information about each dam for operational purposes. Most of the location information was derived from historic data and has been ground-truthed against inspection and ownership reports that are maintained by the ODS. The locations of some dams have not been confirmed. These are pending verification and can be identified through the field 'LocStatus.’Dams regulated by the ODS in accordance with regulation CMR 302 10.00 are listed as ‘Office of Dam Safety’ in the field ‘RegAuth’.Please report any data errors or inconsistencies to the Office of Dam Safety (dam.safety@state.ma.us) or DCR-GIS (chandreyee.lahiri@state.ma.us)"]},"sort":[2.0,1328227200000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:US_MA_BOSTON_G46BLDGS_2012","_score":2.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:US_MA_BOSTON_G46BLDGS_2012","timdex_record_id":"gismit:US_MA_BOSTON_G46BLDGS_2012","title":"us_ma_boston_g46bldgs_2012","citation":"Boston (Mass.). Dept. of Innovation and Technology. us_ma_boston_g46bldgs_2012. Boston Department of Innovation and Technology (DoIT). Geospatial data. https://search.libraries.mit.edu/record/gismit:US_MA_BOSTON_G46BLDGS_2012","content_type":["Geospatial data"],"contributors":[{"value":"Boston (Mass.). Dept. of Innovation and Technology.","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2012-01-19"},{"kind":"Coverage","value":"2012-01-01"},{"kind":"Coverage","value":"2012"}],"format":"Vector","identifiers":[{"value":"us_ma_boston_g46bldgs_2012","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/US_MA_BOSTON_G46BLDGS_2012.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/US_MA_BOSTON_G46BLDGS_2012.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/US_MA_BOSTON_G46BLDGS_2012.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-71.186110, -70.924810, 42.398736, 42.229271)"},{"kind":"Geometry","geoshape":"BBOX (-71.186110, -70.924810, 42.398736, 42.229271)"}],"publication_information":["Boston Department of Innovation and Technology (DoIT)","GIS Lab, MIT Libraries"],"rights":[{"description":"Public","kind":"Access"},{"description":"For educational noncommercial use only."}],"subjects":[{"value":["Structure"],"kind":"DCAT; Theme"},{"value":["Boston"],"kind":"Dublin Core; Spatial"},{"value":["Massachusetts"],"kind":"Dublin Core; Spatial"},{"value":["Suffolk"],"kind":"Dublin Core; Spatial"},{"value":["New England"],"kind":"Dublin Core; Spatial"},{"value":["US"],"kind":"Dublin Core; Spatial"},{"value":["MA"],"kind":"Dublin Core; Spatial"},{"value":["Eastern Massachusetts"],"kind":"Dublin Core; Spatial"},{"value":["Northern Hemisphere"],"kind":"Dublin Core; Spatial"},{"value":["Western Hemisphere"],"kind":"Dublin Core; Spatial"},{"value":["United States"],"kind":"Dublin Core; Spatial"},{"value":["polygon"],"kind":"Dublin Core; Subject"},{"value":["structure"],"kind":"Dublin Core; Subject"},{"value":["Buildings"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["G-polygon"],"kind":"Subject scheme not provided"}],"summary":["This polygon layer represents building footprints in Boston, MA"]},"sort":[2.0,1326931200000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_US_MA_BOSTON_G47PARCELS_2012","_score":2.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_BOSTON_G47PARCELS_2012","timdex_record_id":"gismit:SDE_DATA_US_MA_BOSTON_G47PARCELS_2012","title":"Boston, MA (Land Parcels, 2012)","citation":"Boston (Mass.) Assessing Department. Boston, MA (Land Parcels, 2012). City of Boston Assessing Department. Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_BOSTON_G47PARCELS_2012","content_type":["Geospatial data"],"contributors":[{"value":"Boston (Mass.) Assessing Department","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2012-01-01"},{"kind":"Coverage","value":"2012-01-01"},{"kind":"Coverage","value":"2012"}],"format":"Vector","identifiers":[{"value":"US_MA_BOSTON_G47PARCELS_2012","kind":"Not specified"}],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_BOSTON_G47PARCELS_2012.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_BOSTON_G47PARCELS_2012.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/SDE_DATA_US_MA_BOSTON_G47PARCELS_2012.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-71.191182, -70.922637, 42.397564, 42.227005)"},{"kind":"Geometry","geoshape":"BBOX (-71.191182, -70.922637, 42.397564, 42.227005)"}],"publication_information":["City of Boston Assessing Department","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"N/A"}],"subjects":[{"value":["Boundaries"],"kind":"DCAT; Theme"},{"value":["Location"],"kind":"DCAT; Theme"},{"value":["Massachusetts--Boston"],"kind":"Dublin Core; Spatial"},{"value":["Land use"],"kind":"Dublin Core; Subject"},{"value":["Administrative and political divisions"],"kind":"Dublin Core; Subject"},{"value":["Land value taxation"],"kind":"Dublin Core; Subject"},{"value":["Land tenure"],"kind":"Dublin Core; Subject"},{"value":["Neighborhoods"],"kind":"Dublin Core; Subject"},{"value":["boundaries"],"kind":"Dublin Core; Subject"},{"value":["location"],"kind":"Dublin Core; Subject"},{"value":["planningCadastre"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["GT-polygon composed of chains"],"kind":"Subject scheme not provided"}],"summary":["City of Boston property parcel data from FY 2012 was joined with parcel boundaries from FY 2012. All data is from the City of Boston Assessor's office and represents data from 2011."]},"sort":[2.0,1325376000000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:GISPORTAL_GISOWNER01_CAMBRIDGENHOODCONSVDIST07","_score":2.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:GISPORTAL_GISOWNER01_CAMBRIDGENHOODCONSVDIST07","timdex_record_id":"gismit:GISPORTAL_GISOWNER01_CAMBRIDGENHOODCONSVDIST07","title":"Neighborhood Conservation Districts Cambridge MA 2007","citation":"Cambridge (Mass.). Geographic Information Systems. Neighborhood Conservation Districts Cambridge MA 2007. GIS Lab, MIT Libraries. Geospatial data. https://search.libraries.mit.edu/record/gismit:GISPORTAL_GISOWNER01_CAMBRIDGENHOODCONSVDIST07","content_type":["Geospatial data"],"contributors":[{"value":"Cambridge (Mass.). Geographic Information Systems","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2011-07-20"}],"format":"Vector","identifiers":[{"value":"CambridgeNhoodConsvDist07","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/GISPORTAL_GISOWNER01_CAMBRIDGENHOODCONSVDIST07.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/GISPORTAL_GISOWNER01_CAMBRIDGENHOODCONSVDIST07.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/GISPORTAL_GISOWNER01_CAMBRIDGENHOODCONSVDIST07.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-71.134050, -71.099268, 42.388156, 42.366734)"},{"kind":"Geometry","geoshape":"BBOX (-71.134050, -71.099268, 42.388156, 42.366734)"}],"publication_information":["GIS Lab, MIT Libraries"],"rights":[{"description":"Public","kind":"Access"},{"description":"For educational noncommercial use only."}],"subjects":[{"value":["Boundaries"],"kind":"DCAT; Theme"},{"value":["Society"],"kind":"DCAT; Theme"},{"value":["Structure"],"kind":"DCAT; Theme"},{"value":["Massachusetts--Cambridge"],"kind":"Dublin Core; Spatial"},{"value":["Historic districts--Conservation and restoration"],"kind":"Dublin Core; Subject"},{"value":["boundaries"],"kind":"Dublin Core; Subject"},{"value":["society"],"kind":"Dublin Core; Subject"},{"value":["structure"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["G-polygon"],"kind":"Subject scheme not provided"}],"summary":["This dataset contains five polygons representing Neighborhood Conservation Districts (NCDs) in Cambridge, MA. Conservation districts are groups of buildings and their surroundings that are architecturally and historically distinctive."]},"sort":[2.0,1311120000000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_US_P2MAJRDS_2005","_score":2.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_P2MAJRDS_2005","timdex_record_id":"gismit:SDE_DATA_US_P2MAJRDS_2005","title":"USA (Major Roads, 2005)","citation":"Tele Atlas North America, Inc./Geographic Data Technology, Inc., ESRI. USA (Major Roads, 2005). Environmental Systems Research Institute (ESRI). Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_P2MAJRDS_2005","content_type":["Geospatial data"],"contributors":[{"value":"Tele Atlas North America, Inc./Geographic Data Technology, Inc.","kind":"Creator"},{"value":"ESRI","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2005-04-01"},{"kind":"Coverage","value":"2004-01-01"},{"kind":"Coverage","value":"2005-01-01"},{"kind":"Coverage","value":"2011-04-20"},{"kind":"Coverage","value":"2001-05-20"},{"kind":"Coverage","value":"2004"},{"kind":"Coverage","value":"2005"},{"kind":"Coverage","value":"2011"},{"kind":"Coverage","value":"2001"}],"format":"Vector","identifiers":[{"value":"SDE_DATA.US_P2MAJRDS_2005","kind":"Not specified"},{"value":"US_P2MAJRDS_2005","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_P2MAJRDS_2005.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_P2MAJRDS_2005.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/SDE_DATA_US_P2MAJRDS_2005.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-166.556498, -65.259590, 71.306880, 17.949201)"},{"kind":"Geometry","geoshape":"BBOX (-166.556498, -65.259590, 71.306880, 17.949201)"}],"publication_information":["Environmental Systems Research Institute (ESRI)","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"}],"subjects":[{"value":["Transportation"],"kind":"DCAT; Theme"},{"value":["United States"],"kind":"Dublin Core; Spatial"},{"value":["Transportation"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["String"],"kind":"Subject scheme not provided"}],"summary":["U.S. Major Roads represents interstate, U.S. and state highways, major streets, and other major thoroughfares within the United States."]},"sort":[2.0,1303257600000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_US_P1TRANSTERMS_2005","_score":2.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_P1TRANSTERMS_2005","timdex_record_id":"gismit:SDE_DATA_US_P1TRANSTERMS_2005","title":"USA (Transportation Terminals, 2005)","citation":"Tele Atlas North America, Inc./Geographic Data Technology, Inc., ESRI. USA (Transportation Terminals, 2005). Environmental Systems Research Institute (ESRI). Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_P1TRANSTERMS_2005","content_type":["Geospatial data"],"contributors":[{"value":"Tele Atlas North America, Inc./Geographic Data Technology, Inc.","kind":"Creator"},{"value":"ESRI","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2005-04-01"},{"kind":"Coverage","value":"2004-01-01"},{"kind":"Coverage","value":"2005-01-01"},{"kind":"Coverage","value":"2011-04-20"},{"kind":"Coverage","value":"2001-05-20"},{"kind":"Coverage","value":"2004"},{"kind":"Coverage","value":"2005"},{"kind":"Coverage","value":"2011"},{"kind":"Coverage","value":"2001"}],"format":"Vector","identifiers":[{"value":"SDE_DATA.US_P1TRANSTERMS_2005","kind":"Not specified"},{"value":"US_P1TRANSTERMS_2005","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_P1TRANSTERMS_2005.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_P1TRANSTERMS_2005.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/SDE_DATA_US_P1TRANSTERMS_2005.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-166.498692, -65.302143, 61.122378, 18.152193)"},{"kind":"Geometry","geoshape":"BBOX (-166.498692, -65.302143, 61.122378, 18.152193)"}],"publication_information":["Environmental Systems Research Institute (ESRI)","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"}],"subjects":[{"value":["Transportation"],"kind":"DCAT; Theme"},{"value":["United States"],"kind":"Dublin Core; Spatial"},{"value":["Transportation"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity point"],"kind":"Subject scheme not provided"}],"summary":["U.S. TANA/GDT Transportation Terminals represents locations within United States for transportation terminals such as bus terminals, train stations, marine terminals, and other significant transportation nodes."]},"sort":[2.0,1303257600000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_CA_F7REGNMUNI_2005","_score":2.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_CA_F7REGNMUNI_2005","timdex_record_id":"gismit:SDE_DATA_CA_F7REGNMUNI_2005","title":"Canada (Regional Municipalities, 2005)","citation":"DMTI Spatial Inc., Environmental Systems Research Institute (Redlands, Calif.). Canada (Regional Municipalities, 2005). Environmental Systems Research Institute (Redlands, Calif.). Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_CA_F7REGNMUNI_2005","content_type":["Geospatial data"],"contributors":[{"value":"DMTI Spatial Inc.","kind":"Creator"},{"value":"Environmental Systems Research Institute (Redlands, Calif.)","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2005-04-01"},{"kind":"Coverage","value":"2004-01-01"},{"kind":"Coverage","value":"2001-01-01"},{"kind":"Coverage","value":"2011-04-20"},{"kind":"Coverage","value":"2004"},{"kind":"Coverage","value":"2001"},{"kind":"Coverage","value":"2011"}],"format":"Vector","identifiers":[{"value":"SDE_DATA.CA_F7REGNMUNI_2005","kind":"Not specified"},{"value":"CA_F7REGNMUNI_2005","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_CA_F7REGNMUNI_2005.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_CA_F7REGNMUNI_2005.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/SDE_DATA_CA_F7REGNMUNI_2005.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-141.001870, -52.619170, 83.115063, 41.687973)"},{"kind":"Geometry","geoshape":"BBOX (-141.001870, -52.619170, 83.115063, 41.687973)"}],"publication_information":["Environmental Systems Research Institute (Redlands, Calif.)","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"}],"subjects":[{"value":["Boundaries"],"kind":"DCAT; Theme"},{"value":["Canada"],"kind":"Dublin Core; Spatial"},{"value":["Administrative and political divisions"],"kind":"Dublin Core; Subject"},{"value":["Cities and towns"],"kind":"Dublin Core; Subject"},{"value":["boundaries"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["G-polygon"],"kind":"Subject scheme not provided"}],"summary":["Canada Regional Municipalities represents the regional municipalities (counties) within Canada including regional districts and municipalities, counties, communauté, regions, and districts. The boundaries are digitized from CanMap®."]},"sort":[2.0,1303257600000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_CA_F7MUNI_2005","_score":2.0,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_CA_F7MUNI_2005","timdex_record_id":"gismit:SDE_DATA_CA_F7MUNI_2005","title":"Canada (Municipalities, 2005)","citation":"DMTI Spatial Inc., Environmental Systems Research Institute (Redlands, Calif.). Canada (Municipalities, 2005). Environmental Systems Research Institute (Redlands, Calif.). Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_CA_F7MUNI_2005","content_type":["Geospatial data"],"contributors":[{"value":"DMTI Spatial Inc.","kind":"Creator"},{"value":"Environmental Systems Research Institute (Redlands, Calif.)","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2005-04-01"},{"kind":"Coverage","value":"2004-01-01"},{"kind":"Coverage","value":"2001-01-01"},{"kind":"Coverage","value":"2011-04-20"},{"kind":"Coverage","value":"2004"},{"kind":"Coverage","value":"2001"},{"kind":"Coverage","value":"2011"}],"format":"Vector","identifiers":[{"value":"SDE_DATA.CA_F7MUNI_2005","kind":"Not specified"},{"value":"CA_F7MUNI_2005","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_CA_F7MUNI_2005.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_CA_F7MUNI_2005.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/SDE_DATA_CA_F7MUNI_2005.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-141.001870, -52.619173, 83.115063, 41.687973)"},{"kind":"Geometry","geoshape":"BBOX (-141.001870, -52.619173, 83.115063, 41.687973)"}],"publication_information":["Environmental Systems Research Institute (Redlands, Calif.)","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"}],"subjects":[{"value":["Boundaries"],"kind":"DCAT; Theme"},{"value":["Canada"],"kind":"Dublin Core; Spatial"},{"value":["Cities and towns"],"kind":"Dublin Core; Subject"},{"value":["Villages"],"kind":"Dublin Core; Subject"},{"value":["Parishes (Local government)"],"kind":"Dublin Core; Subject"},{"value":["Administrative and political divisions"],"kind":"Dublin Core; Subject"},{"value":["Inuit--Land tenure"],"kind":"Dublin Core; Subject"},{"value":["boundaries"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["G-polygon"],"kind":"Subject scheme not provided"}],"summary":["Canada Municipalities represents the municipalities (townships) within Canada of types including cities, cantons, hamlets, towns/ville, villages, Indian reserves, parishes/paroisse, communities, unorganized, districts, and terre Inuite. The boundaries are digitized from CanMap®."]},"sort":[2.0,1303257600000]}]},"aggregations":{"languages":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[{"key":"eng","doc_count":808}]},"content_type":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[{"key":"geospatial data","doc_count":825}]},"subjects":{"doc_count":7447,"subject_names":{"doc_count_error_upper_bound":0,"sum_other_doc_count":4183,"buckets":[{"key":"datasets","doc_count":825},{"key":"g-polygon","doc_count":416},{"key":"boundaries","doc_count":376},{"key":"transportation","doc_count":348},{"key":"united states","doc_count":270},{"key":"entity point","doc_count":256},{"key":"society","doc_count":246},{"key":"massachusetts--cambridge","doc_count":197},{"key":"structure","doc_count":166},{"key":"location","doc_count":164}]}},"content_format":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[{"key":"vector","doc_count":824},{"key":"point","doc_count":1}]},"literary_form":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[]},"source":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[{"key":"mit gis resources","doc_count":825}]},"contributors":{"doc_count":1011,"contributor_names":{"doc_count_error_upper_bound":0,"sum_other_doc_count":427,"buckets":[{"key":"massgis (office : mass.)","doc_count":134},{"key":"esri","doc_count":84},{"key":"city of cambridge gis","doc_count":82},{"key":"platts","doc_count":64},{"key":"environmental systems research institute (redlands, calif.)","doc_count":49},{"key":"environmental systems research institute, inc. (esri)","doc_count":44},{"key":"cambridge (mass.). geographic information systems","doc_count":41},{"key":"tele atlas b.v.","doc_count":32},{"key":"usgs","doc_count":28},{"key":"city of newton gis","doc_count":26}]}}}} + recorded_at: Wed, 14 Feb 2024 16:44:24 GMT +recorded_with: VCR 6.2.0 diff --git a/test/vcr_cassettes/graphqlv2_geobox_with_keyword.yml b/test/vcr_cassettes/graphqlv2_geobox_with_keyword.yml new file mode 100644 index 00000000..e7a79f80 --- /dev/null +++ b/test/vcr_cassettes/graphqlv2_geobox_with_keyword.yml @@ -0,0 +1,34 @@ +--- +http_interactions: +- request: + method: post + uri: http://localhost:9200/timdex-prod/_search + body: + encoding: UTF-8 + string: '{"from":"0","size":20,"query":{"bool":{"should":[{"prefix":{"title.exact_value":{"value":"train + stations","boost":15.0}}},{"term":{"title":{"value":"train stations","boost":1.0}}},{"nested":{"path":"contributors","query":{"term":{"contributors.value":{"value":"train + stations","boost":0.1}}}}}],"must":[{"multi_match":{"query":"train stations","fields":["alternate_titles","call_numbers","citation","contents","contributors.value","dates.value","edition","funding_information.*","identifiers.value","languages","locations.value","notes.value","numbering","publication_information","subjects.value","summary","title"]}},{"bool":{"must":{"match_all":{}},"filter":{"geo_bounding_box":{"locations.geoshape":{"top":42.886,"bottom":41.239,"left":-73.507,"right":-69.928}}}}}],"filter":[]}},"aggregations":{"contributors":{"nested":{"path":"contributors"},"aggs":{"contributor_names":{"terms":{"field":"contributors.value.keyword"}}}},"content_type":{"terms":{"field":"content_type"}},"content_format":{"terms":{"field":"format"}},"languages":{"terms":{"field":"languages.keyword"}},"literary_form":{"terms":{"field":"literary_form"}},"source":{"terms":{"field":"source"}},"subjects":{"nested":{"path":"subjects"},"aggs":{"subject_names":{"terms":{"field":"subjects.value.keyword"}}}}},"sort":[{"_score":{"order":"desc"}},{"dates.value.as_date":{"order":"desc","nested":{"path":"dates"}}}]}' + headers: + User-Agent: + - 'opensearch-ruby/3.1.0 (RUBY_VERSION: 3.2.2; darwin arm64; Faraday v2.9.0)' + Content-Type: + - application/json + Accept-Encoding: + - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 + Accept: + - "*/*" + response: + status: + code: 200 + message: OK + headers: + Content-Type: + - application/json; charset=UTF-8 + Content-Length: + - '55942' + body: + encoding: ASCII-8BIT + string: !binary |- + {"took":12,"timed_out":false,"_shards":{"total":1,"successful":1,"skipped":0,"failed":0},"hits":{"total":{"value":38,"relation":"eq"},"max_score":null,"hits":[{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_US_P1TRANTERM_2006","_score":13.357168,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_P1TRANTERM_2006","timdex_record_id":"gismit:SDE_DATA_US_P1TRANTERM_2006","title":"USA (Transportation Terminals, 2006)","citation":"Tele Atlas North America, Inc., ESRI. USA (Transportation Terminals, 2006). Environmental Systems Research Institute (ESRI). Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_P1TRANTERM_2006","content_type":["Geospatial data"],"contributors":[{"value":"Tele Atlas North America, Inc.","kind":"Creator"},{"value":"ESRI","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2006-10-01"},{"kind":"Coverage","value":"2006-10-01"},{"kind":"Coverage","value":"2006"}],"format":"Vector","identifiers":[{"value":"SDE_DATA.US_P1TRANTERM_2006","kind":"Not specified"},{"value":"US_P1TRANTERM_2006","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_P1TRANTERM_2006.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_P1TRANTERM_2006.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/SDE_DATA_US_P1TRANTERM_2006.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-166.498692, -65.302143, 61.122378, 18.152193)"},{"kind":"Geometry","geoshape":"BBOX (-166.498692, -65.302143, 61.122378, 18.152193)"}],"publication_information":["Environmental Systems Research Institute (ESRI)","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"}],"subjects":[{"value":["Transportation"],"kind":"DCAT; Theme"},{"value":["United States"],"kind":"Dublin Core; Spatial"},{"value":["Transportation"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity point"],"kind":"Subject scheme not provided"}],"summary":["U.S. Transportation Terminals represents locations within United States for transportation terminals such as bus stations, train stations, marine terminals, and other significant transportation nodes."]},"sort":[13.357168,1159660800000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_US_MA_P3STATIONS_2004","_score":12.189892,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_P3STATIONS_2004","timdex_record_id":"gismit:SDE_DATA_US_MA_P3STATIONS_2004","title":"Massachusetts (Train Stations 2004)","citation":"MassGIS (Office : Mass.). Massachusetts (Train Stations 2004). MassGIS (Office : Mass.). Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_P3STATIONS_2004","content_type":["Geospatial data"],"contributors":[{"value":"MassGIS (Office : Mass.)","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2004-04-01"},{"kind":"Coverage","value":"2004-04-01"},{"kind":"Coverage","value":"2004"}],"format":"Vector","identifiers":[{"value":"SDE_DATA.US_MA_P3STATIONS_2004","kind":"Not specified"},{"value":"US_MA_P3STATIONS_2004","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_P3STATIONS_2004.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_P3STATIONS_2004.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_P3STATIONS_2004.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-73.448832, -69.923328, 42.979186, 41.256493)"},{"kind":"Geometry","geoshape":"BBOX (-73.448832, -69.923328, 42.979186, 41.256493)"}],"publication_information":["MassGIS (Office : Mass.)","GIS Lab, MIT Libraries"],"rights":[{"description":"Public","kind":"Access"}],"subjects":[{"value":["Transportation"],"kind":"DCAT; Theme"},{"value":["Massachusetts"],"kind":"Dublin Core; Spatial"},{"value":["Railroads"],"kind":"Dublin Core; Subject"},{"value":["Massachusetts Bay Transportation Authority"],"kind":"Dublin Core; Subject"},{"value":["transportation"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity point"],"kind":"Subject scheme not provided"}],"summary":["The Central Transportation Planning Staff updated and enhanced railroad linework distributed by the United States Geological Survey (USGS) as 1:100,000 Digital Line Graphs (DLGs). The original 1:100,000 DLG data were conflated to the orthophoto-derived 1:5,000 Centerline linework. This data layer is much more detailed than pre-April 2004 trains data and has many more abandoned rail lines. In many instances there is more than one track per rail line, and rail yards and spurs are included.CTPS added several attributes pertaining to type of service, MBTA Commuter Rail status and stations (current and proposed, including the Greenbush line), rail line ownership, and freight and passenger operation.Stored in ArcSDE and distributed as shapefiles, the statewide layers include arcs (TRAINS_ARC), nodes (station locations, TRAINS_NODE) and routes (TRAINS_RTE_TRAIN). MassGIS also makes available an ArcInfo coverage version named TRAINS.Other tranportation linework that appears on the USGS 1:100,000-scale maps, such as pipelines and transmission lines, are included in the TRNSLNS layer. The MBTA subway lines are included in the MBTA layer."]},"sort":[12.189892,1080777600000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_US_MA_BOSTON_P33MBTAS_1998","_score":12.189892,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_BOSTON_P33MBTAS_1998","timdex_record_id":"gismit:SDE_DATA_US_MA_BOSTON_P33MBTAS_1998","title":"Massachusetts (Train Stations, 1998)","citation":"MassGIS (Office : Mass.). Massachusetts (Train Stations, 1998). MassGIS (Office : Mass.). Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_BOSTON_P33MBTAS_1998","content_type":["Geospatial data"],"contributors":[{"value":"MassGIS (Office : Mass.)","kind":"Creator"}],"dates":[{"kind":"Issued","value":"1998-06-01"},{"kind":"Coverage","value":"1998-06-01"},{"kind":"Coverage","value":"1998"}],"format":"Vector","identifiers":[{"value":"SDE_DATA.US_MA_BOSTON_P33MBTAS_1998","kind":"Not specified"},{"value":"US_MA_BOSTON_P33MBTAS_1998","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_BOSTON_P33MBTAS_1998.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_BOSTON_P33MBTAS_1998.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_BOSTON_P33MBTAS_1998.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-73.426828, -69.957662, 42.871873, 41.510010)"},{"kind":"Geometry","geoshape":"BBOX (-73.426828, -69.957662, 42.871873, 41.510010)"}],"publication_information":["MassGIS (Office : Mass.)","GIS Lab, MIT Libraries"],"rights":[{"description":"Public","kind":"Access"}],"subjects":[{"value":["Transportation"],"kind":"DCAT; Theme"},{"value":["Massachusetts"],"kind":"Dublin Core; Spatial"},{"value":["Subway stations"],"kind":"Dublin Core; Subject"},{"value":["Massachusetts Bay Transportation Authority"],"kind":"Dublin Core; Subject"},{"value":["Railroads"],"kind":"Dublin Core; Subject"},{"value":["transportation"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity point"],"kind":"Subject scheme not provided"}],"summary":["This layer represents train stops for the Commonwealth of Massachusetts. The Central Transportation Plannig Staff will update the datalayer as needed."]},"sort":[12.189892,896659200000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_US_MA_P3STATN_1998","_score":11.958282,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_P3STATN_1998","timdex_record_id":"gismit:SDE_DATA_US_MA_P3STATN_1998","title":"Massachusetts (MBTA Train Stations, 1998)","citation":"MassGIS (Office : Mass.). Massachusetts (MBTA Train Stations, 1998). MassGIS (Office : Mass.). Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_P3STATN_1998","content_type":["Geospatial data"],"contributors":[{"value":"MassGIS (Office : Mass.)","kind":"Creator"}],"dates":[{"kind":"Issued","value":"1998-06-01"},{"kind":"Coverage","value":"1998-06-01"},{"kind":"Coverage","value":"1998"}],"format":"Vector","identifiers":[{"value":"SDE_DATA.US_MA_P3STATN_1998","kind":"Not specified"},{"value":"US_MA_P3STATN_1998","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_P3STATN_1998.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_P3STATN_1998.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_P3STATN_1998.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-71.255256, -70.991557, 42.436615, 42.207375)"},{"kind":"Geometry","geoshape":"BBOX (-71.255256, -70.991557, 42.436615, 42.207375)"}],"publication_information":["MassGIS (Office : Mass.)","GIS Lab, MIT Libraries"],"rights":[{"description":"Public","kind":"Access"}],"subjects":[{"value":["Transportation"],"kind":"DCAT; Theme"},{"value":["Massachuetts"],"kind":"Dublin Core; Spatial"},{"value":["Subway stations"],"kind":"Dublin Core; Subject"},{"value":["Massachusetts Bay Transportation Authority"],"kind":"Dublin Core; Subject"},{"value":["Railroads"],"kind":"Dublin Core; Subject"},{"value":["transportation"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity point"],"kind":"Subject scheme not provided"}],"summary":["This datalayer comprises the four subway and streetcar lines in the Massachusetts Bay Transportation Authority’s rapid transit rail network. The four ‘T’ lines - Blue, Green, Orange, and Red - are represented with linework. Stations are contained in a node feature class. Station names are included in nodetext and annotation. The coverage was developed by the Central Transportation Planning Staff (CTPS) and is stored as a single statewide layer called MBTA. The Central Transportation Plannig Staff will update the datalayer as needed."]},"sort":[11.958282,896659200000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_US_P1TRAN_1999","_score":11.934823,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_P1TRAN_1999","timdex_record_id":"gismit:SDE_DATA_US_P1TRAN_1999","title":"USA (GDT Transportation Terminals, 1999)","citation":"Geographic Data Technology, Inc. (GDT), Environmental Systems Research Institute, Inc. (ESRI). USA (GDT Transportation Terminals, 1999). Environmental Systems Research Institute (ESRI). Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_P1TRAN_1999","content_type":["Geospatial data"],"contributors":[{"value":"Geographic Data Technology, Inc. (GDT)","kind":"Creator"},{"value":"Environmental Systems Research Institute, Inc. (ESRI)","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2000-11-01"},{"kind":"Coverage","value":"1999-01-01"},{"kind":"Coverage","value":"1999"}],"format":"Vector","identifiers":[{"value":"SDE_DATA.US_P1TRAN_1999","kind":"Not specified"},{"value":"US_P1TRAN_1999","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_P1TRAN_1999.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_P1TRAN_1999.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/SDE_DATA_US_P1TRAN_1999.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-131.720039, -66.984444, 55.360922, 24.554827)"},{"kind":"Geometry","geoshape":"BBOX (-131.720039, -66.984444, 55.360922, 24.554827)"}],"publication_information":["Environmental Systems Research Institute (ESRI)","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"}],"subjects":[{"value":["Transportation"],"kind":"DCAT; Theme"},{"value":["United States"],"kind":"Dublin Core; Spatial"},{"value":["Transportation"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity point"],"kind":"Subject scheme not provided"}],"summary":["U.S. GDT Transportation Terminals represents locations within United States for transportation terminals such as bus terminals, train stations, marine terminals, and other significant transportation nodes."]},"sort":[11.934823,973036800000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_US_P1TRANSTERMS_2005","_score":11.815713,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_P1TRANSTERMS_2005","timdex_record_id":"gismit:SDE_DATA_US_P1TRANSTERMS_2005","title":"USA (Transportation Terminals, 2005)","citation":"Tele Atlas North America, Inc./Geographic Data Technology, Inc., ESRI. USA (Transportation Terminals, 2005). Environmental Systems Research Institute (ESRI). Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_P1TRANSTERMS_2005","content_type":["Geospatial data"],"contributors":[{"value":"Tele Atlas North America, Inc./Geographic Data Technology, Inc.","kind":"Creator"},{"value":"ESRI","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2005-04-01"},{"kind":"Coverage","value":"2004-01-01"},{"kind":"Coverage","value":"2005-01-01"},{"kind":"Coverage","value":"2011-04-20"},{"kind":"Coverage","value":"2001-05-20"},{"kind":"Coverage","value":"2004"},{"kind":"Coverage","value":"2005"},{"kind":"Coverage","value":"2011"},{"kind":"Coverage","value":"2001"}],"format":"Vector","identifiers":[{"value":"SDE_DATA.US_P1TRANSTERMS_2005","kind":"Not specified"},{"value":"US_P1TRANSTERMS_2005","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_P1TRANSTERMS_2005.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_P1TRANSTERMS_2005.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/SDE_DATA_US_P1TRANSTERMS_2005.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-166.498692, -65.302143, 61.122378, 18.152193)"},{"kind":"Geometry","geoshape":"BBOX (-166.498692, -65.302143, 61.122378, 18.152193)"}],"publication_information":["Environmental Systems Research Institute (ESRI)","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"}],"subjects":[{"value":["Transportation"],"kind":"DCAT; Theme"},{"value":["United States"],"kind":"Dublin Core; Spatial"},{"value":["Transportation"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity point"],"kind":"Subject scheme not provided"}],"summary":["U.S. TANA/GDT Transportation Terminals represents locations within United States for transportation terminals such as bus terminals, train stations, marine terminals, and other significant transportation nodes."]},"sort":[11.815713,1303257600000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_US_MA_NEWTON_P33STOPS_1998","_score":8.478521,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_NEWTON_P33STOPS_1998","timdex_record_id":"gismit:SDE_DATA_US_MA_NEWTON_P33STOPS_1998","title":"Newton, MA (MBTA Train Stops, 1998)","citation":"City of Newton GIS. Newton, MA (MBTA Train Stops, 1998). Newton (MA) Geographic Information System (City of Newton GIS). Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_NEWTON_P33STOPS_1998","content_type":["Geospatial data"],"contributors":[{"value":"City of Newton GIS","kind":"Creator"}],"dates":[{"kind":"Issued","value":"1998-01-01"}],"format":"Vector","identifiers":[{"value":"SDE_DATA.US_MA_NEWTON_P33STOPS_1998","kind":"Not specified"},{"value":"US_MA_NEWTON_P33STOPS_1998","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_NEWTON_P33STOPS_1998.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_NEWTON_P33STOPS_1998.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_NEWTON_P33STOPS_1998.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-71.252840, -71.164534, 42.351459, 42.319077)"},{"kind":"Geometry","geoshape":"BBOX (-71.252840, -71.164534, 42.351459, 42.319077)"}],"publication_information":["Newton (MA) Geographic Information System (City of Newton GIS)","GIS Lab, MIT Libraries"],"rights":[{"description":"Public","kind":"Access"}],"subjects":[{"value":["Transportation"],"kind":"DCAT; Theme"},{"value":["Massachusetts--Newton"],"kind":"Dublin Core; Spatial"},{"value":["Massachusetts Bay Transportation Authority"],"kind":"Dublin Core; Subject"},{"value":["Railroads"],"kind":"Dublin Core; Subject"},{"value":["Subway stations"],"kind":"Dublin Core; Subject"},{"value":["transportation"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity point"],"kind":"Subject scheme not provided"}],"summary":["This coverage contains stops along the MBTA train lines in Newton."]},"sort":[8.478521,883612800000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_US_MA_BOSTON_P3RR_1995","_score":8.108314,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_BOSTON_P3RR_1995","timdex_record_id":"gismit:SDE_DATA_US_MA_BOSTON_P3RR_1995","title":"Boston, MA (Railroads, 1995)","citation":"Boston Water and Sewer Commission. Boston, MA (Railroads, 1995). Boston Redevelopment Authority. Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_BOSTON_P3RR_1995","content_type":["Geospatial data"],"contributors":[{"value":"Boston Water and Sewer Commission","kind":"Creator"}],"dates":[{"kind":"Issued","value":"1995-01-01"},{"kind":"Coverage","value":"1995-01-01"},{"kind":"Coverage","value":"1995"}],"format":"Vector","identifiers":[{"value":"SDE_DATA.US_MA_BOSTON_P3RR_1995","kind":"Not specified"},{"value":"US_MA_BOSTON_P3RR_1995","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_BOSTON_P3RR_1995.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_BOSTON_P3RR_1995.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_BOSTON_P3RR_1995.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-71.186845, -70.993797, 42.396068, 42.229213)"},{"kind":"Geometry","geoshape":"BBOX (-71.186845, -70.993797, 42.396068, 42.229213)"}],"publication_information":["Boston Redevelopment Authority","GIS Lab, MIT Libraries"],"rights":[{"description":"Public","kind":"Access"}],"subjects":[{"value":["Transportation"],"kind":"DCAT; Theme"},{"value":["Massachusetts--Boston"],"kind":"Dublin Core; Spatial"},{"value":["Railroads"],"kind":"Dublin Core; Subject"},{"value":["Transportation"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["String"],"kind":"Subject scheme not provided"}],"summary":["Compilation of all railroad lines in the City of Boston (exclusive of MBTA train lines)."]},"sort":[8.108314,788918400000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_US_MA_P3TRAIN_1998","_score":7.616976,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_P3TRAIN_1998","timdex_record_id":"gismit:SDE_DATA_US_MA_P3TRAIN_1998","title":"Massachusetts (Statewide Train Lines, 1998)","citation":"MassGIS (Office : Mass.). Massachusetts (Statewide Train Lines, 1998). MassGIS (Office : Mass.). Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_P3TRAIN_1998","content_type":["Geospatial data"],"contributors":[{"value":"MassGIS (Office : Mass.)","kind":"Creator"}],"dates":[{"kind":"Issued","value":"1998-06-01"},{"kind":"Coverage","value":"1998-06-01"},{"kind":"Coverage","value":"1998"}],"format":"Vector","identifiers":[{"value":"SDE_DATA.US_MA_P3TRAIN_1998","kind":"Not specified"},{"value":"US_MA_P3TRAIN_1998","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_P3TRAIN_1998.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_P3TRAIN_1998.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_P3TRAIN_1998.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-73.426828, -69.955632, 42.871873, 41.509868)"},{"kind":"Geometry","geoshape":"BBOX (-73.426828, -69.955632, 42.871873, 41.509868)"}],"publication_information":["MassGIS (Office : Mass.)","GIS Lab, MIT Libraries"],"rights":[{"description":"Public","kind":"Access"}],"subjects":[{"value":["Transportation"],"kind":"DCAT; Theme"},{"value":["Massachusetts"],"kind":"Dublin Core; Spatial"},{"value":["Locomotives"],"kind":"Dublin Core; Subject"},{"value":["Massachusetts Bay Transportation Authority"],"kind":"Dublin Core; Subject"},{"value":["Railroads"],"kind":"Dublin Core; Subject"},{"value":["transportation"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["String"],"kind":"Subject scheme not provided"}],"summary":["This layer represents train lines for the Commonwealth of Massachusetts. The Central Transportation Plannig Staff will update the datalayer as needed."]},"sort":[7.616976,896659200000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_US_MA_BOSTON_P33CMMTR_1998","_score":7.467951,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_BOSTON_P33CMMTR_1998","timdex_record_id":"gismit:SDE_DATA_US_MA_BOSTON_P33CMMTR_1998","title":"Massachusetts (Commuter Rail, 1998)","citation":"MassGIS (Office : Mass.). Massachusetts (Commuter Rail, 1998). MassGIS (Office : Mass.). Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_BOSTON_P33CMMTR_1998","content_type":["Geospatial data"],"contributors":[{"value":"MassGIS (Office : Mass.)","kind":"Creator"}],"dates":[{"kind":"Issued","value":"1998-06-01"},{"kind":"Coverage","value":"1998-06-01"},{"kind":"Coverage","value":"1998"}],"format":"Vector","identifiers":[{"value":"SDE_DATA.US_MA_BOSTON_P33CMMTR_1998","kind":"Not specified"},{"value":"US_MA_BOSTON_P33CMMTR_1998","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_BOSTON_P33CMMTR_1998.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_BOSTON_P33CMMTR_1998.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_BOSTON_P33CMMTR_1998.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-71.822212, -70.623422, 42.871873, 41.780695)"},{"kind":"Geometry","geoshape":"BBOX (-71.822212, -70.623422, 42.871873, 41.780695)"}],"publication_information":["MassGIS (Office : Mass.)","GIS Lab, MIT Libraries"],"rights":[{"description":"Public","kind":"Access"}],"subjects":[{"value":["Transportation"],"kind":"DCAT; Theme"},{"value":["Massachuetts"],"kind":"Dublin Core; Spatial"},{"value":["Locomotives"],"kind":"Dublin Core; Subject"},{"value":["Massachusets Bay Transportation Authority"],"kind":"Dublin Core; Subject"},{"value":["Railroad"],"kind":"Dublin Core; Subject"},{"value":["transportation"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["String"],"kind":"Subject scheme not provided"}],"summary":["This layer represents commuter rail train lines for the Boston Metropolitan area. The Central Transportation Plannig Staff will update the datalayer as needed."]},"sort":[7.467951,896659200000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_US_MA_P3TRAINTRACKS_2004","_score":7.140089,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_P3TRAINTRACKS_2004","timdex_record_id":"gismit:SDE_DATA_US_MA_P3TRAINTRACKS_2004","title":"Massachusetts (Train Tracks, 2004)","citation":"MassGIS (Office : Mass.). Massachusetts (Train Tracks, 2004). MassGIS (Office : Mass.). Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_P3TRAINTRACKS_2004","content_type":["Geospatial data"],"contributors":[{"value":"MassGIS (Office : Mass.)","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2004-04-01"},{"kind":"Coverage","value":"2004-04-01"},{"kind":"Coverage","value":"2004"}],"format":"Vector","identifiers":[{"value":"SDE_DATA.US_MA_P3TRAINTRACKS_2004","kind":"Not specified"},{"value":"US_MA_P3TRAINTRACKS_2004","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_P3TRAINTRACKS_2004.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_P3TRAINTRACKS_2004.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_P3TRAINTRACKS_2004.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-73.448832, -69.922575, 42.979186, 41.232898)"},{"kind":"Geometry","geoshape":"BBOX (-73.448832, -69.922575, 42.979186, 41.232898)"}],"publication_information":["MassGIS (Office : Mass.)","GIS Lab, MIT Libraries"],"rights":[{"description":"Public","kind":"Access"}],"subjects":[{"value":["Transportation"],"kind":"DCAT; Theme"},{"value":["Massachusetts"],"kind":"Dublin Core; Spatial"},{"value":["Railroads"],"kind":"Dublin Core; Subject"},{"value":["Massachusetts Bay Transportation Authority"],"kind":"Dublin Core; Subject"},{"value":["transportation"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["String"],"kind":"Subject scheme not provided"}],"summary":["The Central Transportation Planning Staff updated and enhanced railroad linework distributed by the United States Geological Survey (USGS) as 1:100,000 Digital Line Graphs (DLGs). The original 1:100,000 DLG data were conflated to the orthophoto-derived 1:5,000 Centerline linework. This data layer is much more detailed than pre-April 2004 trains data and has many more abandoned rail lines. In many instances there is more than one track per rail line, and rail yards and spurs are included.CTPS added several attributes pertaining to type of service, MBTA Commuter Rail status and stations (current and proposed, including the Greenbush line), rail line ownership, and freight and passenger operation.Stored in ArcSDE and distributed as shapefiles, the statewide layers include arcs (TRAINS_ARC), nodes (station locations, TRAINS_NODE) and routes (TRAINS_RTE_TRAIN). MassGIS also makes available an ArcInfo coverage version named TRAINS.Other tranportation linework that appears on the USGS 1:100,000-scale maps, such as pipelines and transmission lines, are included in the TRNSLNS layer. The MBTA subway lines are included in the MBTA layer."]},"sort":[7.140089,1080777600000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_US_MA_P3RTS_2004","_score":7.140089,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_P3RTS_2004","timdex_record_id":"gismit:SDE_DATA_US_MA_P3RTS_2004","title":"Massachusetts (Train Routes 2004)","citation":"MassGIS (Office : Mass.). Massachusetts (Train Routes 2004). MassGIS (Office : Mass.). Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_P3RTS_2004","content_type":["Geospatial data"],"contributors":[{"value":"MassGIS (Office : Mass.)","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2004-04-01"},{"kind":"Coverage","value":"2004-04-01"},{"kind":"Coverage","value":"2004"}],"format":"Vector","identifiers":[{"value":"SDE_DATA.US_MA_P3RTS_2004","kind":"Not specified"},{"value":"US_MA_P3RTS_2004","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_P3RTS_2004.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_P3RTS_2004.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_P3RTS_2004.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-73.448832, -69.922575, 42.979186, 41.232898)"},{"kind":"Geometry","geoshape":"BBOX (-73.448832, -69.922575, 42.979186, 41.232898)"}],"publication_information":["MassGIS (Office : Mass.)","GIS Lab, MIT Libraries"],"rights":[{"description":"Public","kind":"Access"}],"subjects":[{"value":["Transportation"],"kind":"DCAT; Theme"},{"value":["Massachusetts"],"kind":"Dublin Core; Spatial"},{"value":["Locomotives"],"kind":"Dublin Core; Subject"},{"value":["Railroads"],"kind":"Dublin Core; Subject"},{"value":["Massachusetts Bay Transportation Authority"],"kind":"Dublin Core; Subject"},{"value":["transportation"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["String"],"kind":"Subject scheme not provided"}],"summary":["The Central Transportation Planning Staff updated and enhanced railroad linework distributed by the United States Geological Survey (USGS) as 1:100,000 Digital Line Graphs (DLGs). The original 1:100,000 DLG data were conflated to the orthophoto-derived 1:5,000 Centerline linework. This data layer is much more detailed than pre-April 2004 trains data and has many more abandoned rail lines. In many instances there is more than one track per rail line, and rail yards and spurs are included.CTPS added several attributes pertaining to type of service, MBTA Commuter Rail status and stations (current and proposed, including the Greenbush line), rail line ownership, and freight and passenger operation.Stored in ArcSDE and distributed as shapefiles, the statewide layers include arcs (TRAINS_ARC), nodes (station locations, TRAINS_NODE) and routes (TRAINS_RTE_TRAIN). MassGIS also makes available an ArcInfo coverage version named TRAINS.Other tranportation linework that appears on the USGS 1:100,000-scale maps, such as pipelines and transmission lines, are included in the TRNSLNS layer. The MBTA subway lines are included in the MBTA layer."]},"sort":[7.140089,1080777600000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_US_MA_CAMBRIDGE_P3EXITS_1995","_score":6.5663033,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_CAMBRIDGE_P3EXITS_1995","timdex_record_id":"gismit:SDE_DATA_US_MA_CAMBRIDGE_P3EXITS_1995","title":"Cambridge, MA (Train exits, 1995)","citation":"City of Cambridge GIS. Cambridge, MA (Train exits, 1995). Cambridge (MA) Geographic Information System (City of Cambridge GIS). Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_CAMBRIDGE_P3EXITS_1995","content_type":["Geospatial data"],"contributors":[{"value":"City of Cambridge GIS","kind":"Creator"}],"dates":[{"kind":"Issued","value":"1995-03-29"},{"kind":"Coverage","value":"1995-03-29"},{"kind":"Coverage","value":"1995"}],"format":"Vector","identifiers":[{"value":"SDE_DATA.US_MA_CAMBRIDGE_P3EXITS_1995","kind":"Not specified"},{"value":"US_MA_CAMBRIDGE_P3EXITS_1995","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_CAMBRIDGE_P3EXITS_1995.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_CAMBRIDGE_P3EXITS_1995.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/SDE_DATA_US_MA_CAMBRIDGE_P3EXITS_1995.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-71.144415, -71.077374, 42.398926, 42.362185)"},{"kind":"Geometry","geoshape":"BBOX (-71.144415, -71.077374, 42.398926, 42.362185)"}],"publication_information":["Cambridge (MA) Geographic Information System (City of Cambridge GIS)","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"}],"subjects":[{"value":["Transportation"],"kind":"DCAT; Theme"},{"value":["Structure"],"kind":"DCAT; Theme"},{"value":["Massachusetts--Cambridge"],"kind":"Dublin Core; Spatial"},{"value":["Subway stations"],"kind":"Dublin Core; Subject"},{"value":["Railroad stations"],"kind":"Dublin Core; Subject"},{"value":["transportation"],"kind":"Dublin Core; Subject"},{"value":["structure"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity point"],"kind":"Subject scheme not provided"}],"summary":["This layer provides a spatial representation of the all the T stations and emergency exits in the City of Cambridge."]},"sort":[6.5663033,796435200000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_US_MA_CAMBRIDGE_F8FIREST_1997","_score":6.3112288,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_CAMBRIDGE_F8FIREST_1997","timdex_record_id":"gismit:SDE_DATA_US_MA_CAMBRIDGE_F8FIREST_1997","title":"Cambridge, MA (Fire Stations, 1997)","citation":"Cambridge Fire Department. Cambridge, MA (Fire Stations, 1997). Cambridge (MA) Geographic Information System (City of Cambridge GIS). Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_MA_CAMBRIDGE_F8FIREST_1997","content_type":["Geospatial data"],"contributors":[{"value":"Cambridge Fire Department","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2008-06-24"},{"kind":"Coverage","value":"1997-01-01"},{"kind":"Coverage","value":"1997"}],"format":"Vector","identifiers":[{"value":"US_MA_CAMBRIDGE_F8FIREST_1997","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_CAMBRIDGE_F8FIREST_1997.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_MA_CAMBRIDGE_F8FIREST_1997.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/SDE_DATA_US_MA_CAMBRIDGE_F8FIREST_1997.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-71.140936, -71.078591, 42.391092, 42.362933)"},{"kind":"Geometry","geoshape":"BBOX (-71.140936, -71.078591, 42.391092, 42.362933)"}],"publication_information":["Cambridge (MA) Geographic Information System (City of Cambridge GIS)","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"},{"description":"City of Cambridge GIS Data Release Agreement1. The City of Cambridge provides Geographic Information Systems (\"GIS\") data in good faith. The City makes no warranty in regard to the data whatsoever, including, but not limited to, a warranty of the accuracy of the data. The party requesting the data (hereafter \"Requester\") agrees that the City has no liability arising from any incomplete, incorrect, inaccurate or misleading data provided. 2. The City makes no warranties of fitness or merchantability either express or implied in regard to the data provided to the Requester hereunder. The data provided are provided \"as is\" and with all faults. 3. The Requester will have no claims to data updates. 4. The Requester shall indemnify and hold harmless the City and its officers, employees and agents from and against all losses, claims, demands, actions, payments, costs, suits, liabilities, including attorney's fees, expenses and damages (direct or consequential) whether or not caused by the negligence of the City, its officers, employees or agents, which are incurred by or recovered against the City for any reason whatsoever arising out of or relating to this Agreement, or the data, or to any use to which the Requester might put the data."}],"subjects":[{"value":["Structure"],"kind":"DCAT; Theme"},{"value":["Massachusetts--Cambridge"],"kind":"Dublin Core; Spatial"},{"value":["Fire stations"],"kind":"Dublin Core; Subject"},{"value":["structure"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity point"],"kind":"Subject scheme not provided"}],"summary":["This point layer contains the eight fire stations within the City of Cambridge."]},"sort":[6.3112288,1214265600000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_US_N42ALTFUELS_2006","_score":6.2446747,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_N42ALTFUELS_2006","timdex_record_id":"gismit:SDE_DATA_US_N42ALTFUELS_2006","title":"USA (Alternative Fuel Stations, 2006)","citation":"National Renewable Energy Laboratory. USA (Alternative Fuel Stations, 2006). U.S. National Renewable Energy Laboratory (NREL). Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_N42ALTFUELS_2006","content_type":["Geospatial data"],"contributors":[{"value":"National Renewable Energy Laboratory","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2006-12-01"},{"kind":"Coverage","value":"2006-12-01"},{"kind":"Coverage","value":"2006"}],"format":"Vector","identifiers":[{"value":"SDE_DATA.US_N42ALTFUELS_2006","kind":"Not specified"},{"value":"US_N42ALTFUELS_2006","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_N42ALTFUELS_2006.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_N42ALTFUELS_2006.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_N42ALTFUELS_2006.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-157.928516, -68.011168, 64.812658, 19.378613)"},{"kind":"Geometry","geoshape":"BBOX (-157.928516, -68.011168, 64.812658, 19.378613)"}],"publication_information":["U.S. National Renewable Energy Laboratory (NREL)","GIS Lab, MIT Libraries"],"rights":[{"description":"Public","kind":"Access"}],"subjects":[{"value":["United States"],"kind":"Dublin Core; Spatial"},{"value":["utilitiesCommunication"],"kind":"Dublin Core; Subject"},{"value":["Fuel switching"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity point"],"kind":"Subject scheme not provided"}],"summary":["Biodiesel, CNG, electric, 85% ethanol, hydrogen, LNG, LPG/Propane stations in the United States."]},"sort":[6.2446747,1164931200000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_US_P3AMTRAK_2009","_score":5.9759994,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_P3AMTRAK_2009","timdex_record_id":"gismit:SDE_DATA_US_P3AMTRAK_2009","title":"USA (Amtrak Stations, 2009)","citation":"Federal Railroad Administration (FRA). USA (Amtrak Stations, 2009). GIS Lab, MIT Libraries. Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_P3AMTRAK_2009","content_type":["Geospatial data"],"contributors":[{"value":"Federal Railroad Administration (FRA)","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2009-03-01"},{"kind":"Coverage","value":"2009-03-01"},{"kind":"Coverage","value":"2009"}],"format":"Vector","identifiers":[{"value":"US_P3AMTRAK_2009","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_P3AMTRAK_2009.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_P3AMTRAK_2009.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_P3AMTRAK_2009.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-124.211990, -68.670621, 48.720486, 25.849848)"},{"kind":"Geometry","geoshape":"BBOX (-124.211990, -68.670621, 48.720486, 25.849848)"}],"publication_information":["GIS Lab, MIT Libraries"],"rights":[{"description":"Public","kind":"Access"},{"description":"None. Acknowledgment of the Federal Railroad Administration (FRA) should be cited in products derived from these data."}],"subjects":[{"value":["Transportation"],"kind":"DCAT; Theme"},{"value":["United States"],"kind":"Dublin Core; Spatial"},{"value":["transportation"],"kind":"Dublin Core; Subject"},{"value":["Railroads"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity point"],"kind":"Subject scheme not provided"}],"summary":["Updated database of the Federal Railroad Administration's (FRA) Amtrak Station database. This database is a geographic data set containing Amtrak intercity railroad passenger terminals in the United States and Canada. Attribute data include services and passenger amenities provided at the station."]},"sort":[5.9759994,1235865600000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_US_P3AMTRAK_2008","_score":5.9759994,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_P3AMTRAK_2008","timdex_record_id":"gismit:SDE_DATA_US_P3AMTRAK_2008","title":"USA (Amtrak Stations, 2008)","citation":"Federal Railroad Administration (FRA). USA (Amtrak Stations, 2008). U.S. Federal Railroad Administration (FRA). Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_P3AMTRAK_2008","content_type":["Geospatial data"],"contributors":[{"value":"Federal Railroad Administration (FRA)","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2008-01-01"},{"kind":"Coverage","value":"2008-01-01"},{"kind":"Coverage","value":"2008"}],"format":"Vector","identifiers":[{"value":"US_P3AMTRAK_2008","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_P3AMTRAK_2008.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_P3AMTRAK_2008.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_P3AMTRAK_2008.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-124.211990, -68.670621, 48.720486, 25.849848)"},{"kind":"Geometry","geoshape":"BBOX (-124.211990, -68.670621, 48.720486, 25.849848)"}],"publication_information":["U.S. Federal Railroad Administration (FRA)","GIS Lab, MIT Libraries"],"rights":[{"description":"Public","kind":"Access"},{"description":"None. Acknowledgment of the Federal Railroad Administration (FRA) should be cited in products derived from these data."}],"subjects":[{"value":["Transportation"],"kind":"DCAT; Theme"},{"value":["United States"],"kind":"Dublin Core; Spatial"},{"value":["transportation"],"kind":"Dublin Core; Subject"},{"value":["Railroads"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity point"],"kind":"Subject scheme not provided"}],"summary":["The Amtrak Stations database is a geographic data set containing Amtrak intercity railroad passenger terminals in the United States and Canada. Attribute data include services and passenger amenities provided at the station."]},"sort":[5.9759994,1199145600000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_US_F81FIRESTATIONS_2001","_score":5.9759994,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_F81FIRESTATIONS_2001","timdex_record_id":"gismit:SDE_DATA_US_F81FIRESTATIONS_2001","title":"USA (Fire Stations, 2001)","citation":"PBS&J, Atlanta GA, developed this database under contract to the National Institute of Building Sciences. USA (Fire Stations, 2001). U.S. Federal Emergency Management Agency (FEMA). Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_F81FIRESTATIONS_2001","content_type":["Geospatial data"],"contributors":[{"value":"PBS&J, Atlanta GA, developed this database under contract to the National Institute of Building Sciences.","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2003-01-01"},{"kind":"Coverage","value":"2001-01-01"},{"kind":"Coverage","value":"2001"}],"format":"Vector","identifiers":[{"value":"US_F81FIRESTATIONS_2001","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_F81FIRESTATIONS_2001.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_F81FIRESTATIONS_2001.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_F81FIRESTATIONS_2001.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-174.075610, -65.965860, 70.216050, 18.398820)"},{"kind":"Geometry","geoshape":"BBOX (-174.075610, -65.965860, 70.216050, 18.398820)"}],"publication_information":["U.S. Federal Emergency Management Agency (FEMA)","GIS Lab, MIT Libraries"],"rights":[{"description":"Public","kind":"Access"},{"description":"None"}],"subjects":[{"value":["Location"],"kind":"DCAT; Theme"},{"value":["United States"],"kind":"Dublin Core; Spatial"},{"value":["location"],"kind":"Dublin Core; Subject"},{"value":["Fire stations"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity point"],"kind":"Subject scheme not provided"}],"summary":["PBS&J developed this database from data already geocoded provided by InfoUSA Inc. that extracted records of Fire stations based on SIC for the entire United States. The attribute information provided by InfoUSA Inc for each Fire station facility included: name, address, city, zip, state, and geographical coordinates.The contact information for the InfoUSA, Inc is: InfoUSA, Inc. 5711 S. 86th Circle, PO Box 27347, Omaha, NE 68127-0347, (402) 930 3500. The InfoUSA, Inc website address is http://www.infousa.com/Data provided by URS Corporation was incorporated for the state of Alaska. For each item or feature provided, a note was included under the Comment field. For metadata information about this data, please contact: Laura YoungURS Corporation2700 Gambell, Suite 200Anchorage, Alaska 99503Phone - 907.261.9704Fax - 907.562.1297For metadata information on the South Carolina Data, please contact:John KnightSouth Carolina Emergency Division (SCEMD)1100 Fish Hatchery RdWest Columbia, SC 29172Phone: 803-737-8500"]},"sort":[5.9759994,1041379200000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_US_P3FXDTRANSITSTATN_2004","_score":5.2387877,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_P3FXDTRANSITSTATN_2004","timdex_record_id":"gismit:SDE_DATA_US_P3FXDTRANSITSTATN_2004","title":"USA (Fixed-Guideway Transit Stations, 2004)","citation":"Federal Transit Administration (FTA), Research and Innovative Technology Administration's Bureau of Transportation Statistics (RITA/BTS). USA (Fixed-Guideway Transit Stations, 2004). U.S. Bureau of Transportation Statistics (BTS). Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_P3FXDTRANSITSTATN_2004","content_type":["Geospatial data"],"contributors":[{"value":"Federal Transit Administration (FTA)","kind":"Creator"},{"value":"Research and Innovative Technology Administration's Bureau of Transportation Statistics (RITA/BTS)","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2008-01-01"},{"kind":"Coverage","value":"2004-01-01"},{"kind":"Coverage","value":"2004"}],"format":"Vector","identifiers":[{"value":"US_P3FXDTRANSITSTATN_2004","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_P3FXDTRANSITSTATN_2004.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_P3FXDTRANSITSTATN_2004.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_P3FXDTRANSITSTATN_2004.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-122.991273, -70.626380, 47.974800, 25.680243)"},{"kind":"Geometry","geoshape":"BBOX (-122.991273, -70.626380, 47.974800, 25.680243)"}],"publication_information":["U.S. Bureau of Transportation Statistics (BTS)","GIS Lab, MIT Libraries"],"rights":[{"description":"Public","kind":"Access"},{"description":"Acknowledgment of the Research and Innovative Technology Administration's Bureau of Transportation Statistics (RITA/BTS) National Transportation Atlas Databases (NTAD) 2008 would be appreciated in products derived from these data."}],"subjects":[{"value":["Transportation"],"kind":"DCAT; Theme"},{"value":["United States"],"kind":"Dublin Core; Spatial"},{"value":["Transportation"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["Entity point"],"kind":"Subject scheme not provided"}],"summary":["Version 2004 of the Fixed-Guideway Transit Network is a network database of the nation's fixed-guideway transit systems. The data set covers systems in cities defined as FTA's universe of cities and includes heavy rail, light rail, monorail, cable car, inclined plane, and automated guideway."]},"sort":[5.2387877,1199145600000]},{"_index":"gismit-2024-02-02t11-36-57","_id":"gismit:SDE_DATA_US_E25DMA_2000","_score":5.23612,"_source":{"source":"MIT GIS Resources","source_link":"https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_E25DMA_2000","timdex_record_id":"gismit:SDE_DATA_US_E25DMA_2000","title":"USA (Designated Market Areas, 2000)","citation":"Geographic Data Technology, Inc. (GDT), Environmental Systems Research Institute, Inc. (ESRI). USA (Designated Market Areas, 2000). Environmental Systems Research Institute (ESRI). Geospatial data. https://search.libraries.mit.edu/record/gismit:SDE_DATA_US_E25DMA_2000","content_type":["Geospatial data"],"contributors":[{"value":"Geographic Data Technology, Inc. (GDT)","kind":"Creator"},{"value":"Environmental Systems Research Institute, Inc. (ESRI)","kind":"Creator"}],"dates":[{"kind":"Issued","value":"2000-11-01"},{"kind":"Coverage","value":"1999-01-01"},{"kind":"Coverage","value":"1999"}],"format":"Vector","identifiers":[{"value":"SDE_DATA.US_E25DMA_2000","kind":"Not specified"},{"value":"US_E25DMA_2000","kind":"Not specified"}],"languages":["eng"],"links":[{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_E25DMA_2000.source.fgdc.xml","kind":"Download","text":"Source Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/public/SDE_DATA_US_E25DMA_2000.normalized.aardvark.json","kind":"Download","text":"Normalized Metadata"},{"url":"https://cdn.dev1.mitlibrary.net/geo/restricted/SDE_DATA_US_E25DMA_2000.zip","kind":"Download","text":"Data Zipfile"}],"locations":[{"kind":"Bounding Box","geoshape":"BBOX (-160.246909, -66.951007, 65.445013, 18.911160)"},{"kind":"Geometry","geoshape":"BBOX (-160.246909, -66.951007, 65.445013, 18.911160)"}],"publication_information":["Environmental Systems Research Institute (ESRI)","GIS Lab, MIT Libraries"],"rights":[{"description":"Restricted","kind":"Access"}],"subjects":[{"value":["Boundaries"],"kind":"DCAT; Theme"},{"value":["United States"],"kind":"Dublin Core; Spatial"},{"value":["boundaries"],"kind":"Dublin Core; Subject"},{"value":["Administrative and political divisions"],"kind":"Dublin Core; Subject"},{"value":["Datasets"],"kind":"Subject scheme not provided"},{"value":["G-polygon"],"kind":"Subject scheme not provided"}],"summary":["A U.S. Designated Market Area (DMA) is generally the group of surrounding counties or split counties (by five-digit ZIP) in which metropolitan central area commercial TV stations achieve the largest audience share."]},"sort":[5.23612,973036800000]}]},"aggregations":{"languages":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[{"key":"eng","doc_count":38}]},"content_type":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[{"key":"geospatial data","doc_count":38}]},"subjects":{"doc_count":533,"subject_names":{"doc_count_error_upper_bound":0,"sum_other_doc_count":348,"buckets":[{"key":"transportation","doc_count":40},{"key":"datasets","doc_count":38},{"key":"entity point","doc_count":23},{"key":"structure","doc_count":20},{"key":"united states","doc_count":15},{"key":"railroads","doc_count":14},{"key":"string","doc_count":10},{"key":"massachusetts bay transportation authority","doc_count":9},{"key":"location","doc_count":8},{"key":"massachusetts","doc_count":8}]}},"content_format":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[{"key":"vector","doc_count":38}]},"literary_form":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[]},"source":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[{"key":"mit gis resources","doc_count":38}]},"contributors":{"doc_count":46,"contributor_names":{"doc_count_error_upper_bound":0,"sum_other_doc_count":12,"buckets":[{"key":"massgis (office : mass.)","doc_count":10},{"key":"city of cambridge gis","doc_count":4},{"key":"massachusetts--brookline (town)","doc_count":4},{"key":"environmental systems research institute (redlands, calif.)","doc_count":3},{"key":"platts","doc_count":3},{"key":"environmental systems research institute, inc. (esri)","doc_count":2},{"key":"esri","doc_count":2},{"key":"federal railroad administration (fra)","doc_count":2},{"key":"geographic data technology, inc. (gdt)","doc_count":2},{"key":"tele atlas north america, inc.","doc_count":2}]}}}} + recorded_at: Wed, 14 Feb 2024 16:44:24 GMT +recorded_with: VCR 6.2.0 From 1ed5cbc2da135f5516b75627732903b46f5b9ed8 Mon Sep 17 00:00:00 2001 From: Matthew Bernhardt Date: Thu, 15 Feb 2024 10:01:48 -0500 Subject: [PATCH 2/2] Respond to code review feedback --- test/controllers/graphql_controller_v2_test.rb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/controllers/graphql_controller_v2_test.rb b/test/controllers/graphql_controller_v2_test.rb index 585a45bd..ae963252 100644 --- a/test/controllers/graphql_controller_v2_test.rb +++ b/test/controllers/graphql_controller_v2_test.rb @@ -399,7 +399,7 @@ def setup end test 'graphqlv2 geobox search with geodistance search' do - # Should this work? It does. + # This is not a recommended way to work, but it does function. VCR.use_cassette('graphqlv2 geobox with geodistance') do post '/graphql', params: { query: '{ search(