From 3b145bcc91a3b93fc4f4628cc876a41fde3eecd2 Mon Sep 17 00:00:00 2001 From: Michael King Date: Mon, 29 Oct 2018 19:19:05 -0400 Subject: [PATCH 01/11] add test for upcoming launches --- spec/spacex/launches_spec.rb | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/spec/spacex/launches_spec.rb b/spec/spacex/launches_spec.rb index dad65d0..57b7f53 100644 --- a/spec/spacex/launches_spec.rb +++ b/spec/spacex/launches_spec.rb @@ -393,6 +393,27 @@ end end + context '#upcoming', vcr: { cassette_name: 'launches/upcoming' } do + subject do + SPACEX::Launches.upcoming + end + + it 'returns and array of upcoming launch hashes' do + expect(subject).to be_an Array + expect(subject.first).to be_a Hash + expect(subject.all?(&:upcoming)).to be true + end + + it 'returns launches scheduled in the future' do + subject.each do |launch| + expect(launch.launch_year).to be >= Time.now.year.to_s + expect(Time.parse(launch.launch_date_utc)).to be >= Time.now.utc + expect(launch.rocket.first_stage.cores.first.land_success).to be nil + expect(launch.launch_success).to be nil + end + end + end + context '#all', vcr: { cassette_name: 'launches/all' } do subject do SPACEX::Launches.all From d513058970f71211984b71fb38ff7f5d48bb206f Mon Sep 17 00:00:00 2001 From: Michael King Date: Mon, 29 Oct 2018 19:19:29 -0400 Subject: [PATCH 02/11] implement upcoming launches endpoint --- lib/spacex/launches.rb | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/lib/spacex/launches.rb b/lib/spacex/launches.rb index bd656af..6bab291 100644 --- a/lib/spacex/launches.rb +++ b/lib/spacex/launches.rb @@ -16,6 +16,10 @@ def self.past SPACEX::BaseRequest.info('launches/past') end + def self.upcoming + SPACEX::BaseRequest.info('launches/upcoming') + end + def self.all info end From fcb52b0738b13822c9532b90f816b331b9d7ae9d Mon Sep 17 00:00:00 2001 From: Michael King Date: Mon, 29 Oct 2018 19:20:10 -0400 Subject: [PATCH 03/11] add upcoming launches cassette --- spec/fixtures/spacex/launches/upcoming.yml | 64 ++++++++++++++++++++++ 1 file changed, 64 insertions(+) create mode 100644 spec/fixtures/spacex/launches/upcoming.yml diff --git a/spec/fixtures/spacex/launches/upcoming.yml b/spec/fixtures/spacex/launches/upcoming.yml new file mode 100644 index 0000000..153486e --- /dev/null +++ b/spec/fixtures/spacex/launches/upcoming.yml @@ -0,0 +1,64 @@ +--- +http_interactions: +- request: + method: get + uri: https://api.spacexdata.com/v3/launches/upcoming + body: + encoding: US-ASCII + string: '' + headers: + User-Agent: + - Faraday v0.15.3 + Accept-Encoding: + - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 + Accept: + - "*/*" + response: + status: + code: 200 + message: OK + headers: + Date: + - Mon, 29 Oct 2018 22:59:11 GMT + Content-Type: + - application/json; charset=utf-8 + Transfer-Encoding: + - chunked + Connection: + - keep-alive + Set-Cookie: + - __cfduid=dc63256bab7f88c06c55be07971c3b9cc1540853951; expires=Tue, 29-Oct-19 + 22:59:11 GMT; path=/; domain=.spacexdata.com; HttpOnly; Secure + Vary: + - Accept-Encoding, Origin + X-Dns-Prefetch-Control: + - 'off' + X-Frame-Options: + - SAMEORIGIN + Strict-Transport-Security: + - max-age=15552000; includeSubDomains + X-Download-Options: + - noopen + X-Content-Type-Options: + - nosniff + X-Xss-Protection: + - 1; mode=block + Access-Control-Allow-Origin: + - "*" + X-Koa-Redis-Cache: + - 'true' + X-Response-Time: + - 2ms + Expect-Ct: + - max-age=604800, report-uri="https://report-uri.cloudflare.com/cdn-cgi/beacon/expect-ct" + Server: + - cloudflare + Cf-Ray: + - 4719404aacf55e58-TPA + body: + encoding: ASCII-8BIT + string: !binary |- + [{"flight_number":70,"mission_name":"Es’hail 2","mission_id":[],"launch_year":"2018","launch_date_unix":1542228360,"launch_date_utc":"2018-11-14T20:46:00.000Z","launch_date_local":"2018-11-14T15:46:00-05:00","is_tentative":true,"tentative_max_precision":"hour","rocket":{"rocket_id":"falcon9","rocket_name":"Falcon 9","rocket_type":"FT","first_stage":{"cores":[{"core_serial":null,"flight":null,"block":5,"gridfins":true,"legs":true,"reused":false,"land_success":null,"landing_intent":true,"landing_type":"ASDS","landing_vehicle":"OCISLY"}]},"second_stage":{"block":5,"payloads":[{"payload_id":"Es’hail 2","norad_id":[],"reused":false,"customers":["Es’hailSat"],"nationality":"Qatar","manufacturer":"Mitsubishi Electric","payload_type":"Satellite","payload_mass_kg":3000,"payload_mass_lbs":6613.868,"orbit":"GTO","orbit_params":{"reference_system":"geocentric","regime":"geostationary","longitude":25.5,"semi_major_axis_km":null,"eccentricity":null,"periapsis_km":null,"apoapsis_km":null,"inclination_deg":null,"period_min":null,"lifespan_years":15,"epoch":null,"mean_motion":null,"raan":null,"arg_of_pericenter":null,"mean_anomaly":null}}]},"fairings":{"reused":false,"recovery_attempt":false,"recovered":false,"ship":null}},"ships":[],"telemetry":{"flight_club":null},"launch_site":{"site_id":"ccafs_slc_40","site_name":"CCAFS SLC 40","site_name_long":"Cape Canaveral Air Force Station Space Launch Complex 40"},"launch_success":null,"links":{"mission_patch":null,"mission_patch_small":null,"reddit_campaign":"https://www.reddit.com/r/spacex/comments/9p82jt/eshail_2_launch_campaign_thread/","reddit_launch":null,"reddit_recovery":null,"reddit_media":null,"presskit":null,"article_link":null,"wikipedia":null,"video_link":null,"flickr_images":[]},"details":"SpaceX's eighteenth flight of 2018 will be its first for Es'hailSat. Es'hail-2 is a communications satellite that will deliver television and internet to Qatar and the surrounding region. It will be launched into a geostationary transfer orbit from LC-39A at Kennedy Space Center. The booster is expected to land on OCISLY.","upcoming":true,"static_fire_date_utc":null,"static_fire_date_unix":null},{"flight_number":71,"mission_name":"SSO-A","mission_id":[],"launch_year":"2018","launch_date_unix":1542652200,"launch_date_utc":"2018-11-19T18:30:00.000Z","launch_date_local":"2018-11-19T10:30:00-08:00","is_tentative":true,"tentative_max_precision":"hour","rocket":{"rocket_id":"falcon9","rocket_name":"Falcon 9","rocket_type":"FT","first_stage":{"cores":[{"core_serial":"B1046","flight":3,"block":5,"gridfins":true,"legs":true,"reused":true,"land_success":null,"landing_intent":true,"landing_type":"RTLS","landing_vehicle":"LZ-4"}]},"second_stage":{"block":5,"payloads":[{"payload_id":"SSO-A","norad_id":[],"reused":false,"customers":["Spaceflight Industries, Inc"],"nationality":"United States","manufacturer":"Spaceflight Industries, Inc","payload_type":"Satellite","payload_mass_kg":4000,"payload_mass_lbs":8818.49,"orbit":"SSO","orbit_params":{"reference_system":"geocentric","regime":"sun-synchronous","longitude":null,"semi_major_axis_km":null,"eccentricity":null,"periapsis_km":null,"apoapsis_km":null,"inclination_deg":null,"period_min":null,"lifespan_years":null,"epoch":null,"mean_motion":null,"raan":null,"arg_of_pericenter":null,"mean_anomaly":null}}]},"fairings":{"reused":false,"recovery_attempt":null,"recovered":null,"ship":null}},"ships":[],"telemetry":{"flight_club":null},"launch_site":{"site_id":"vafb_slc_4e","site_name":"VAFB SLC 4E","site_name_long":"Vandenberg Air Force Base Space Launch Complex 4E"},"launch_success":null,"links":{"mission_patch":null,"mission_patch_small":null,"reddit_campaign":"https://www.reddit.com/r/spacex/comments/9raysi/ssoa_launch_campaign_thread","reddit_launch":null,"reddit_recovery":null,"reddit_media":null,"presskit":null,"article_link":null,"wikipedia":null,"video_link":null,"flickr_images":[]},"details":"SpaceX's nineteenth flight of 2018 will fly SSO-A: SmallSat Express out of Vandenberg SLC-4E for Spaceflight. SSO-A is a rideshare to sun synchronus low earth orbit consisting of 74 individual microsatellites and cubesats. It is also likely to be the third flight of core B1046 which previously flew Bangabandhu-1 and Merah Putih. If this happens it will be the first time a Falcon 9 has flown more than two missions. This is expected to be a RTLS landing.","upcoming":true,"static_fire_date_utc":null,"static_fire_date_unix":null},{"flight_number":72,"mission_name":"CRS-16","mission_id":["EE86F74"],"launch_year":"2018","launch_date_unix":1543622400,"launch_date_utc":"2018-12-01T00:00:00.000Z","launch_date_local":"2018-11-30T19:00:00-05:00","is_tentative":true,"tentative_max_precision":"month","rocket":{"rocket_id":"falcon9","rocket_name":"Falcon 9","rocket_type":"FT","first_stage":{"cores":[{"core_serial":null,"flight":null,"block":5,"gridfins":true,"legs":true,"reused":false,"land_success":null,"landing_intent":null,"landing_type":null,"landing_vehicle":null}]},"second_stage":{"block":5,"payloads":[{"payload_id":"CRS-16","norad_id":[],"cap_serial":null,"reused":true,"customers":["NASA (CRS)"],"nationality":"United States","manufacturer":"SpaceX","payload_type":"Dragon 1.1","payload_mass_kg":null,"payload_mass_lbs":null,"orbit":"ISS","orbit_params":{"reference_system":"geocentric","regime":"low-earth","longitude":null,"semi_major_axis_km":null,"eccentricity":null,"periapsis_km":null,"apoapsis_km":null,"inclination_deg":null,"period_min":null,"lifespan_years":null,"epoch":null,"mean_motion":null,"raan":null,"arg_of_pericenter":null,"mean_anomaly":null},"mass_returned_kg":null,"mass_returned_lbs":null,"flight_time_sec":null,"cargo_manifest":null}]},"fairings":null},"ships":[],"telemetry":{"flight_club":null},"launch_site":{"site_id":"ccafs_slc_40","site_name":"CCAFS SLC 40","site_name_long":"Cape Canaveral Air Force Station Space Launch Complex 40"},"launch_success":null,"links":{"mission_patch":null,"mission_patch_small":null,"reddit_campaign":null,"reddit_launch":null,"reddit_recovery":null,"reddit_media":null,"presskit":null,"article_link":null,"wikipedia":null,"video_link":null,"flickr_images":[]},"details":"SpaceX's 16th Crew Resupply Mission on behalf of NASA, with a total of 20 contracted flights. This will bring essential supplies to the International Space Station using SpaceX's reusable Dragon spacecraft. The Falcon 9 will launch from SLC-40 at Cape Canaveral Air Force Station. This launch could be affected by the recent Soyuz failure. ","upcoming":true,"static_fire_date_utc":null,"static_fire_date_unix":null},{"flight_number":73,"mission_name":"GPS IIIA-1","mission_id":[],"launch_year":"2018","launch_date_unix":1544882880,"launch_date_utc":"2018-12-15T14:08:00.000Z","launch_date_local":"2018-12-15T09:08:00-05:00","is_tentative":true,"tentative_max_precision":"hour","rocket":{"rocket_id":"falcon9","rocket_name":"Falcon 9","rocket_type":"FT","first_stage":{"cores":[{"core_serial":"B1050","flight":1,"block":5,"gridfins":true,"legs":true,"reused":false,"land_success":null,"landing_intent":null,"landing_type":null,"landing_vehicle":null}]},"second_stage":{"block":5,"payloads":[{"payload_id":"GPS IIIA-1","norad_id":[],"reused":false,"customers":["USAF"],"nationality":"United States","manufacturer":"Lockheed Martin","payload_type":"Satellite","payload_mass_kg":3880,"payload_mass_lbs":8553.94,"orbit":"MEO","orbit_params":{"reference_system":null,"regime":null,"longitude":null,"semi_major_axis_km":null,"eccentricity":null,"periapsis_km":null,"apoapsis_km":null,"inclination_deg":null,"period_min":null,"lifespan_years":15,"epoch":null,"mean_motion":null,"raan":null,"arg_of_pericenter":null,"mean_anomaly":null}}]},"fairings":{"reused":false,"recovery_attempt":false,"recovered":false,"ship":null}},"ships":[],"telemetry":{"flight_club":null},"launch_site":{"site_id":"ccafs_slc_40","site_name":"CCAFS SLC 40","site_name_long":"Cape Canaveral Air Force Station Space Launch Complex 40"},"launch_success":null,"links":{"mission_patch":null,"mission_patch_small":null,"reddit_campaign":null,"reddit_launch":null,"reddit_recovery":null,"reddit_media":null,"presskit":null,"article_link":null,"wikipedia":null,"video_link":null,"flickr_images":[]},"details":null,"upcoming":true,"static_fire_date_utc":null,"static_fire_date_unix":null},{"flight_number":74,"mission_name":"Iridium NEXT Mission 8","mission_id":["F3364BF"],"launch_year":"2018","launch_date_unix":1546187880,"launch_date_utc":"2018-12-30T16:38:00.000Z","launch_date_local":"2018-12-30T08:38:00-08:00","is_tentative":true,"tentative_max_precision":"hour","rocket":{"rocket_id":"falcon9","rocket_name":"Falcon 9","rocket_type":"FT","first_stage":{"cores":[{"core_serial":null,"flight":null,"block":5,"gridfins":true,"legs":true,"reused":null,"land_success":null,"landing_intent":null,"landing_type":null,"landing_vehicle":null}]},"second_stage":{"block":5,"payloads":[{"payload_id":"Iridium NEXT 8","norad_id":[],"reused":false,"customers":["Iridium Communications"],"nationality":"United States","manufacturer":"Thales Alenia Space","payload_type":"Satellite","payload_mass_kg":9600,"payload_mass_lbs":21164.38,"orbit":"PO","orbit_params":{"reference_system":"geocentric","regime":"low-earth","longitude":null,"semi_major_axis_km":6994.843,"eccentricity":0.001022,"periapsis_km":609.559,"apoapsis_km":623.856,"inclination_deg":86.6763,"period_min":97.034,"lifespan_years":15,"epoch":"2018-07-25T19:08:38.000Z","mean_motion":14.840065,"raan":181.7071,"arg_of_pericenter":null,"mean_anomaly":null}}]},"fairings":{"reused":false,"recovery_attempt":null,"recovered":null,"ship":null}},"ships":[],"telemetry":{"flight_club":null},"launch_site":{"site_id":"vafb_slc_4e","site_name":"VAFB SLC 4E","site_name_long":"Vandenberg Air Force Base Space Launch Complex 4E"},"launch_success":null,"links":{"mission_patch":null,"mission_patch_small":null,"reddit_campaign":null,"reddit_launch":null,"reddit_recovery":null,"reddit_media":null,"presskit":null,"article_link":null,"wikipedia":null,"video_link":null,"flickr_images":[]},"details":null,"upcoming":true,"static_fire_date_utc":null,"static_fire_date_unix":null},{"flight_number":75,"mission_name":"CCtCap Demo Mission 1","mission_id":["EE86F74"],"launch_year":"2019","launch_date_unix":1546300800,"launch_date_utc":"2019-01-01T00:00:00.000Z","launch_date_local":"2018-12-31T19:00:00-05:00","is_tentative":true,"tentative_max_precision":"month","rocket":{"rocket_id":"falcon9","rocket_name":"Falcon 9","rocket_type":"FT","first_stage":{"cores":[{"core_serial":"B1051","flight":1,"block":5,"gridfins":null,"legs":null,"reused":false,"land_success":null,"landing_intent":null,"landing_type":null,"landing_vehicle":null}]},"second_stage":{"block":5,"payloads":[{"payload_id":"CCtCap Demo Mission 1","norad_id":[],"cap_serial":null,"reused":false,"customers":["NASA (CCtCap)"],"nationality":"United States","manufacturer":"SpaceX","payload_type":"Crew Dragon","payload_mass_kg":null,"payload_mass_lbs":null,"orbit":"ISS","orbit_params":{"reference_system":"geocentric","regime":"low-earth","longitude":null,"semi_major_axis_km":null,"eccentricity":null,"periapsis_km":null,"apoapsis_km":null,"inclination_deg":null,"period_min":null,"lifespan_years":null,"epoch":null,"mean_motion":null,"raan":null,"arg_of_pericenter":null,"mean_anomaly":null},"mass_returned_kg":null,"mass_returned_lbs":null,"flight_time_sec":null,"cargo_manifest":null}]},"fairings":null},"ships":[],"telemetry":{"flight_club":null},"launch_site":{"site_id":"ksc_lc_39a","site_name":"KSC LC 39A","site_name_long":"Kennedy Space Center Historic Launch Complex 39A"},"launch_success":null,"links":{"mission_patch":null,"mission_patch_small":null,"reddit_campaign":null,"reddit_launch":null,"reddit_recovery":null,"reddit_media":null,"presskit":null,"article_link":null,"wikipedia":null,"video_link":null,"flickr_images":[]},"details":"Demonstration mission to ISS for NASA with an uncrewed Dragon 2 capsule.","upcoming":true,"static_fire_date_utc":"2018-11-01T00:00:00.000Z","static_fire_date_unix":1541030400},{"flight_number":76,"mission_name":"PSN-6 / GTO-1 / SpaceIL Moon Lander","mission_id":[],"launch_year":"2019","launch_date_unix":1546300800,"launch_date_utc":"2019-01-01T00:00:00.000Z","launch_date_local":"2018-12-31T19:00:00-05:00","is_tentative":true,"tentative_max_precision":"month","rocket":{"rocket_id":"falcon9","rocket_name":"Falcon 9","rocket_type":"FT","first_stage":{"cores":[{"core_serial":null,"flight":null,"block":5,"gridfins":null,"legs":null,"reused":false,"land_success":null,"landing_intent":null,"landing_type":null,"landing_vehicle":null}]},"second_stage":{"block":5,"payloads":[{"payload_id":"PSN-6","norad_id":[],"reused":false,"customers":["Pasifik Satelit Nusantara"],"nationality":"Indonesia","manufacturer":"SSL","payload_type":"Satellite","payload_mass_kg":5000,"payload_mass_lbs":11023.11,"orbit":"GTO","orbit_params":{"reference_system":null,"regime":null,"longitude":null,"semi_major_axis_km":null,"eccentricity":null,"periapsis_km":null,"apoapsis_km":null,"inclination_deg":null,"period_min":null,"lifespan_years":15,"epoch":null,"mean_motion":null,"raan":null,"arg_of_pericenter":null,"mean_anomaly":null}},{"payload_id":"GTO-1","norad_id":[],"reused":false,"customers":["Spaceflight Industries, Inc"],"nationality":"United States","manufacturer":null,"payload_type":null,"payload_mass_kg":null,"payload_mass_lbs":null,"orbit":"GTO","orbit_params":{"reference_system":"geocentric","regime":"geostationary","longitude":null,"semi_major_axis_km":null,"eccentricity":null,"periapsis_km":null,"apoapsis_km":null,"inclination_deg":null,"period_min":null,"lifespan_years":null,"epoch":null,"mean_motion":null,"raan":null,"arg_of_pericenter":null,"mean_anomaly":null}},{"payload_id":"SpaceIL Moon Lander","norad_id":[],"reused":false,"customers":["SpaceIL"],"nationality":"Israel","manufacturer":"SSL","payload_type":"Lander","payload_mass_kg":585,"payload_mass_lbs":1289.7,"orbit":"GTO","orbit_params":{"reference_system":null,"regime":null,"longitude":null,"semi_major_axis_km":null,"eccentricity":null,"periapsis_km":null,"apoapsis_km":null,"inclination_deg":null,"period_min":null,"lifespan_years":0.00547945,"epoch":null,"mean_motion":null,"raan":null,"arg_of_pericenter":null,"mean_anomaly":null}}]},"fairings":{"reused":false,"recovery_attempt":false,"recovered":false,"ship":null}},"ships":[],"telemetry":{"flight_club":null},"launch_site":{"site_id":"ccafs_slc_40","site_name":"CCAFS SLC 40","site_name_long":"Cape Canaveral Air Force Station Space Launch Complex 40"},"launch_success":null,"links":{"mission_patch":null,"mission_patch_small":null,"reddit_campaign":null,"reddit_launch":null,"reddit_recovery":null,"reddit_media":null,"presskit":null,"article_link":null,"wikipedia":null,"video_link":null,"flickr_images":[]},"details":null,"upcoming":true,"static_fire_date_utc":null,"static_fire_date_unix":null},{"flight_number":77,"mission_name":"ArabSat 6A","mission_id":[],"launch_year":"2019","launch_date_unix":1546300800,"launch_date_utc":"2019-01-01T00:00:00.000Z","launch_date_local":"2018-12-31T19:00:00-05:00","is_tentative":true,"tentative_max_precision":"month","rocket":{"rocket_id":"falconheavy","rocket_name":"Falcon Heavy","rocket_type":"FT","first_stage":{"cores":[{"core_serial":null,"flight":null,"block":null,"gridfins":null,"legs":null,"reused":null,"land_success":null,"landing_intent":null,"landing_type":null,"landing_vehicle":null},{"core_serial":null,"flight":null,"block":null,"gridfins":null,"legs":null,"reused":null,"land_success":null,"landing_intent":null,"landing_type":null,"landing_vehicle":null},{"core_serial":null,"flight":null,"block":null,"gridfins":null,"legs":null,"reused":null,"land_success":null,"landing_intent":null,"landing_type":null,"landing_vehicle":null}]},"second_stage":{"block":null,"payloads":[{"payload_id":"ArabSat 6A","norad_id":[],"reused":false,"customers":["Arabsat"],"nationality":"Saudi Arabia","manufacturer":"Lockheed Martin","payload_type":"Satellite","payload_mass_kg":6000,"payload_mass_lbs":13227.74,"orbit":"GTO","orbit_params":{"reference_system":"geocentric","regime":"geostationary","longitude":30.5,"semi_major_axis_km":null,"eccentricity":null,"periapsis_km":null,"apoapsis_km":null,"inclination_deg":null,"period_min":null,"lifespan_years":15,"epoch":null,"mean_motion":null,"raan":null,"arg_of_pericenter":null,"mean_anomaly":null}}]},"fairings":null},"ships":[],"telemetry":{"flight_club":null},"launch_site":{"site_id":"ksc_lc_39a","site_name":"KSC LC 39A","site_name_long":"Kennedy Space Center Historic Launch Complex 39A"},"launch_success":null,"links":{"mission_patch":null,"mission_patch_small":null,"reddit_campaign":null,"reddit_launch":null,"reddit_recovery":null,"reddit_media":null,"presskit":null,"article_link":null,"wikipedia":null,"video_link":null,"flickr_images":[]},"details":null,"upcoming":true,"static_fire_date_utc":null,"static_fire_date_unix":null},{"flight_number":78,"mission_name":"CRS-17","mission_id":["EE86F74"],"launch_year":"2019","launch_date_unix":1550361600,"launch_date_utc":"2019-02-17T00:00:00.000Z","launch_date_local":"2019-02-16T19:00:00-05:00","is_tentative":true,"tentative_max_precision":"day","rocket":{"rocket_id":"falcon9","rocket_name":"Falcon 9","rocket_type":"FT","first_stage":{"cores":[{"core_serial":null,"flight":null,"block":null,"gridfins":null,"legs":null,"reused":true,"land_success":null,"landing_intent":null,"landing_type":null,"landing_vehicle":null}]},"second_stage":{"block":null,"payloads":[{"payload_id":"CRS-17","norad_id":[],"cap_serial":null,"reused":true,"customers":["NASA (CRS)"],"nationality":"United States","manufacturer":"SpaceX","payload_type":"Dragon 1.1","payload_mass_kg":null,"payload_mass_lbs":null,"orbit":"ISS","orbit_params":{"reference_system":"geocentric","regime":"low-earth","longitude":null,"semi_major_axis_km":null,"eccentricity":null,"periapsis_km":null,"apoapsis_km":null,"inclination_deg":null,"period_min":null,"lifespan_years":null,"epoch":null,"mean_motion":null,"raan":null,"arg_of_pericenter":null,"mean_anomaly":null},"mass_returned_kg":null,"mass_returned_lbs":null,"flight_time_sec":null,"cargo_manifest":null}]},"fairings":{"reused":false,"recovery_attempt":null,"recovered":null,"ship":null}},"ships":[],"telemetry":{"flight_club":null},"launch_site":{"site_id":"ccafs_slc_40","site_name":"CCAFS SLC 40","site_name_long":"Cape Canaveral Air Force Station Space Launch Complex 40"},"launch_success":null,"links":{"mission_patch":null,"mission_patch_small":null,"reddit_campaign":null,"reddit_launch":null,"reddit_recovery":null,"reddit_media":null,"presskit":null,"article_link":null,"wikipedia":null,"video_link":null,"flickr_images":[]},"details":null,"upcoming":true,"static_fire_date_utc":null,"static_fire_date_unix":null},{"flight_number":79,"mission_name":"RADARSAT C-1, C-2, C-3","mission_id":[],"launch_year":"2019","launch_date_unix":1550448000,"launch_date_utc":"2019-02-18T00:00:00.000Z","launch_date_local":"2019-02-17T16:00:00-08:00","is_tentative":true,"tentative_max_precision":"day","rocket":{"rocket_id":"falcon9","rocket_name":"Falcon 9","rocket_type":"FT","first_stage":{"cores":[{"core_serial":null,"flight":null,"block":null,"gridfins":null,"legs":null,"reused":true,"land_success":null,"landing_intent":null,"landing_type":null,"landing_vehicle":null}]},"second_stage":{"block":null,"payloads":[{"payload_id":"RADARSAT C-1, C-2, C-3","norad_id":[],"reused":false,"customers":["CSA"],"nationality":"Canada","manufacturer":"Maxar Technologies","payload_type":"Satellite","payload_mass_kg":1425,"payload_mass_lbs":3141.59,"orbit":"SSO","orbit_params":{"reference_system":"geocentric","regime":"sun-synchronous","longitude":null,"semi_major_axis_km":null,"eccentricity":null,"periapsis_km":null,"apoapsis_km":null,"inclination_deg":null,"period_min":null,"lifespan_years":null,"epoch":null,"mean_motion":null,"raan":null,"arg_of_pericenter":null,"mean_anomaly":null}}]},"fairings":{"reused":false,"recovery_attempt":null,"recovered":null,"ship":null}},"ships":[],"telemetry":{"flight_club":null},"launch_site":{"site_id":"vafb_slc_4e","site_name":"VAFB SLC 4E","site_name_long":"Vandenberg Air Force Base Space Launch Complex 4E"},"launch_success":null,"links":{"mission_patch":null,"mission_patch_small":null,"reddit_campaign":null,"reddit_launch":null,"reddit_recovery":null,"reddit_media":null,"presskit":null,"article_link":null,"wikipedia":null,"video_link":null,"flickr_images":[]},"details":null,"upcoming":true,"static_fire_date_utc":null,"static_fire_date_unix":null},{"flight_number":80,"mission_name":"STP-2","mission_id":[],"launch_year":"2019","launch_date_unix":1551398400,"launch_date_utc":"2019-03-01T00:00:00.000Z","launch_date_local":"2019-02-28T19:00:00-05:00","is_tentative":true,"tentative_max_precision":"month","rocket":{"rocket_id":"falconheavy","rocket_name":"Falcon Heavy","rocket_type":"FT","first_stage":{"cores":[{"core_serial":null,"flight":null,"block":null,"gridfins":null,"legs":null,"reused":null,"land_success":null,"landing_intent":null,"landing_type":null,"landing_vehicle":null},{"core_serial":null,"flight":null,"block":null,"gridfins":null,"legs":null,"reused":null,"land_success":null,"landing_intent":null,"landing_type":null,"landing_vehicle":null},{"core_serial":null,"flight":null,"block":null,"gridfins":null,"legs":null,"reused":null,"land_success":null,"landing_intent":null,"landing_type":null,"landing_vehicle":null}]},"second_stage":{"block":null,"payloads":[{"payload_id":"STP-2","norad_id":[],"reused":false,"customers":["USAF"],"nationality":"United States","manufacturer":null,"payload_type":"Satellite","payload_mass_kg":null,"payload_mass_lbs":null,"orbit":"GTO","orbit_params":{"reference_system":"geocentric","regime":"low-earth","longitude":null,"semi_major_axis_km":null,"eccentricity":null,"periapsis_km":null,"apoapsis_km":null,"inclination_deg":null,"period_min":null,"lifespan_years":null,"epoch":null,"mean_motion":null,"raan":null,"arg_of_pericenter":null,"mean_anomaly":null}}]},"fairings":null},"ships":[],"telemetry":{"flight_club":null},"launch_site":{"site_id":"ksc_lc_39a","site_name":"KSC LC 39A","site_name_long":"Kennedy Space Center Historic Launch Complex 39A"},"launch_success":null,"links":{"mission_patch":null,"mission_patch_small":null,"reddit_campaign":null,"reddit_launch":null,"reddit_recovery":null,"reddit_media":null,"presskit":null,"article_link":null,"wikipedia":null,"video_link":null,"flickr_images":[]},"details":null,"upcoming":true,"static_fire_date_utc":null,"static_fire_date_unix":null},{"flight_number":81,"mission_name":"SARah 1","mission_id":[],"launch_year":"2019","launch_date_unix":1546300800,"launch_date_utc":"2019-01-01T00:00:00.000Z","launch_date_local":"2018-12-31T16:00:00-08:00","is_tentative":true,"tentative_max_precision":"quarter","rocket":{"rocket_id":"falcon9","rocket_name":"Falcon 9","rocket_type":"FT","first_stage":{"cores":[{"core_serial":null,"flight":null,"block":null,"gridfins":null,"legs":null,"reused":null,"land_success":null,"landing_intent":null,"landing_type":null,"landing_vehicle":null}]},"second_stage":{"block":null,"payloads":[{"payload_id":"SARah 1","norad_id":[],"reused":false,"customers":["OHB-System AG "],"nationality":"Germany","manufacturer":null,"payload_type":"Satellite","payload_mass_kg":2200,"payload_mass_lbs":4850.17,"orbit":"SSO","orbit_params":{"reference_system":"geocentric","regime":"sun-synchronous","longitude":null,"semi_major_axis_km":null,"eccentricity":null,"periapsis_km":null,"apoapsis_km":null,"inclination_deg":null,"period_min":null,"lifespan_years":null,"epoch":null,"mean_motion":null,"raan":null,"arg_of_pericenter":null,"mean_anomaly":null}}]},"fairings":{"reused":false,"recovery_attempt":null,"recovered":null,"ship":null}},"ships":[],"telemetry":{"flight_club":null},"launch_site":{"site_id":"vafb_slc_4e","site_name":"VAFB SLC 4E","site_name_long":"Vandenberg Air Force Base Space Launch Complex 4E"},"launch_success":null,"links":{"mission_patch":null,"mission_patch_small":null,"reddit_campaign":null,"reddit_launch":null,"reddit_recovery":null,"reddit_media":null,"presskit":null,"article_link":null,"wikipedia":null,"video_link":null,"flickr_images":[]},"details":null,"upcoming":true,"static_fire_date_utc":null,"static_fire_date_unix":null},{"flight_number":82,"mission_name":"CRS-18","mission_id":["EE86F74"],"launch_year":"2019","launch_date_unix":1557187200,"launch_date_utc":"2019-05-07T00:00:00.000Z","launch_date_local":"2019-05-06T20:00:00-04:00","is_tentative":true,"tentative_max_precision":"day","rocket":{"rocket_id":"falcon9","rocket_name":"Falcon 9","rocket_type":"FT","first_stage":{"cores":[{"core_serial":null,"flight":null,"block":null,"gridfins":null,"legs":null,"reused":true,"land_success":null,"landing_intent":null,"landing_type":null,"landing_vehicle":null}]},"second_stage":{"block":null,"payloads":[{"payload_id":"CRS-18","norad_id":[],"cap_serial":null,"reused":true,"customers":["NASA (CRS)"],"nationality":"United States","manufacturer":"SpaceX","payload_type":"Dragon 1.1","payload_mass_kg":null,"payload_mass_lbs":null,"orbit":"ISS","orbit_params":{"reference_system":"geocentric","regime":"low-earth","longitude":null,"semi_major_axis_km":null,"eccentricity":null,"periapsis_km":null,"apoapsis_km":null,"inclination_deg":null,"period_min":null,"lifespan_years":null,"epoch":null,"mean_motion":null,"raan":null,"arg_of_pericenter":null,"mean_anomaly":null},"mass_returned_kg":null,"mass_returned_lbs":null,"flight_time_sec":null,"cargo_manifest":null}]},"fairings":null},"ships":[],"telemetry":{"flight_club":null},"launch_site":{"site_id":"ksc_lc_39a","site_name":"KSC LC 39A","site_name_long":"Kennedy Space Center Historic Launch Complex 39A"},"launch_success":null,"links":{"mission_patch":null,"mission_patch_small":null,"reddit_campaign":null,"reddit_launch":null,"reddit_recovery":null,"reddit_media":null,"presskit":null,"article_link":null,"wikipedia":null,"video_link":null,"flickr_images":[]},"details":null,"upcoming":true,"static_fire_date_utc":null,"static_fire_date_unix":null},{"flight_number":83,"mission_name":"Crew Dragon In Flight Abort Test","mission_id":["EE86F74"],"launch_year":"2019","launch_date_unix":1556668800,"launch_date_utc":"2019-05-01T00:00:00.000Z","launch_date_local":"2019-04-30T20:00:00-04:00","is_tentative":true,"tentative_max_precision":"month","rocket":{"rocket_id":"falcon9","rocket_name":"Falcon 9","rocket_type":"FT","first_stage":{"cores":[{"core_serial":null,"flight":null,"block":null,"gridfins":null,"legs":null,"reused":true,"land_success":null,"landing_intent":null,"landing_type":null,"landing_vehicle":null}]},"second_stage":{"block":null,"payloads":[{"payload_id":"Crew Dragon In Flight Abort Test","norad_id":[],"cap_serial":null,"reused":true,"customers":["NASA (CCtCap)"],"nationality":"United States","manufacturer":"SpaceX","payload_type":"Crew Dragon","payload_mass_kg":null,"payload_mass_lbs":null,"orbit":"SO","orbit_params":{"reference_system":"geocentric","regime":"sub-orbital","longitude":null,"semi_major_axis_km":null,"eccentricity":null,"periapsis_km":null,"apoapsis_km":null,"inclination_deg":null,"period_min":null,"lifespan_years":null,"epoch":null,"mean_motion":null,"raan":null,"arg_of_pericenter":null,"mean_anomaly":null},"mass_returned_kg":null,"mass_returned_lbs":null,"flight_time_sec":null,"cargo_manifest":null}]},"fairings":null},"ships":[],"telemetry":{"flight_club":null},"launch_site":{"site_id":"ksc_lc_39a","site_name":"KSC LC 39A","site_name_long":"Kennedy Space Center Historic Launch Complex 39A"},"launch_success":null,"links":{"mission_patch":null,"mission_patch_small":null,"reddit_campaign":null,"reddit_launch":null,"reddit_recovery":null,"reddit_media":null,"presskit":null,"article_link":null,"wikipedia":null,"video_link":null,"flickr_images":[]},"details":null,"upcoming":true,"static_fire_date_utc":null,"static_fire_date_unix":null},{"flight_number":84,"mission_name":"CCtCap Demo Mission 2","mission_id":["EE86F74"],"launch_year":"2019","launch_date_unix":1559347200,"launch_date_utc":"2019-06-01T00:00:00.000Z","launch_date_local":"2019-05-31T20:00:00-04:00","is_tentative":true,"tentative_max_precision":"month","rocket":{"rocket_id":"falcon9","rocket_name":"Falcon 9","rocket_type":"FT","first_stage":{"cores":[{"core_serial":null,"flight":null,"block":5,"gridfins":null,"legs":null,"reused":false,"land_success":null,"landing_intent":null,"landing_type":null,"landing_vehicle":null}]},"second_stage":{"block":null,"payloads":[{"payload_id":"CCtCap Demo Mission 2","norad_id":[],"cap_serial":null,"reused":false,"customers":["NASA (CCtCap)"],"nationality":"United States","manufacturer":"SpaceX","payload_type":"Crew Dragon","payload_mass_kg":null,"payload_mass_lbs":null,"orbit":"ISS","orbit_params":{"reference_system":"geocentric","regime":"low-earth","longitude":null,"semi_major_axis_km":null,"eccentricity":null,"periapsis_km":null,"apoapsis_km":null,"inclination_deg":null,"period_min":null,"lifespan_years":null,"epoch":null,"mean_motion":null,"raan":null,"arg_of_pericenter":null,"mean_anomaly":null},"mass_returned_kg":null,"mass_returned_lbs":null,"flight_time_sec":null,"cargo_manifest":null}]},"fairings":null},"ships":[],"telemetry":{"flight_club":null},"launch_site":{"site_id":"ksc_lc_39a","site_name":"KSC LC 39A","site_name_long":"Kennedy Space Center Historic Launch Complex 39A"},"launch_success":null,"links":{"mission_patch":null,"mission_patch_small":null,"reddit_campaign":null,"reddit_launch":null,"reddit_recovery":null,"reddit_media":null,"presskit":null,"article_link":null,"wikipedia":null,"video_link":null,"flickr_images":[]},"details":null,"upcoming":true,"static_fire_date_utc":null,"static_fire_date_unix":null},{"flight_number":85,"mission_name":"Amos-17","mission_id":[],"launch_year":"2019","launch_date_unix":1554076800,"launch_date_utc":"2019-04-01T00:00:00.000Z","launch_date_local":"2019-03-31T20:00:00-04:00","is_tentative":true,"tentative_max_precision":"quarter","rocket":{"rocket_id":"falcon9","rocket_name":"Falcon 9","rocket_type":"FT","first_stage":{"cores":[{"core_serial":null,"flight":null,"block":null,"gridfins":null,"legs":null,"reused":null,"land_success":null,"landing_intent":null,"landing_type":null,"landing_vehicle":null}]},"second_stage":{"block":null,"payloads":[{"payload_id":"Amos-17","norad_id":[],"reused":false,"customers":["Spacecom"],"nationality":"Israel","manufacturer":"Boeing Satellite Systems","payload_type":"Satellite","payload_mass_kg":5500,"payload_mass_lbs":12125.42,"orbit":"GTO","orbit_params":{"reference_system":"geocentric","regime":"geostationary","longitude":17,"semi_major_axis_km":null,"eccentricity":null,"periapsis_km":null,"apoapsis_km":null,"inclination_deg":null,"period_min":null,"lifespan_years":15,"epoch":null,"mean_motion":null,"raan":null,"arg_of_pericenter":null,"mean_anomaly":null}}]},"fairings":{"reused":false,"recovery_attempt":false,"recovered":false,"ship":null}},"ships":[],"telemetry":{"flight_club":null},"launch_site":{"site_id":"ccafs_slc_40","site_name":"CCAFS SLC 40","site_name_long":"Cape Canaveral Air Force Station Space Launch Complex 40"},"launch_success":null,"links":{"mission_patch":null,"mission_patch_small":null,"reddit_campaign":null,"reddit_launch":null,"reddit_recovery":null,"reddit_media":null,"presskit":null,"article_link":null,"wikipedia":null,"video_link":null,"flickr_images":[]},"details":null,"upcoming":true,"static_fire_date_utc":null,"static_fire_date_unix":null},{"flight_number":86,"mission_name":"SSO-B","mission_id":[],"launch_year":"2019","launch_date_unix":1554076800,"launch_date_utc":"2019-04-01T00:00:00.000Z","launch_date_local":"2019-03-31T17:00:00-07:00","is_tentative":true,"tentative_max_precision":"quarter","rocket":{"rocket_id":"falcon9","rocket_name":"Falcon 9","rocket_type":"FT","first_stage":{"cores":[{"core_serial":null,"flight":null,"block":null,"gridfins":null,"legs":null,"reused":null,"land_success":null,"landing_intent":null,"landing_type":null,"landing_vehicle":null}]},"second_stage":{"block":null,"payloads":[{"payload_id":"SSO-B","norad_id":[],"reused":false,"customers":["Spaceflight Industries, Inc"],"nationality":"United States","manufacturer":null,"payload_type":"Satellite","payload_mass_kg":null,"payload_mass_lbs":null,"orbit":"SSO","orbit_params":{"reference_system":"geocentric","regime":"sun-synchronous","longitude":null,"semi_major_axis_km":null,"eccentricity":null,"periapsis_km":null,"apoapsis_km":null,"inclination_deg":null,"period_min":null,"lifespan_years":null,"epoch":null,"mean_motion":null,"raan":null,"arg_of_pericenter":null,"mean_anomaly":null}}]},"fairings":{"reused":false,"recovery_attempt":null,"recovered":null,"ship":null}},"ships":[],"telemetry":{"flight_club":null},"launch_site":{"site_id":"vafb_slc_4e","site_name":"VAFB SLC 4E","site_name_long":"Vandenberg Air Force Base Space Launch Complex 4E"},"launch_success":null,"links":{"mission_patch":null,"mission_patch_small":null,"reddit_campaign":null,"reddit_launch":null,"reddit_recovery":null,"reddit_media":null,"presskit":null,"article_link":null,"wikipedia":null,"video_link":null,"flickr_images":[]},"details":null,"upcoming":true,"static_fire_date_utc":null,"static_fire_date_unix":null},{"flight_number":87,"mission_name":"GiSAT-1","mission_id":[],"launch_year":"2019","launch_date_unix":1546300800,"launch_date_utc":"2019-01-01T00:00:00.000Z","launch_date_local":"2018-12-31T19:00:00-05:00","is_tentative":true,"tentative_max_precision":"half","rocket":{"rocket_id":"falcon9","rocket_name":"Falcon 9","rocket_type":"FT","first_stage":{"cores":[{"core_serial":null,"flight":null,"block":5,"gridfins":null,"legs":null,"reused":null,"land_success":null,"landing_intent":null,"landing_type":null,"landing_vehicle":null}]},"second_stage":{"block":5,"payloads":[{"payload_id":"GiSAT-1","norad_id":[],"reused":false,"customers":["Global IP Cayman"],"nationality":"Cayman Islands","manufacturer":"Boeing","payload_type":"Satellite","payload_mass_kg":6000,"payload_mass_lbs":13227.74,"orbit":"GTO","orbit_params":{"reference_system":"geocentric","regime":"geostationary","longitude":null,"semi_major_axis_km":null,"eccentricity":null,"periapsis_km":null,"apoapsis_km":null,"inclination_deg":null,"period_min":null,"lifespan_years":15,"epoch":null,"mean_motion":null,"raan":null,"arg_of_pericenter":null,"mean_anomaly":null}}]},"fairings":{"reused":false,"recovery_attempt":false,"recovered":false,"ship":null}},"ships":[],"telemetry":{"flight_club":null},"launch_site":{"site_id":"ccafs_slc_40","site_name":"CCAFS SLC 40","site_name_long":"Cape Canaveral Air Force Station Space Launch Complex 40"},"launch_success":null,"links":{"mission_patch":null,"mission_patch_small":null,"reddit_campaign":null,"reddit_launch":null,"reddit_recovery":null,"reddit_media":null,"presskit":null,"article_link":null,"wikipedia":null,"video_link":null,"flickr_images":[]},"details":null,"upcoming":true,"static_fire_date_utc":null,"static_fire_date_unix":null},{"flight_number":88,"mission_name":"USCV-1 (NASA Crew Flight 1)","mission_id":["EE86F74"],"launch_year":"2019","launch_date_unix":1564617600,"launch_date_utc":"2019-08-01T00:00:00.000Z","launch_date_local":"2019-07-31T20:00:00-04:00","is_tentative":true,"tentative_max_precision":"month","rocket":{"rocket_id":"falcon9","rocket_name":"Falcon 9","rocket_type":"FT","first_stage":{"cores":[{"core_serial":null,"flight":null,"block":5,"gridfins":null,"legs":null,"reused":false,"land_success":null,"landing_intent":null,"landing_type":null,"landing_vehicle":null}]},"second_stage":{"block":5,"payloads":[{"payload_id":"USCV-1 (NASA Crew Flight 1)","norad_id":[],"cap_serial":null,"reused":false,"customers":["NASA (CCtCap)"],"nationality":"United States","manufacturer":"SpaceX","payload_type":"Crew Dragon","payload_mass_kg":null,"payload_mass_lbs":null,"orbit":"ISS","orbit_params":{"reference_system":"geocentric","regime":"low-earth","longitude":null,"semi_major_axis_km":null,"eccentricity":null,"periapsis_km":null,"apoapsis_km":null,"inclination_deg":null,"period_min":null,"lifespan_years":null,"epoch":null,"mean_motion":null,"raan":null,"arg_of_pericenter":null,"mean_anomaly":null},"mass_returned_kg":null,"mass_returned_lbs":null,"flight_time_sec":null,"cargo_manifest":null}]},"fairings":null},"ships":[],"telemetry":{"flight_club":null},"launch_site":{"site_id":"ksc_lc_39a","site_name":"KSC LC 39A","site_name_long":"Kennedy Space Center Historic Launch Complex 39A"},"launch_success":null,"links":{"mission_patch":null,"mission_patch_small":null,"reddit_campaign":null,"reddit_launch":null,"reddit_recovery":null,"reddit_media":null,"presskit":null,"article_link":null,"wikipedia":null,"video_link":null,"flickr_images":[]},"details":null,"upcoming":true,"static_fire_date_utc":null,"static_fire_date_unix":null},{"flight_number":89,"mission_name":"SAOCOM 1B","mission_id":[],"launch_year":"2019","launch_date_unix":1567296000,"launch_date_utc":"2019-09-01T00:00:00.000Z","launch_date_local":"2019-08-31T17:00:00-07:00","is_tentative":true,"tentative_max_precision":"month","rocket":{"rocket_id":"falcon9","rocket_name":"Falcon 9","rocket_type":"FT","first_stage":{"cores":[{"core_serial":null,"flight":null,"block":null,"gridfins":null,"legs":null,"reused":null,"land_success":null,"landing_intent":null,"landing_type":null,"landing_vehicle":null}]},"second_stage":{"block":null,"payloads":[{"payload_id":"SAOCOM 1B","norad_id":[],"reused":false,"customers":["CONAE"],"nationality":"Argentina","manufacturer":null,"payload_type":"Satellite","payload_mass_kg":1600,"payload_mass_lbs":3527.396,"orbit":"SSO","orbit_params":{"reference_system":"geocentric","regime":"sun-synchronous","longitude":null,"semi_major_axis_km":null,"eccentricity":null,"periapsis_km":null,"apoapsis_km":null,"inclination_deg":null,"period_min":null,"lifespan_years":null,"epoch":null,"mean_motion":null,"raan":null,"arg_of_pericenter":null,"mean_anomaly":null}}]},"fairings":{"reused":false,"recovery_attempt":null,"recovered":null,"ship":null}},"ships":[],"telemetry":{"flight_club":null},"launch_site":{"site_id":"vafb_slc_4e","site_name":"VAFB SLC 4E","site_name_long":"Vandenberg Air Force Base Space Launch Complex 4E"},"launch_success":null,"links":{"mission_patch":null,"mission_patch_small":null,"reddit_campaign":null,"reddit_launch":null,"reddit_recovery":null,"reddit_media":null,"presskit":null,"article_link":null,"wikipedia":null,"video_link":null,"flickr_images":[]},"details":null,"upcoming":true,"static_fire_date_utc":null,"static_fire_date_unix":null},{"flight_number":90,"mission_name":"CRS-19","mission_id":["EE86F74"],"launch_year":"2019","launch_date_unix":1569888000,"launch_date_utc":"2019-10-01T00:00:00.000Z","launch_date_local":"2019-09-30T20:00:00-04:00","is_tentative":true,"tentative_max_precision":"month","rocket":{"rocket_id":"falcon9","rocket_name":"Falcon 9","rocket_type":"FT","first_stage":{"cores":[{"core_serial":null,"flight":null,"block":null,"gridfins":null,"legs":null,"reused":true,"land_success":null,"landing_intent":null,"landing_type":null,"landing_vehicle":null}]},"second_stage":{"block":null,"payloads":[{"payload_id":"CRS-19","norad_id":[],"cap_serial":null,"reused":true,"customers":["NASA (CRS)"],"nationality":"United States","manufacturer":"SpaceX","payload_type":"Dragon 1.1","payload_mass_kg":null,"payload_mass_lbs":null,"orbit":"ISS","orbit_params":{"reference_system":"geocentric","regime":"low-earth","longitude":null,"semi_major_axis_km":null,"eccentricity":null,"periapsis_km":null,"apoapsis_km":null,"inclination_deg":null,"period_min":null,"lifespan_years":null,"epoch":null,"mean_motion":null,"raan":null,"arg_of_pericenter":null,"mean_anomaly":null},"mass_returned_kg":null,"mass_returned_lbs":null,"flight_time_sec":null,"cargo_manifest":null}]},"fairings":null},"ships":[],"telemetry":{"flight_club":null},"launch_site":{"site_id":"ksc_lc_39a","site_name":"KSC LC 39A","site_name_long":"Kennedy Space Center Historic Launch Complex 39A"},"launch_success":null,"links":{"mission_patch":null,"mission_patch_small":null,"reddit_campaign":null,"reddit_launch":null,"reddit_recovery":null,"reddit_media":null,"presskit":null,"article_link":null,"wikipedia":null,"video_link":null,"flickr_images":[]},"details":null,"upcoming":true,"static_fire_date_utc":null,"static_fire_date_unix":null},{"flight_number":91,"mission_name":"GPS IIIA-3","mission_id":[],"launch_year":"2019","launch_date_unix":1569888000,"launch_date_utc":"2019-10-01T00:00:00.000Z","launch_date_local":"2019-09-30T20:00:00-04:00","is_tentative":true,"tentative_max_precision":"month","rocket":{"rocket_id":"falcon9","rocket_name":"Falcon 9","rocket_type":"FT","first_stage":{"cores":[{"core_serial":null,"flight":null,"block":null,"gridfins":null,"legs":null,"reused":false,"land_success":null,"landing_intent":null,"landing_type":null,"landing_vehicle":null}]},"second_stage":{"block":null,"payloads":[{"payload_id":"GPS IIIA-3","norad_id":[],"reused":false,"customers":["USAF"],"nationality":"United States","manufacturer":"Lockheed Martin","payload_type":"Satellite","payload_mass_kg":3880,"payload_mass_lbs":8553.94,"orbit":"MEO","orbit_params":{"reference_system":null,"regime":null,"longitude":null,"semi_major_axis_km":null,"eccentricity":null,"periapsis_km":null,"apoapsis_km":null,"inclination_deg":null,"period_min":null,"lifespan_years":15,"epoch":null,"mean_motion":null,"raan":null,"arg_of_pericenter":null,"mean_anomaly":null}}]},"fairings":{"reused":false,"recovery_attempt":null,"recovered":null,"ship":null}},"ships":[],"telemetry":{"flight_club":null},"launch_site":{"site_id":"ccafs_slc_40","site_name":"CCAFS SLC 40","site_name_long":"Cape Canaveral Air Force Station Space Launch Complex 40"},"launch_success":null,"links":{"mission_patch":null,"mission_patch_small":null,"reddit_campaign":null,"reddit_launch":null,"reddit_recovery":null,"reddit_media":null,"presskit":null,"article_link":null,"wikipedia":null,"video_link":null,"flickr_images":[]},"details":null,"upcoming":true,"static_fire_date_utc":null,"static_fire_date_unix":null}] + http_version: + recorded_at: Mon, 29 Oct 2018 22:59:11 GMT +recorded_with: VCR 4.0.0 From 01c3d32e11a283c488892217a344e0793948538c Mon Sep 17 00:00:00 2001 From: Michael King Date: Mon, 29 Oct 2018 19:20:56 -0400 Subject: [PATCH 04/11] update rubocop todo --- .rubocop_todo.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.rubocop_todo.yml b/.rubocop_todo.yml index edafff7..09dbc90 100644 --- a/.rubocop_todo.yml +++ b/.rubocop_todo.yml @@ -1,6 +1,6 @@ # This configuration was generated by # `rubocop --auto-gen-config` -# on 2018-10-23 18:08:15 -0400 using RuboCop version 0.51.0. +# on 2018-10-29 19:01:14 -0400 using RuboCop version 0.51.0. # The point is for the user to remove these configuration records # one by one as the offenses are removed from the code base. # Note that changes in the inspected code, or installation of new @@ -12,10 +12,10 @@ Lint/ParenthesesAsGroupedExpression: - 'spec/spacex/dragon_capsules_spec.rb' - 'spec/spacex/ships_spec.rb' -# Offense count: 30 +# Offense count: 32 # Configuration parameters: CountComments, ExcludedMethods. Metrics/BlockLength: - Max: 423 + Max: 441 # Offense count: 128 # Configuration parameters: AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, IgnoredPatterns. From b4d930c834bf0404bfb5ce50a0b019964d004ffc Mon Sep 17 00:00:00 2001 From: Michael King Date: Mon, 29 Oct 2018 19:21:12 -0400 Subject: [PATCH 05/11] update README --- README.md | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/README.md b/README.md index 137a006..ce16715 100644 --- a/README.md +++ b/README.md @@ -214,6 +214,7 @@ first_event.links['wikipedia'] # https://en.wikipedia.org/wiki/Falcon_1 - Get information on the next launch: `SPACEX::Launches.next` - Get the latest launch information: `SPACEX::Launches.latest` - Get information on past launches: `SPACEX::Launches.past` +- Get information on upcoming launches: `SPACEX::Launches.upcoming` The following code snippet shows the latest launch information and the data fields available on the Launch object: @@ -314,6 +315,22 @@ past_launches.last.rocket.first_stage.cores.first.land_success # true past_launches.last.launch_success # true ``` +This code snippet shows how to get information on upcoming launches: +```ruby +upcoming_launches = SPACEX::Launches.upcoming + +upcoming_launches.all?(&:upcoming) # true +upcoming_launches.all? {|launch| Time.parse(launch.launch_date_utc) >= Time.now.utc} # true + +upcoming_launches.each do |launch| + puts "Flight #{launch.flight_number} (#{launch.mission_name}) is scheduled to launch at #{launch.launch_date_local} from #{launch.launch_site.site_name_long}" +end +# Flight 70 (Es’hail 2) is scheduled to launch at 2018-11-14T15:46:00-05:00 from Cape Canaveral Air Force Station Space Launch Complex 40 +# Flight 71 (SSO-A) is scheduled to launch at 2018-11-19T10:30:00-08:00 from Vandenberg Air Force Base Space Launch Complex 4E +# Flight 72 (CRS-16) is scheduled to launch at 2018-11-30T19:00:00-05:00 from Cape Canaveral Air Force Station Space Launch Complex 40 +# ... +``` + ### Missions - Get all mission information: `SPACEX::Missions.info` From 8ee9739351f822dad8da2838014965a903184f3c Mon Sep 17 00:00:00 2001 From: Michael King Date: Mon, 29 Oct 2018 19:21:27 -0400 Subject: [PATCH 06/11] update CHANGELOG --- CHANGELOG.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index a220c4d..c828ce4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,7 +3,8 @@ * [#48](https://github.com/rodolfobandeira/spacex/pull/48): Add ability to query specific Launch via `.info('flight_number')` - [@mtking2](http://github.com/mtking2). * [#51](https://github.com/rodolfobandeira/spacex/pull/51): Added payloads endpoint [@maiafernando](http://github.com/maiafernando). * [#52](https://github.com/rodolfobandeira/spacex/pull/52): Add ability to query Past Launches - [@mtking2](http://github.com/mtking2). -* [#52](https://github.com/rodolfobandeira/spacex/pull/54): Refactor ENDPOINT_URI - [@ludamillion](http://github.com/ludamillion). +* [#54](https://github.com/rodolfobandeira/spacex/pull/54): Refactor ENDPOINT_URI - [@ludamillion](http://github.com/ludamillion). +* [#56](https://github.com/rodolfobandeira/spacex/pull/56): Add ability to query upcoming launches - [@mtking2](http://github.com/mtking2). * Your contribution here. ### 1.0.0 (2018/10/15) From 0be5e9e2d12a97ab7e0e398d4e08087f0c250eb8 Mon Sep 17 00:00:00 2001 From: Michael King Date: Thu, 1 Nov 2018 19:57:52 -0400 Subject: [PATCH 07/11] add tests to verify all fields for upcoming launches --- spec/spacex/launches_spec.rb | 187 +++++++++++++++++++++++++++++++++++ 1 file changed, 187 insertions(+) diff --git a/spec/spacex/launches_spec.rb b/spec/spacex/launches_spec.rb index 57b7f53..bee0b92 100644 --- a/spec/spacex/launches_spec.rb +++ b/spec/spacex/launches_spec.rb @@ -412,6 +412,193 @@ expect(launch.launch_success).to be nil end end + + context 'returns upcoming launches' do + it 'returns the next upcoming launch' do + expect(subject.first.flight_number).to eq 70 + expect(subject.first.mission_name).to eq 'Es’hail 2' + expect(subject.first.mission_id).to eq [] + expect(subject.first.launch_year).to eq '2018' + expect(subject.first.launch_date_unix).to eq 1_542_228_360 + expect(subject.first.launch_date_utc).to eq '2018-11-14T20:46:00.000Z' + expect(subject.first.launch_date_local).to eq '2018-11-14T15:46:00-05:00' + expect(subject.first.is_tentative).to eq true + expect(subject.first.tentative_max_precision).to eq 'hour' + expect(subject.first.rocket.rocket_id).to eq 'falcon9' + expect(subject.first.rocket.rocket_name).to eq 'Falcon 9' + expect(subject.first.rocket.rocket_type).to eq 'FT' + expect(subject.first.rocket.first_stage.cores).to be_an(Array) + expect(subject.first.rocket.first_stage.cores.first).to eq( + "core_serial" => nil, + "flight" => nil, + "block" => 5, + "gridfins" => true, + "legs" => true, + "reused" => false, + "land_success" => nil, + "landing_intent" => true, + "landing_type" => "ASDS", + "landing_vehicle" => "OCISLY" + ) + expect(subject.first.rocket.second_stage.block).to eq 5 + expect(subject.first.rocket.second_stage.payloads).to be_an(Array) + expect(subject.first.rocket.second_stage.payloads.first).to eq( + "payload_id" => "Es’hail 2", + "norad_id" => [], + "reused" => false, + "customers" => ["Es’hailSat"], + "nationality" => "Qatar", + "manufacturer" => "Mitsubishi Electric", + "payload_type" => "Satellite", + "payload_mass_kg" => 3000, + "payload_mass_lbs" => 6613.868, + "orbit" => "GTO", + "orbit_params" => { + "reference_system" => "geocentric", + "regime" => "geostationary", + "longitude" => 25.5, + "semi_major_axis_km" => nil, + "eccentricity" => nil, + "periapsis_km" => nil, + "apoapsis_km" => nil, + "inclination_deg" => nil, + "period_min" => nil, + "lifespan_years" => 15, + "epoch" => nil, + "mean_motion" => nil, + "raan" => nil, + "arg_of_pericenter" => nil, + "mean_anomaly" => nil + } + ) + expect(subject.first.rocket.fairings).to eq( + "reused" => false, + "recovery_attempt" => false, + "recovered" => false, + "ship" => nil + ) + expect(subject.first.ships).to eq [] + expect(subject.first.telemetry.flight_club).to eq nil + expect(subject.first.launch_site).to eq( + "site_id" => "ccafs_slc_40", + "site_name" => "CCAFS SLC 40", + "site_name_long" => "Cape Canaveral Air Force Station Space Launch Complex 40" + ) + expect(subject.first.launch_success).to eq nil + expect(subject.first.links).to eq( + "mission_patch" => nil, + "mission_patch_small" => nil, + "reddit_campaign" => "https://www.reddit.com/r/spacex/comments/9p82jt/eshail_2_launch_campaign_thread/", + "reddit_launch" => nil, + "reddit_recovery" => nil, + "reddit_media" => nil, + "presskit" => nil, + "article_link" => nil, + "wikipedia" => nil, + "video_link" => nil, + "flickr_images" => [] + ) + expect(subject.first.details).to eq "SpaceX's eighteenth flight of 2018 will "\ + "be its first for Es'hailSat. Es'hail-2 is a communications satellite "\ + "that will deliver television and internet to Qatar and the surrounding "\ + "region. It will be launched into a geostationary transfer orbit from "\ + "LC-39A at Kennedy Space Center. The booster is expected to land on OCISLY." + expect(subject.first.upcoming).to eq true + expect(subject.first.static_fire_date_utc).to eq nil + expect(subject.first.static_fire_date_unix).to eq nil + end + + it 'returns the last upcoming launch' do + expect(subject.last.flight_number).to eq 91 + expect(subject.last.mission_name).to eq 'GPS IIIA-3' + expect(subject.last.mission_id).to eq [] + expect(subject.last.launch_year).to eq '2019' + expect(subject.last.launch_date_unix).to eq 1_569_888_000 + expect(subject.last.launch_date_utc).to eq '2019-10-01T00:00:00.000Z' + expect(subject.last.launch_date_local).to eq '2019-09-30T20:00:00-04:00' + expect(subject.last.is_tentative).to eq true + expect(subject.last.tentative_max_precision).to eq 'month' + expect(subject.last.rocket.rocket_id).to eq 'falcon9' + expect(subject.last.rocket.rocket_name).to eq 'Falcon 9' + expect(subject.last.rocket.rocket_type).to eq 'FT' + expect(subject.last.rocket.first_stage.cores).to be_an(Array) + expect(subject.last.rocket.first_stage.cores.first).to eq( + "core_serial" => nil, + "flight" => nil, + "block" => nil, + "gridfins" => nil, + "legs" => nil, + "reused" => false, + "land_success" => nil, + "landing_intent" => nil, + "landing_type" => nil, + "landing_vehicle" => nil + ) + expect(subject.last.rocket.second_stage.block).to eq nil + expect(subject.last.rocket.second_stage.payloads).to be_an(Array) + expect(subject.last.rocket.second_stage.payloads.first).to eq( + "payload_id" => "GPS IIIA-3", + "norad_id" => [], + "reused" => false, + "customers" => ["USAF"], + "nationality" => "United States", + "manufacturer" => "Lockheed Martin", + "payload_type" => "Satellite", + "payload_mass_kg" => 3880, + "payload_mass_lbs" => 8553.94, + "orbit" => "MEO", + "orbit_params" => { + "reference_system" => nil, + "regime" => nil, + "longitude" => nil, + "semi_major_axis_km" => nil, + "eccentricity" => nil, + "periapsis_km" => nil, + "apoapsis_km" => nil, + "inclination_deg" => nil, + "period_min" => nil, + "lifespan_years" => 15, + "epoch" => nil, + "mean_motion" => nil, + "raan" => nil, + "arg_of_pericenter" => nil, + "mean_anomaly" => nil + } + ) + expect(subject.last.rocket.fairings).to eq( + "reused" => false, + "recovery_attempt" => nil, + "recovered" => nil, + "ship" => nil + ) + expect(subject.last.ships).to eq [] + expect(subject.last.telemetry.flight_club).to eq nil + expect(subject.last.launch_site).to eq( + "site_id" => "ccafs_slc_40", + "site_name" => "CCAFS SLC 40", + "site_name_long" => "Cape Canaveral Air Force Station Space Launch Complex 40" + ) + expect(subject.last.launch_success).to eq nil + expect(subject.last.links).to eq( + "mission_patch" => nil, + "mission_patch_small" => nil, + "reddit_campaign" => nil, + "reddit_launch" => nil, + "reddit_recovery" => nil, + "reddit_media" => nil, + "presskit" => nil, + "article_link" => nil, + "wikipedia" => nil, + "video_link" => nil, + "flickr_images" => [] + ) + expect(subject.last.details).to eq nil + expect(subject.last.upcoming).to eq true + expect(subject.last.static_fire_date_utc).to eq nil + expect(subject.last.static_fire_date_unix).to eq nil + end + + end end context '#all', vcr: { cassette_name: 'launches/all' } do From 2ff9162b40447637e3eb92b6681292dfd6e03a8f Mon Sep 17 00:00:00 2001 From: Michael King Date: Thu, 1 Nov 2018 20:03:14 -0400 Subject: [PATCH 08/11] update README to make examples consistent --- README.md | 17 +++++++---------- 1 file changed, 7 insertions(+), 10 deletions(-) diff --git a/README.md b/README.md index 9950a8a..af289ad 100644 --- a/README.md +++ b/README.md @@ -351,16 +351,13 @@ This code snippet shows how to get information on upcoming launches: ```ruby upcoming_launches = SPACEX::Launches.upcoming -upcoming_launches.all?(&:upcoming) # true -upcoming_launches.all? {|launch| Time.parse(launch.launch_date_utc) >= Time.now.utc} # true - -upcoming_launches.each do |launch| - puts "Flight #{launch.flight_number} (#{launch.mission_name}) is scheduled to launch at #{launch.launch_date_local} from #{launch.launch_site.site_name_long}" -end -# Flight 70 (Es’hail 2) is scheduled to launch at 2018-11-14T15:46:00-05:00 from Cape Canaveral Air Force Station Space Launch Complex 40 -# Flight 71 (SSO-A) is scheduled to launch at 2018-11-19T10:30:00-08:00 from Vandenberg Air Force Base Space Launch Complex 4E -# Flight 72 (CRS-16) is scheduled to launch at 2018-11-30T19:00:00-05:00 from Cape Canaveral Air Force Station Space Launch Complex 40 -# ... +upcoming_launches.first.flight_number # 70 +upcoming_launches.first.mission_name # 'Es’hail 2' +upcoming_launches.first.launch_date_utc # '2018-11-14T20:46:00.000Z' + +upcoming_launches.last.flight_number # 91 +upcoming_launches.last.mission_name # 'GPS IIIA-3' +upcoming_launches.last.launch_date_utc # '2019-10-01T00:00:00.000Z' ``` ### Missions From 0d514bea8f7750ead048477a4db63d8240ff96e5 Mon Sep 17 00:00:00 2001 From: Michael King Date: Thu, 1 Nov 2018 20:10:52 -0400 Subject: [PATCH 09/11] use single quoted string to satisfy rubocop --- .rubocop_todo.yml | 8 +- spec/spacex/launches_spec.rb | 227 +++++++++++++++++------------------ 2 files changed, 117 insertions(+), 118 deletions(-) diff --git a/.rubocop_todo.yml b/.rubocop_todo.yml index 09dbc90..21ede23 100644 --- a/.rubocop_todo.yml +++ b/.rubocop_todo.yml @@ -1,6 +1,6 @@ # This configuration was generated by # `rubocop --auto-gen-config` -# on 2018-10-29 19:01:14 -0400 using RuboCop version 0.51.0. +# on 2018-11-01 20:09:44 -0400 using RuboCop version 0.51.0. # The point is for the user to remove these configuration records # one by one as the offenses are removed from the code base. # Note that changes in the inspected code, or installation of new @@ -12,12 +12,12 @@ Lint/ParenthesesAsGroupedExpression: - 'spec/spacex/dragon_capsules_spec.rb' - 'spec/spacex/ships_spec.rb' -# Offense count: 32 +# Offense count: 36 # Configuration parameters: CountComments, ExcludedMethods. Metrics/BlockLength: - Max: 441 + Max: 625 -# Offense count: 128 +# Offense count: 136 # Configuration parameters: AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, IgnoredPatterns. # URISchemes: http, https Metrics/LineLength: diff --git a/spec/spacex/launches_spec.rb b/spec/spacex/launches_spec.rb index bee0b92..84036ef 100644 --- a/spec/spacex/launches_spec.rb +++ b/spec/spacex/launches_spec.rb @@ -429,80 +429,80 @@ expect(subject.first.rocket.rocket_type).to eq 'FT' expect(subject.first.rocket.first_stage.cores).to be_an(Array) expect(subject.first.rocket.first_stage.cores.first).to eq( - "core_serial" => nil, - "flight" => nil, - "block" => 5, - "gridfins" => true, - "legs" => true, - "reused" => false, - "land_success" => nil, - "landing_intent" => true, - "landing_type" => "ASDS", - "landing_vehicle" => "OCISLY" + 'core_serial' => nil, + 'flight' => nil, + 'block' => 5, + 'gridfins' => true, + 'legs' => true, + 'reused' => false, + 'land_success' => nil, + 'landing_intent' => true, + 'landing_type' => 'ASDS', + 'landing_vehicle' => 'OCISLY' ) expect(subject.first.rocket.second_stage.block).to eq 5 expect(subject.first.rocket.second_stage.payloads).to be_an(Array) expect(subject.first.rocket.second_stage.payloads.first).to eq( - "payload_id" => "Es’hail 2", - "norad_id" => [], - "reused" => false, - "customers" => ["Es’hailSat"], - "nationality" => "Qatar", - "manufacturer" => "Mitsubishi Electric", - "payload_type" => "Satellite", - "payload_mass_kg" => 3000, - "payload_mass_lbs" => 6613.868, - "orbit" => "GTO", - "orbit_params" => { - "reference_system" => "geocentric", - "regime" => "geostationary", - "longitude" => 25.5, - "semi_major_axis_km" => nil, - "eccentricity" => nil, - "periapsis_km" => nil, - "apoapsis_km" => nil, - "inclination_deg" => nil, - "period_min" => nil, - "lifespan_years" => 15, - "epoch" => nil, - "mean_motion" => nil, - "raan" => nil, - "arg_of_pericenter" => nil, - "mean_anomaly" => nil + 'payload_id' => 'Es’hail 2', + 'norad_id' => [], + 'reused' => false, + 'customers' => ['Es’hailSat'], + 'nationality' => 'Qatar', + 'manufacturer' => 'Mitsubishi Electric', + 'payload_type' => 'Satellite', + 'payload_mass_kg' => 3000, + 'payload_mass_lbs' => 6613.868, + 'orbit' => 'GTO', + 'orbit_params' => { + 'reference_system' => 'geocentric', + 'regime' => 'geostationary', + 'longitude' => 25.5, + 'semi_major_axis_km' => nil, + 'eccentricity' => nil, + 'periapsis_km' => nil, + 'apoapsis_km' => nil, + 'inclination_deg' => nil, + 'period_min' => nil, + 'lifespan_years' => 15, + 'epoch' => nil, + 'mean_motion' => nil, + 'raan' => nil, + 'arg_of_pericenter' => nil, + 'mean_anomaly' => nil } ) expect(subject.first.rocket.fairings).to eq( - "reused" => false, - "recovery_attempt" => false, - "recovered" => false, - "ship" => nil + 'reused' => false, + 'recovery_attempt' => false, + 'recovered' => false, + 'ship' => nil ) expect(subject.first.ships).to eq [] expect(subject.first.telemetry.flight_club).to eq nil expect(subject.first.launch_site).to eq( - "site_id" => "ccafs_slc_40", - "site_name" => "CCAFS SLC 40", - "site_name_long" => "Cape Canaveral Air Force Station Space Launch Complex 40" + 'site_id' => 'ccafs_slc_40', + 'site_name' => 'CCAFS SLC 40', + 'site_name_long' => 'Cape Canaveral Air Force Station Space Launch Complex 40' ) expect(subject.first.launch_success).to eq nil expect(subject.first.links).to eq( - "mission_patch" => nil, - "mission_patch_small" => nil, - "reddit_campaign" => "https://www.reddit.com/r/spacex/comments/9p82jt/eshail_2_launch_campaign_thread/", - "reddit_launch" => nil, - "reddit_recovery" => nil, - "reddit_media" => nil, - "presskit" => nil, - "article_link" => nil, - "wikipedia" => nil, - "video_link" => nil, - "flickr_images" => [] + 'mission_patch' => nil, + 'mission_patch_small' => nil, + 'reddit_campaign' => 'https://www.reddit.com/r/spacex/comments/9p82jt/eshail_2_launch_campaign_thread/', + 'reddit_launch' => nil, + 'reddit_recovery' => nil, + 'reddit_media' => nil, + 'presskit' => nil, + 'article_link' => nil, + 'wikipedia' => nil, + 'video_link' => nil, + 'flickr_images' => [] ) - expect(subject.first.details).to eq "SpaceX's eighteenth flight of 2018 will "\ - "be its first for Es'hailSat. Es'hail-2 is a communications satellite "\ - "that will deliver television and internet to Qatar and the surrounding "\ - "region. It will be launched into a geostationary transfer orbit from "\ - "LC-39A at Kennedy Space Center. The booster is expected to land on OCISLY." + expect(subject.first.details).to eq 'SpaceX\'s eighteenth flight of 2018 will '\ + 'be its first for Es\'hailSat. Es\'hail-2 is a communications satellite '\ + 'that will deliver television and internet to Qatar and the surrounding '\ + 'region. It will be launched into a geostationary transfer orbit from '\ + 'LC-39A at Kennedy Space Center. The booster is expected to land on OCISLY.' expect(subject.first.upcoming).to eq true expect(subject.first.static_fire_date_utc).to eq nil expect(subject.first.static_fire_date_unix).to eq nil @@ -523,81 +523,80 @@ expect(subject.last.rocket.rocket_type).to eq 'FT' expect(subject.last.rocket.first_stage.cores).to be_an(Array) expect(subject.last.rocket.first_stage.cores.first).to eq( - "core_serial" => nil, - "flight" => nil, - "block" => nil, - "gridfins" => nil, - "legs" => nil, - "reused" => false, - "land_success" => nil, - "landing_intent" => nil, - "landing_type" => nil, - "landing_vehicle" => nil + 'core_serial' => nil, + 'flight' => nil, + 'block' => nil, + 'gridfins' => nil, + 'legs' => nil, + 'reused' => false, + 'land_success' => nil, + 'landing_intent' => nil, + 'landing_type' => nil, + 'landing_vehicle' => nil ) expect(subject.last.rocket.second_stage.block).to eq nil expect(subject.last.rocket.second_stage.payloads).to be_an(Array) expect(subject.last.rocket.second_stage.payloads.first).to eq( - "payload_id" => "GPS IIIA-3", - "norad_id" => [], - "reused" => false, - "customers" => ["USAF"], - "nationality" => "United States", - "manufacturer" => "Lockheed Martin", - "payload_type" => "Satellite", - "payload_mass_kg" => 3880, - "payload_mass_lbs" => 8553.94, - "orbit" => "MEO", - "orbit_params" => { - "reference_system" => nil, - "regime" => nil, - "longitude" => nil, - "semi_major_axis_km" => nil, - "eccentricity" => nil, - "periapsis_km" => nil, - "apoapsis_km" => nil, - "inclination_deg" => nil, - "period_min" => nil, - "lifespan_years" => 15, - "epoch" => nil, - "mean_motion" => nil, - "raan" => nil, - "arg_of_pericenter" => nil, - "mean_anomaly" => nil + 'payload_id' => 'GPS IIIA-3', + 'norad_id' => [], + 'reused' => false, + 'customers' => ['USAF'], + 'nationality' => 'United States', + 'manufacturer' => 'Lockheed Martin', + 'payload_type' => 'Satellite', + 'payload_mass_kg' => 3880, + 'payload_mass_lbs' => 8553.94, + 'orbit' => 'MEO', + 'orbit_params' => { + 'reference_system' => nil, + 'regime' => nil, + 'longitude' => nil, + 'semi_major_axis_km' => nil, + 'eccentricity' => nil, + 'periapsis_km' => nil, + 'apoapsis_km' => nil, + 'inclination_deg' => nil, + 'period_min' => nil, + 'lifespan_years' => 15, + 'epoch' => nil, + 'mean_motion' => nil, + 'raan' => nil, + 'arg_of_pericenter' => nil, + 'mean_anomaly' => nil } ) expect(subject.last.rocket.fairings).to eq( - "reused" => false, - "recovery_attempt" => nil, - "recovered" => nil, - "ship" => nil + 'reused' => false, + 'recovery_attempt' => nil, + 'recovered' => nil, + 'ship' => nil ) expect(subject.last.ships).to eq [] expect(subject.last.telemetry.flight_club).to eq nil expect(subject.last.launch_site).to eq( - "site_id" => "ccafs_slc_40", - "site_name" => "CCAFS SLC 40", - "site_name_long" => "Cape Canaveral Air Force Station Space Launch Complex 40" + 'site_id' => 'ccafs_slc_40', + 'site_name' => 'CCAFS SLC 40', + 'site_name_long' => 'Cape Canaveral Air Force Station Space Launch Complex 40' ) expect(subject.last.launch_success).to eq nil expect(subject.last.links).to eq( - "mission_patch" => nil, - "mission_patch_small" => nil, - "reddit_campaign" => nil, - "reddit_launch" => nil, - "reddit_recovery" => nil, - "reddit_media" => nil, - "presskit" => nil, - "article_link" => nil, - "wikipedia" => nil, - "video_link" => nil, - "flickr_images" => [] + 'mission_patch' => nil, + 'mission_patch_small' => nil, + 'reddit_campaign' => nil, + 'reddit_launch' => nil, + 'reddit_recovery' => nil, + 'reddit_media' => nil, + 'presskit' => nil, + 'article_link' => nil, + 'wikipedia' => nil, + 'video_link' => nil, + 'flickr_images' => [] ) expect(subject.last.details).to eq nil expect(subject.last.upcoming).to eq true expect(subject.last.static_fire_date_utc).to eq nil expect(subject.last.static_fire_date_unix).to eq nil end - end end From f78fd565123656dda7a291352e7bfa455676cbcd Mon Sep 17 00:00:00 2001 From: Michael King Date: Fri, 2 Nov 2018 12:56:46 -0400 Subject: [PATCH 10/11] update README, remove duplicate examples --- README.md | 37 +++++-------------------------------- 1 file changed, 5 insertions(+), 32 deletions(-) diff --git a/README.md b/README.md index af289ad..adb8e3a 100644 --- a/README.md +++ b/README.md @@ -213,6 +213,10 @@ first_event.links['wikipedia'] # https://en.wikipedia.org/wiki/Falcon_1 - Get information for all launches: `SPACEX::Launches.all` or `SPACEX::Launches.info` - Get information about a specific launch: `SPACEX::Launches.info('flight_number')` +- Get information on past launches: `SPACEX::Launches.past` +- Get information on the next launch: `SPACEX::Launches.next` +- Get the latest launch information: `SPACEX::Launches.latest` +- Get information on upcoming launches: `SPACEX::Launches.upcoming` This code snippet shows how to get information for a specific launch by flight number and list the fields: @@ -242,11 +246,7 @@ past_launches.last.rocket.first_stage.cores.first.land_success # true past_launches.last.launch_success # true ``` -- Get information on past launches: `SPACEX::Launches.past` -- Get information on the next launch: `SPACEX::Launches.next` -- Get the latest launch information: `SPACEX::Launches.latest` -- Get information on past launches: `SPACEX::Launches.past` -- Get information on upcoming launches: `SPACEX::Launches.upcoming` + The following code snippet shows the latest launch information and the data fields available on the Launch object: @@ -320,33 +320,6 @@ latest_launch.upcoming # false latest_launch.static_fire_date_utc # '2018-08-02T15:53:00.000Z' ``` -This code snippet shows how to get information for a specific launch by flight number and list the fields: -```ruby -require 'spacex' -launch_68 = SPACEX::Launches.info(68) - -launch_68.flight_number # 68 -launch_68.mission_name # 'Telstar 18V' -launch_68.rocket.rocket_name # 'Falcon 9' -launch_68.rocket.first_stage.cores.first.land_success # true -``` - -This code snippet shows how to get information on past launches: -```ruby -past_launches = SPACEX::Launches.past - -past_launches.first.flight_number # 1 -past_launches.first.mission_name # 'FalconSat' -past_launches.first.rocket.rocket_name # 'Falcon 1' -past_launches.first.launch_success # false - -past_launches.last.flight_number # 69 -past_launches.last.mission_name # 'SAOCOM 1A' -past_launches.last.rocket.rocket_name # 'Falcon 9' -past_launches.last.rocket.first_stage.cores.first.land_success # true -past_launches.last.launch_success # true -``` - This code snippet shows how to get information on upcoming launches: ```ruby upcoming_launches = SPACEX::Launches.upcoming From 4cd014b5fa984c1e3bc9055479f2ddb27f003939 Mon Sep 17 00:00:00 2001 From: Michael King Date: Fri, 2 Nov 2018 13:02:13 -0400 Subject: [PATCH 11/11] update README, remove duplicate examples --- README.md | 37 +++++-------------------------------- 1 file changed, 5 insertions(+), 32 deletions(-) diff --git a/README.md b/README.md index af289ad..adb8e3a 100644 --- a/README.md +++ b/README.md @@ -213,6 +213,10 @@ first_event.links['wikipedia'] # https://en.wikipedia.org/wiki/Falcon_1 - Get information for all launches: `SPACEX::Launches.all` or `SPACEX::Launches.info` - Get information about a specific launch: `SPACEX::Launches.info('flight_number')` +- Get information on past launches: `SPACEX::Launches.past` +- Get information on the next launch: `SPACEX::Launches.next` +- Get the latest launch information: `SPACEX::Launches.latest` +- Get information on upcoming launches: `SPACEX::Launches.upcoming` This code snippet shows how to get information for a specific launch by flight number and list the fields: @@ -242,11 +246,7 @@ past_launches.last.rocket.first_stage.cores.first.land_success # true past_launches.last.launch_success # true ``` -- Get information on past launches: `SPACEX::Launches.past` -- Get information on the next launch: `SPACEX::Launches.next` -- Get the latest launch information: `SPACEX::Launches.latest` -- Get information on past launches: `SPACEX::Launches.past` -- Get information on upcoming launches: `SPACEX::Launches.upcoming` + The following code snippet shows the latest launch information and the data fields available on the Launch object: @@ -320,33 +320,6 @@ latest_launch.upcoming # false latest_launch.static_fire_date_utc # '2018-08-02T15:53:00.000Z' ``` -This code snippet shows how to get information for a specific launch by flight number and list the fields: -```ruby -require 'spacex' -launch_68 = SPACEX::Launches.info(68) - -launch_68.flight_number # 68 -launch_68.mission_name # 'Telstar 18V' -launch_68.rocket.rocket_name # 'Falcon 9' -launch_68.rocket.first_stage.cores.first.land_success # true -``` - -This code snippet shows how to get information on past launches: -```ruby -past_launches = SPACEX::Launches.past - -past_launches.first.flight_number # 1 -past_launches.first.mission_name # 'FalconSat' -past_launches.first.rocket.rocket_name # 'Falcon 1' -past_launches.first.launch_success # false - -past_launches.last.flight_number # 69 -past_launches.last.mission_name # 'SAOCOM 1A' -past_launches.last.rocket.rocket_name # 'Falcon 9' -past_launches.last.rocket.first_stage.cores.first.land_success # true -past_launches.last.launch_success # true -``` - This code snippet shows how to get information on upcoming launches: ```ruby upcoming_launches = SPACEX::Launches.upcoming