7 |
8 |
9 | 
10 |
11 | An Open Source REST API of Rocket Launch telemetry
3 | 4 | 12 | 13 |
14 | 
15 |
Architecture
18 | 19 |
20 | 
21 |
|
95 | |[Starlink-18 First Stage Telemetry and Analysis](https://www.reddit.com/r/spacex/comments/ldkz7c/starlink18_first_stage_telemetry_and_analysis/)| My analysis of first stage telemetry of a SpaceX Starlink (SpaceX's internet constellation) launch|[Shahar603](https://github.com/shahar603)|
|
96 | |[Unplanned engine shutdown of Falcon 9 rocket](https://www.reddit.com/r/SpaceXLounge/comments/fkpb37/starlink5_telemetry_confirming_the_early_engine/)|Acceleration graph from LD API affirmed the space community suspicion of an unplanned engine shutdown during Falcon 9 ascent. Later confirmed by [Elon Musk on twitter](https://twitter.com/elonmusk/status/1240262636547100672)|[Shahar603](https://github.com/shahar603)|
|
97 | |[Webcast vs Simulation graph](https://twitter.com/flightclubio/status/1131794017606340608)|Used by trajectory creators on FlightClub.io to compare their simulations to the real telemetry|[u/TheVehicleDestroyer](https://www.reddit.com/user/thevehicledestroyer)|
|
98 | |[Aerodynamic Pressure animation](https://twitter.com/JcAsHcan/status/1188125678396493825)|An animation of the aerodynamic pressure(Q) during ascent on the AMOS-17 mission|[Jake Hannan](https://twitter.com/JcAsHcan)||
99 | |[Mission Creation](https://twitter.com/flightclubio/status/1344060720892166146)|A tools that builds a flight plan that matches the webcast telemetry in the API |[u/TheVehicleDestroyer](https://www.reddit.com/user/thevehicledestroyer)||
100 | |[Falcon Boosters' Entry Energy Comparison](https://www.reddit.com/r/spacex/comments/elzp52/falcon_boosters_entry_energy_comparison/)|A diagram that compares total energy of the Falcon boosters' reentry energy|[Shahar603](https://github.com/shahar603)||
101 |
102 |
103 |
104 | ## Apps and Clients
105 | Clients and Apps using Launch Dashboard API
106 |
107 | |Client|Description|Creator|
108 | |-----|-----|----|
109 | |[FlightClub.io](https://www2.flightclub.io/)|Rocket Launch Simulation and Visualization|[u/TheVehicleDestroyer](https://www.reddit.com/user/thevehicledestroyer)|
110 | |[.NET Launch Dashboard](https://github.com/Tearth/.NET-Launch-Dashboard)| .NET Wrapper for Launch Dashboard API|[Tearth](https://github.com/Tearth)
111 |
112 | ## Data Sources
113 | The Source of the data in the API
114 |
115 | |Launch Provider|Tool|Creator|
116 | |----|-----|-----|
117 | |SpaceX|[SpaceXtract](https://github.com/shahar603/SpaceXtract)|[Shahar603](https://github.com/shahar603)|
118 | |RocketLab|[SpaceXtract](https://github.com/shahar603/SpaceXtract)|[Shahar603](https://github.com/shahar603)|
119 | |Arianespace|[VideoTelemetryParser](https://github.com/Togusa09/VideoTelemetryParser)|[Hitura-Nobad](https://www.reddit.com/user/hitura-nobad/)|
120 |
121 |
122 |
--------------------------------------------------------------------------------
/src/app.js:
--------------------------------------------------------------------------------
1 | // Import packages
2 | const express = require("express");
3 | const mongoose = require("mongoose");
4 | const socketio = require("socket.io");
5 | const Redis = require("ioredis");
6 | // Import middleware
7 | const bodyParser = require("body-parser");
8 | const requestSplitterV1 = require("./middleware/v1/request_splitting");
9 | const requestSplitterV2 = require("./middleware/v2/request_splitting");
10 | const errorHandler = require("./middleware/error_handler");
11 | const filter = require("content-filter");
12 | // Live
13 | const live = require("./routes/v1/live");
14 | const info = require("./routes/info");
15 | // Import routes V1
16 | const launchesV1 = require("./routes/v1/launches");
17 | const rawV1 = require("./routes/v1/raw");
18 | const analysedV1 = require("./routes/v1/analysed");
19 | const eventsV1 = require("./routes/v1/events");
20 | const infoV1 = require("./routes/v1/info");
21 | const companyV1 = require("./routes/v1/company");
22 | // Import routes V2
23 | const launchesV2 = require("./routes/v2/launches");
24 | const rawV2 = require("./routes/v2/raw");
25 | const analysedV2 = require("./routes/v2/analysed");
26 | const eventsV2 = require("./routes/v2/events");
27 | const infoV2 = require("./routes/v2/info");
28 | const companyV2 = require("./routes/v2/company");
29 | // Authentication imports
30 | const confirmAuth = require("./middleware/confirm_auth");
31 | const authRoutes = require("./routes/auth-routes");
32 | const keys = require("./auth/keys");
33 | const passport = require("passport");
34 | const passportSetup = require("./auth/passport-setup");
35 | const cacheHelper = require("./helpers/cache_helper");
36 | const tokens = require("./auth/tokens");
37 | const jwt = require("jsonwebtoken");
38 | var morgan = require("morgan");
39 | process.setMaxListeners(0);
40 |
41 | global.REDIS_CONNECTION_STRING = keys.redis.redisConnectionString;
42 | global.CONNECTION_STRING = keys.mongodb.connectionString;
43 |
44 | // Create an express app
45 | const app = express();
46 |
47 |
48 |
49 | // create and connect redis client to Elasticache instance.
50 | if (cacheHelper.doCache()){
51 | global.REDIS_CLIENT = new Redis({
52 | port: 6379,
53 | host: global.REDIS_CONNECTION_STRING,
54 | reconnectOnError: function (err) {
55 | const targetError = "READONLY";
56 | if (err.message.slice(0, targetError.length) === targetError) {
57 | // Only reconnect when the error starts with "READONLY"
58 | return true; // or `return 1;`
59 | }
60 | }
61 | });
62 |
63 |
64 | // Print redis errors to the console
65 | global.REDIS_CLIENT.on("error", (err) => {
66 | console.log("Error " + err);
67 | });
68 |
69 | // Print redis connection to the console
70 | global.REDIS_CLIENT.on("connect", (err) => {
71 | console.log("Connected to Redis");
72 | });
73 | }
74 |
75 |
76 |
77 |
78 | // ######################### AUTHENTICATION TOKEN ###################
79 |
80 | // Initialize passport
81 | app.use(passport.initialize());
82 |
83 |
84 | // ##################### MIDDLEWARE #####################
85 |
86 | // Alllow post requests with a lot of telemetry
87 | app.use(bodyParser.json({limit: "10mb"}));
88 | // support parsing of application/x-www-form-urlencoded post data
89 | app.use(bodyParser.urlencoded({limit: "10mb", extended: true}));
90 | // Validate the input to prevent NoSQL injection
91 | app.use(filter());
92 | // If the user tries to modify the database, make sure he/she is authenticated
93 | app.use("*", confirmAuth);
94 | // Allow Cross Origin Requests
95 | app.use(function(req, res, next) {
96 | res.header("Access-Control-Allow-Origin", "*");
97 | res.header("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");
98 | next();
99 | });
100 |
101 |
102 |
103 |
104 | // Logging the request (without identifing details);
105 | app.use(morgan(function (tokens, req, res) {
106 | return [
107 | "[", tokens.date(req, res), "]",
108 | tokens.method(req, res),
109 | tokens.url(req, res),
110 | tokens.status(req, res),
111 | tokens.res(req, res, "content-length"), "-",
112 | tokens["response-time"](req, res), "ms"
113 | ].join(" ");
114 | }));
115 |
116 | // ##################### ROUTES #####################
117 |
118 | app.use("/", info);
119 |
120 | app.all("/v1/*", requestSplitterV1);
121 | // Use the routes we set up on routes/api.js
122 | app.use("/v1/company", companyV1);
123 | app.use("/v1/launches", launchesV1);
124 | app.use("/v1/raw", rawV1);
125 | app.use("/v1/analysed", analysedV1);
126 | app.use("/v1/events", eventsV1);
127 | app.use("/v1/live", live);
128 | app.use("/v1", infoV1);
129 |
130 | app.all("/v2/*", requestSplitterV2);
131 | // Use the routes we set up on routes/api.js
132 | app.use("/v2/company", companyV2);
133 | app.use("/v2/launches", launchesV2);
134 | app.use("/v2/raw", rawV2);
135 | app.use("/v2/analysed", analysedV2);
136 | app.use("/v2/events", eventsV2);
137 | app.use("/v2/live", live);
138 | app.use("/v2", infoV2);
139 |
140 | // set up authentiacation routes
141 | app.use("/auth", authRoutes);
142 |
143 |
144 | // ##################### ERROR HANDLING #####################
145 |
146 |
147 | // this is default in case of unmatched routes
148 | app.use(function(req, res) {
149 | throw {status: 404, message: `path "${req.path}" does not exist`};
150 | });
151 |
152 | // Promise rejection handling
153 | app.use(errorHandler);
154 |
155 |
156 | module.exports = app;
157 |
158 |
159 | (async function(){
160 | mongoose.connect(global.CONNECTION_STRING, {useNewUrlParser: true});
161 | tokens.setKeys();
162 |
163 | function setupLive(){
164 | // Start the server on port 3000
165 | const server = app.listen(process.env.PORT || 3000, () => {
166 | app.emit("ready");
167 | console.log("Running on port 3000");
168 | });
169 |
170 |
171 | const allowedEvents = ["raw", "analysed"];
172 | const io = socketio(server);
173 |
174 | io.on("connect", async function(socket){
175 | console.log("Made a connection", socket.id);
176 |
177 | try{
178 | const user = await jwt.verify(socket.handshake.query.access_token, tokens.pubKey, { algorithm: "RS256"});
179 | socket.user = user;
180 | }catch(ex){
181 | console.log(ex);
182 | }
183 |
184 |
185 |
186 | function registerEvent(event){
187 | socket.on(event, function(data) {
188 | if (Object.keys(global.LIVE_TELEMETRY).includes(event)){
189 | global.LIVE_TELEMETRY[event].push(data);
190 | socket.broadcast.to(event).emit(event, data);
191 | }
192 | });
193 | }
194 |
195 | socket.on("register", function(events) {
196 | if (!socket.user) return;
197 |
198 | events.forEach((event) => {
199 | if (allowedEvents.includes(event))
200 | registerEvent(event);
201 | });
202 | });
203 |
204 |
205 | socket.on("join", function(rooms) {
206 | rooms.forEach((room) => {
207 | if (allowedEvents.includes(room))
208 | socket.join(room);
209 | });
210 | });
211 |
212 | });
213 |
214 | }
215 | setupLive();
216 | })();
217 |
--------------------------------------------------------------------------------
/src/helpers/v1/telemetry_helper.js:
--------------------------------------------------------------------------------
1 | const _ = require("lodash");
2 | const s3Helper = require("./s3_helper");
3 | const mongoHelper = require("./mongo_helper");
4 |
5 | function eventsToStartEnd(events, modifiers){
6 | let start, end, eventTime;
7 |
8 | if (!events || !modifiers)
9 | return {};
10 |
11 | function eventToTime(eventsArray, event){
12 | // If event is not defined then return 'undefined'
13 | if(!event)
14 | return undefined;
15 |
16 | // If the 'event' is not a number then try to find the event
17 | if (_.isNaN(Number(event))){
18 | let res = _.find(eventsArray, {key: event});
19 |
20 | if (!res)
21 | return undefined;
22 |
23 | return res.time;
24 | }
25 |
26 | // 'event' is a number
27 | return Number(event);
28 | }
29 |
30 |
31 | // Get time values for "start", "end" and "eventTime"
32 | start = eventToTime(events, modifiers.start);
33 | end = eventToTime(events, modifiers.end);
34 | eventTime = eventToTime(events, modifiers.event);
35 |
36 | // Check the validity of "start", "end" and "eventTime"
37 | if (start === undefined && modifiers.start !== undefined)
38 | throw new Error("\"start\" has to a number or an event");
39 | else if (start === null && modifiers.start !== undefined)
40 | throw new Error(`event ${modifiers.start} of "start" is not set in the data`);
41 |
42 | if (end === undefined && modifiers.end !== undefined)
43 | throw new Error("\"end\" has to a number or an event");
44 | else if (end === null && modifiers.end !== undefined)
45 | throw new Error(`event ${modifiers.end} of "end" is not set in the data`);
46 |
47 | if (eventTime === undefined && modifiers.event !== undefined)
48 | throw new Error("\"event\" has to a number or an event");
49 | else if (eventTime === null && modifiers.event !== undefined)
50 | throw new Error(`event ${modifiers.event} of "event" is not set in the data`);
51 |
52 | if (start && end && start > end)
53 | throw new Error("\"end\" cannot be smaller than \"start\"");
54 |
55 |
56 | // Apply offset modifiers
57 | if (start !== undefined && modifiers.start_offset != undefined){
58 | start += modifiers.start_offset;
59 | }
60 | if (end !== undefined && modifiers.end_offset != undefined){
61 | end += modifiers.end_offset;
62 | }
63 | if (eventTime !== undefined && modifiers.event_offset != undefined){
64 | eventTime += modifiers.event_offset;
65 | }
66 |
67 | return {start: start, end: end, event: eventTime};
68 | }
69 |
70 | function cropTelemetry(telemetry, start, end ,event, eventWindow){
71 | eventWindow = eventWindow || 1;
72 |
73 | if (!telemetry || telemetry.length === 0)
74 | return [];
75 | if (_.isNil(start))
76 | start = telemetry[0].time;
77 | if (_.isNil(end))
78 | end = telemetry[telemetry.length - 1].time;
79 | if (!_.isNil(event))
80 | start = end = event;
81 |
82 |
83 | let startIndex = telemetry.findIndex(function(element) {
84 | return element.time >= start;
85 | });
86 |
87 | let endIndex = telemetry.findIndex(function(element) {
88 | return element.time > end;
89 | });
90 |
91 | // If start is after all the telemetry or
92 | // end is before all the telemetry
93 | if (startIndex === -1 || (start != end && telemetry[0].time > end))
94 | return [];
95 |
96 | if (endIndex === -1)
97 | endIndex = telemetry.length;
98 |
99 | if (startIndex < endIndex){
100 | // Interval between start and end
101 | return telemetry.slice(Math.max(0, startIndex), endIndex);
102 | }else{
103 | // Event
104 | let eventTelemetry = telemetry[startIndex];
105 |
106 | // Check the telemetry is close enough to the requested time (in the window)
107 | if (Math.abs(eventTelemetry.time - start) > eventWindow){
108 | // Telemetry is out of the window
109 | return [];
110 | }else{
111 | // Telemetry is in the window
112 | return [eventTelemetry];
113 | }
114 | }
115 | }
116 |
117 | function intervalTelemetry(telemetry, interval){
118 | if (_.isNil(telemetry) || telemetry.length === 0)
119 | return [];
120 |
121 | let filteredTelemetry = [telemetry[0]];
122 | let prevTime = telemetry[0].time;
123 |
124 | for(let i = 1; i < telemetry.length; i++){
125 | if (telemetry[i].time - prevTime >= interval){
126 | filteredTelemetry.push(telemetry[i]);
127 | prevTime = telemetry[i].time;
128 | }
129 | }
130 |
131 | return filteredTelemetry;
132 | }
133 |
134 | function getInterval(modifiers){
135 | let interval = 0;
136 |
137 | if (!_.isNil(modifiers.frame_rate) && modifiers.frame_rate != 0)
138 | interval = 1/modifiers.frame_rate;
139 |
140 | if (!_.isNil(modifiers.interval))
141 | interval = modifiers.interval;
142 |
143 | return interval;
144 | }
145 |
146 | function chooseStagesAndTelemetryRange(data, stage, start, end, event, eventWindow, interval){
147 | let out = [];
148 | let tmpTelemetry;
149 |
150 | for (let i = 0; i < data.length; i++){
151 | if (stage === undefined || stage === data[i].stage){
152 | tmpTelemetry = cropTelemetry(data[i].telemetry, start, end, event, eventWindow);
153 | tmpTelemetry = intervalTelemetry(tmpTelemetry, interval);
154 |
155 | out.push({
156 | stage: data[i].stage,
157 | telemetry: tmpTelemetry
158 | });
159 | }
160 | }
161 |
162 | return out;
163 | }
164 |
165 | // Get 'key' telemetry from the 'identifiers' and modified using 'modifiers'
166 | async function getTelemetry(key, company, identifiers, modifiers){
167 | if (!key || _.isEmpty(identifiers) || _.isNil(modifiers))
168 | throw {status: 404, message: "Not Found"};
169 |
170 | // Get the launch from the database
171 | let launchMetadata = await mongoHelper.findLaunchMetadata(company, identifiers);
172 |
173 | if (!launchMetadata){
174 | throw {status: 404, message: "Not Found"};
175 | }
176 |
177 | let events = await s3Helper.getFile(launchMetadata.events_path);
178 | let data;
179 |
180 | if (key === "raw")
181 | data = await s3Helper.getFile(launchMetadata.raw_path);
182 | else if (key === "analysed")
183 | data = await s3Helper.getFile(launchMetadata.analysed_path);
184 |
185 | if (!data)
186 | return undefined;
187 |
188 | let {start, end, event} = eventsToStartEnd(events, modifiers);
189 | let interval = getInterval(modifiers);
190 | return chooseStagesAndTelemetryRange(data,
191 | modifiers.stage,
192 | start,
193 | end,
194 | event,
195 | modifiers.event_window,
196 | interval);
197 | }
198 |
199 | function modifyData(rawData, analysedData, eventData, modifiers){
200 | let {start, end, event} = eventsToStartEnd(eventData, modifiers);
201 | let interval = getInterval(modifiers);
202 | rawData = chooseStagesAndTelemetryRange(rawData,
203 | modifiers.stage,
204 | start,
205 | end,
206 | event,
207 | modifiers.event_window,
208 | interval);
209 |
210 | analysedData = chooseStagesAndTelemetryRange(analysedData,
211 | modifiers.stage,
212 | start,
213 | end,
214 | event,
215 | modifiers.event_window,
216 | interval);
217 |
218 | return {raw: rawData, analysed: analysedData};
219 | }
220 |
221 | module.exports = {
222 | modifyData: modifyData,
223 | cropTelemetry: cropTelemetry,
224 | getTelemetry: getTelemetry
225 | };
226 |
--------------------------------------------------------------------------------
/src/helpers/v2/telemetry_helper.js:
--------------------------------------------------------------------------------
1 | const _ = require("lodash");
2 | const s3Helper = require("./s3_helper");
3 | const mongoHelper = require("./mongo_helper");
4 |
5 | function eventsToStartEnd(events, modifiers){
6 | let start, end, eventTime;
7 |
8 | if (!events || !modifiers)
9 | return {};
10 |
11 | function eventToTime(eventsArray, event){
12 | // If event is not defined then return 'undefined'
13 | if(!event)
14 | return undefined;
15 |
16 | // If the 'event' is not a number then try to find the event
17 | if (_.isNaN(Number(event))){
18 | let res = _.find(eventsArray, {key: event});
19 |
20 | if (!res)
21 | return undefined;
22 |
23 | return res.time;
24 | }
25 |
26 | // 'event' is a number
27 | return Number(event);
28 | }
29 |
30 |
31 | // Get time values for "start", "end" and "eventTime"
32 | start = eventToTime(events, modifiers.start);
33 | end = eventToTime(events, modifiers.end);
34 | eventTime = eventToTime(events, modifiers.event);
35 |
36 | // Check the validity of "start", "end" and "eventTime"
37 | if (start === undefined && modifiers.start !== undefined)
38 | throw new Error("\"start\" has to a number or an event");
39 | else if (start === null && modifiers.start !== undefined)
40 | throw new Error(`event ${modifiers.start} of "start" is not set in the data`);
41 |
42 | if (end === undefined && modifiers.end !== undefined)
43 | throw new Error("\"end\" has to a number or an event");
44 | else if (end === null && modifiers.end !== undefined)
45 | throw new Error(`event ${modifiers.end} of "end" is not set in the data`);
46 |
47 | if (eventTime === undefined && modifiers.event !== undefined)
48 | throw new Error("\"event\" has to a number or an event");
49 | else if (eventTime === null && modifiers.event !== undefined)
50 | throw new Error(`event ${modifiers.event} of "event" is not set in the data`);
51 |
52 | if (start && end && start > end)
53 | throw new Error("\"end\" cannot be smaller than \"start\"");
54 |
55 |
56 | // Apply offset modifiers
57 | if (start !== undefined && modifiers.start_offset != undefined){
58 | start += modifiers.start_offset;
59 | }
60 | if (end !== undefined && modifiers.end_offset != undefined){
61 | end += modifiers.end_offset;
62 | }
63 | if (eventTime !== undefined && modifiers.event_offset != undefined){
64 | eventTime += modifiers.event_offset;
65 | }
66 |
67 | return {start: start, end: end, event: eventTime};
68 | }
69 |
70 | function cropTelemetry(telemetry, start, end ,event, eventWindow){
71 | eventWindow = eventWindow || 1;
72 |
73 | if (!telemetry || telemetry.length === 0)
74 | return [];
75 | if (_.isNil(start))
76 | start = telemetry[0].time;
77 | if (_.isNil(end))
78 | end = telemetry[telemetry.length - 1].time;
79 | if (!_.isNil(event))
80 | start = end = event;
81 |
82 |
83 | let startIndex = telemetry.findIndex(function(element) {
84 | return element.time >= start;
85 | });
86 |
87 | let endIndex = telemetry.findIndex(function(element) {
88 | return element.time > end;
89 | });
90 |
91 | // If start is after all the telemetry or
92 | // end is before all the telemetry
93 | if (startIndex === -1 || (start != end && telemetry[0].time > end))
94 | return [];
95 |
96 | if (endIndex === -1)
97 | endIndex = telemetry.length;
98 |
99 | if (startIndex < endIndex){
100 | // Interval between start and end
101 | return telemetry.slice(Math.max(0, startIndex), endIndex);
102 | }else{
103 | // Event
104 | let eventTelemetry = telemetry[startIndex];
105 |
106 | // Check the telemetry is close enough to the requested time (in the window)
107 | if (Math.abs(eventTelemetry.time - start) > eventWindow){
108 | // Telemetry is out of the window
109 | return [];
110 | }else{
111 | // Telemetry is in the window
112 | return [eventTelemetry];
113 | }
114 | }
115 | }
116 |
117 | function intervalTelemetry(telemetry, interval){
118 | if (_.isNil(telemetry) || telemetry.length === 0)
119 | return [];
120 |
121 | let filteredTelemetry = [telemetry[0]];
122 | let prevTime = telemetry[0].time;
123 |
124 | for(let i = 1; i < telemetry.length; i++){
125 | if (telemetry[i].time - prevTime >= interval){
126 | filteredTelemetry.push(telemetry[i]);
127 | prevTime = telemetry[i].time;
128 | }
129 | }
130 |
131 | return filteredTelemetry;
132 | }
133 |
134 | function getInterval(modifiers){
135 | let interval = 0;
136 |
137 | if (!_.isNil(modifiers.frame_rate) && modifiers.frame_rate != 0)
138 | interval = 1/modifiers.frame_rate;
139 |
140 | if (!_.isNil(modifiers.interval))
141 | interval = modifiers.interval;
142 |
143 | return interval;
144 | }
145 |
146 | function chooseStagesAndTelemetryRange(data, stage, start, end, event, eventWindow, interval){
147 | let out = [];
148 | let tmpTelemetry;
149 |
150 | for (let i = 0; i < data.length; i++){
151 | if (stage === undefined || stage === data[i].stage){
152 | tmpTelemetry = cropTelemetry(data[i].telemetry, start, end, event, eventWindow);
153 | tmpTelemetry = intervalTelemetry(tmpTelemetry, interval);
154 |
155 | out.push({
156 | stage: data[i].stage,
157 | telemetry: tmpTelemetry
158 | });
159 | }
160 | }
161 |
162 | return out;
163 | }
164 |
165 | // Get 'key' telemetry from the 'identifiers' and modified using 'modifiers'
166 | async function getTelemetry(key, company, identifiers, modifiers){
167 | if (!key || _.isEmpty(identifiers) || _.isNil(modifiers))
168 | throw {status: 404, message: "Not Found"};
169 |
170 | // Get the launch from the database
171 | let launchMetadata = await mongoHelper.findLaunchMetadata(company, identifiers);
172 |
173 | if (!launchMetadata){
174 | throw {status: 404, message: "Not Found"};
175 | }
176 |
177 | let events = await s3Helper.getFile(launchMetadata.events_path);
178 | let data;
179 |
180 | if (key === "raw")
181 | data = await s3Helper.getFile(launchMetadata.raw_path);
182 | else if (key === "analysed")
183 | data = await s3Helper.getFile(launchMetadata.analysed_path);
184 |
185 | if (!data)
186 | return undefined;
187 |
188 | let {start, end, event} = eventsToStartEnd(events, modifiers);
189 | let interval = getInterval(modifiers);
190 | return chooseStagesAndTelemetryRange(data,
191 | modifiers.stage,
192 | start,
193 | end,
194 | event,
195 | modifiers.event_window,
196 | interval);
197 | }
198 |
199 | function modifyData(rawData, analysedData, eventData, modifiers){
200 | let {start, end, event} = eventsToStartEnd(eventData, modifiers);
201 | let interval = getInterval(modifiers);
202 | rawData = chooseStagesAndTelemetryRange(rawData,
203 | modifiers.stage,
204 | start,
205 | end,
206 | event,
207 | modifiers.event_window,
208 | interval);
209 |
210 | analysedData = chooseStagesAndTelemetryRange(analysedData,
211 | modifiers.stage,
212 | start,
213 | end,
214 | event,
215 | modifiers.event_window,
216 | interval);
217 |
218 | return {raw: rawData, analysed: analysedData};
219 | }
220 |
221 | module.exports = {
222 | modifyData: modifyData,
223 | cropTelemetry: cropTelemetry,
224 | getTelemetry: getTelemetry
225 | };
226 |
--------------------------------------------------------------------------------
/test/other/routes/raw_test.js:
--------------------------------------------------------------------------------
1 | // Import assert to unit test the database
2 | const assert = require("assert");
3 | const controller = require("../../src/controllers/raw");
4 | const _ = require("lodash");
5 |
6 | /*
7 |
8 |
9 | // Create a series of tests
10 | describe("Testing the /raw endpoint is returning the correct data", function(){
11 |
12 | it("raw/ with a valid flight_number", function(done){
13 | let req = {
14 | identifiers: {
15 | flight_number: 25
16 | },
17 | modifiers: {}
18 | };
19 |
20 | let res = {
21 | send: function(raw) {
22 | assert(raw.length === 1);
23 | assert(Object.keys(raw[0]).length === 2);
24 | assert(raw[0].stage === 2);
25 | assert(raw[0].telemetry !== undefined);
26 | done();
27 | },
28 | next: function(err){
29 | assert(false);
30 | done();
31 | }
32 | };
33 |
34 | controller.getOne(req, res, function(err){
35 | assert(false);
36 | done();
37 | });
38 | });
39 |
40 |
41 |
42 |
43 | it("raw/ with an empty identifiers object throws a 404 error", function(done){
44 | let req = {
45 | identifiers: {},
46 | modifiers: {}
47 | };
48 |
49 | let res = {
50 | send: function(raw) {
51 | assert(false);
52 | done();
53 | },
54 | next: function(err){
55 | assert(false);
56 | done();
57 | }
58 | };
59 |
60 | controller.getOne(req, res, function(err){
61 | assert(err !== undefined);
62 | assert(err.status === 404);
63 | done();
64 | });
65 | });
66 |
67 |
68 |
69 |
70 | it("raw/ with conflicting flight_number and mission_id throws a 404 error", function(done){
71 | let req = {
72 | identifiers: {
73 | flight_number: 45,
74 | mission_id: "not crs-12"
75 | },
76 | modifiers: {}
77 | };
78 |
79 | let res = {
80 | send: function(raw) {
81 | assert(false);
82 | done();
83 | },
84 | next: function(err){
85 | assert(false);
86 | done();
87 | }
88 | };
89 |
90 | controller.getOne(req, res, function(err){
91 | assert(err !== undefined);
92 | assert(err.status === 404);
93 | done();
94 | });
95 | });
96 |
97 |
98 |
99 |
100 | it("raw/ with a valid flight_number, start and end numeric values", function(done){
101 | let req = {
102 | identifiers: {
103 | flight_number: 45
104 | },
105 | modifiers: {
106 | start: 60,
107 | end: 70,
108 | }
109 | };
110 |
111 | let res = {
112 | send: function(raw) {
113 | assert(raw.length === 2);
114 | assert(Object.keys(raw[0]).length === 2);
115 | assert(raw[0].stage === 1);
116 | assert(raw[0].telemetry !== undefined);
117 | raw[0].telemetry.forEach((val) => {
118 | assert(val.time >= 60);
119 | assert(val.time <= 70);
120 | });
121 | done();
122 | },
123 | next: function(err){
124 | assert(false);
125 | done();
126 | }
127 | };
128 |
129 | controller.getOne(req, res, function(err){
130 | assert(false);
131 | done();
132 | });
133 | });
134 |
135 |
136 |
137 |
138 | it("raw/ with a valid flight_number, start and end numeric values but start is negative", function(done){
139 | let req = {
140 | identifiers: {
141 | flight_number: 45
142 | },
143 | modifiers: {
144 | start: -5,
145 | end: 70,
146 | }
147 | };
148 |
149 | let res = {
150 | send: function(raw) {
151 | assert(raw.length === 2);
152 | assert(Object.keys(raw[0]).length === 2);
153 | assert(raw[0].stage === 1);
154 | assert(raw[0].telemetry !== undefined && raw[0].telemetry.length > 0);
155 | assert(raw[1].telemetry !== undefined && raw[1].telemetry.length === 0);
156 | raw[0].telemetry.forEach((val) => {
157 | assert(val.time >= -5);
158 | assert(val.time <= 70);
159 | });
160 | done();
161 | },
162 | next: function(err){
163 | assert(false);
164 | done();
165 | }
166 | };
167 |
168 | controller.getOne(req, res, function(err){
169 | assert(false);
170 | done();
171 | });
172 | });
173 |
174 |
175 |
176 |
177 | it("raw/ with a valid flight_number but start and end are bigger than the end of the telemetry", function(done){
178 | let req = {
179 | identifiers: {
180 | flight_number: 45
181 | },
182 | modifiers: {
183 | start: 100000,
184 | end: 1000000,
185 | }
186 | };
187 |
188 | let res = {
189 | send: function(raw) {
190 | assert(raw.length === 2);
191 | assert(Object.keys(raw[0]).length === 2);
192 | assert(raw[0].stage === 1);
193 | assert(raw[0].telemetry !== undefined);
194 | raw.forEach((val) => assert(val.telemetry.length === 0));
195 | done();
196 | },
197 | next: function(err){
198 | assert(false);
199 | done();
200 | }
201 | };
202 |
203 | controller.getOne(req, res, function(err){
204 | assert(false);
205 | done();
206 | });
207 | });
208 |
209 |
210 |
211 |
212 | it("raw/ with a valid flight_number, start and end are events", function(done){
213 | let req = {
214 | identifiers: {
215 | flight_number: 45
216 | },
217 | modifiers: {
218 | start: "boostback_start",
219 | end: "boostback_end",
220 | }
221 | };
222 |
223 | let res = {
224 | send: function(raw) {
225 | assert(raw.length === 2);
226 | assert(Object.keys(raw[0]).length === 2);
227 | assert(raw[0].stage === 1);
228 | assert(raw[0].telemetry !== undefined);
229 | raw[0].telemetry.forEach((val) => {
230 | assert(val.time >= 166.032);
231 | assert(val.time <= 211.978);
232 | });
233 | done();
234 | },
235 | next: function(err){
236 | assert(false);
237 | done();
238 | }
239 | };
240 |
241 | controller.getOne(req, res, function(err){
242 | assert(false);
243 | done();
244 | });
245 | });
246 |
247 |
248 |
249 |
250 | it("raw/ with valid flight_number but with an invalid event in start", function(done){
251 | let req = {
252 | identifiers: {
253 | flight_number: 45,
254 | },
255 | modifiers: {
256 | start: "abc"
257 | }
258 | };
259 |
260 | let res = {
261 | send: function(raw) {
262 | assert(false);
263 | done();
264 | },
265 | next: function(err){
266 | assert(false);
267 | done();
268 | }
269 | };
270 |
271 | controller.getOne(req, res, function(err){
272 | assert(err !== undefined);
273 | done();
274 | });
275 | });
276 |
277 |
278 |
279 | it("raw/ with a valid flight_number and event", function(done){
280 | let req = {
281 | identifiers: {
282 | flight_number: 45
283 | },
284 | modifiers: {
285 | event: "boostback_start",
286 | }
287 | };
288 |
289 | let res = {
290 | send: function(raw) {
291 | assert(raw.length === 2);
292 | assert(Object.keys(raw[0]).length === 2);
293 | assert(raw[0].stage === 1);
294 | assert(raw[0].telemetry !== undefined);
295 | assert(raw[0].telemetry.length === 1);
296 | assert(_.isEqual(raw[0].telemetry[0].toJSON(), { time: 166.032, velocity: 1524.444, altitude: 80.9 }));
297 | done();
298 | },
299 | next: function(err){
300 |
301 | assert(false);
302 | done();
303 | }
304 | };
305 |
306 | controller.getOne(req, res, function(err){
307 |
308 | assert(false);
309 | done();
310 | });
311 | });
312 |
313 |
314 |
315 |
316 |
317 | it("raw/ with a valid flight_number and an invalid event should return an error", function(done){
318 | let req = {
319 | identifiers: {
320 | flight_number: 45
321 | },
322 | modifiers: {
323 | event: "not a real event",
324 | }
325 | };
326 |
327 | let res = {
328 | send: function(raw) {
329 | assert(false);
330 | done();
331 | },
332 | next: function(err){
333 |
334 | assert(false);
335 | done();
336 | }
337 | };
338 |
339 | controller.getOne(req, res, function(err){
340 |
341 | assert(err !== undefined);
342 | done();
343 | });
344 | });
345 |
346 |
347 |
348 |
349 | it("raw/ with a valid flight_number and event = null should return an error", function(done){
350 | let req = {
351 | identifiers: {
352 | flight_number: 45
353 | },
354 | modifiers: {
355 | event: null,
356 | }
357 | };
358 |
359 | let res = {
360 | send: function(raw) {
361 | assert(false);
362 | done();
363 | },
364 | next: function(err){
365 | assert(false);
366 | done();
367 | }
368 | };
369 |
370 | controller.getOne(req, res, function(err){
371 | assert(true);
372 | done();
373 | });
374 | });
375 |
376 | });
377 |
378 |
379 | */
380 |
--------------------------------------------------------------------------------
/src/controllers/v1/launches.js:
--------------------------------------------------------------------------------
1 | const Company = require("../../models/v1/company");
2 | const s3Helper = require("../../helpers/v1/s3_helper");
3 | const mongoHelper = require("../../helpers/v1/mongo_helper");
4 | const _ = require("lodash");
5 | const { checkIdentifiers } = require("../../middleware/v1/validator");
6 | const company = require("./company");
7 | const {modifyData} = require("../../helpers/v1/telemetry_helper");
8 |
9 |
10 | async function exists(company_id, identifiers){
11 | return await mongoHelper.findLaunchMetadata(company_id, identifiers) != null;
12 | }
13 |
14 |
15 |
16 |
17 | function findLaunch(companies, launch_library_id){
18 | for(let company of companies){
19 | for(let launch of company.launches) {
20 | if(launch_library_id === launch.launch_library_id){
21 | return {company: company, launch: launch};
22 | }
23 | }
24 | }
25 |
26 | return {company: null, launch: null};
27 | }
28 |
29 |
30 | module.exports = {
31 | // Get information about launches from the database
32 | info: async function getInfo(req, res, next){
33 | try{
34 | // Get all launches
35 | if (_.isEmpty(req.identifiers)){
36 | let result = await Company.findOne({company_id: req.params.company}, "launches.mission_id launches.name launches.flight_number launches.launch_library_id");
37 |
38 | if (!result)
39 | throw {status: 404, message: "Not Found"};
40 |
41 | res.send(result.launches.sort((elm1, elm2) => elm1.flight_number - elm2.flight_number));
42 | }
43 | // Get a specific launch
44 | else{
45 | let result = await mongoHelper.findLaunchMetadata(req.params.company, req.identifiers);
46 |
47 | if (!result)
48 | throw {status: 404, message: "Not Found"};
49 |
50 | res.send({
51 | mission_id: result.mission_id,
52 | name: result.name,
53 | flight_number: result.flight_number,
54 | launch_library_id: result.launch_library_id
55 | });
56 | }
57 | }catch(ex){
58 | next(ex);
59 | }
60 | },
61 |
62 |
63 |
64 |
65 | getLaunchFromLaunchLibraryProvider: async function(req, res, next){
66 | try{
67 | if(!req.identifiers.launch_library_id){
68 | throw new Error("Missing \"launch_library_id\" or \"ccompany\" parameters");
69 | }
70 |
71 | const companies = await Company.find({});
72 | const {company, launch} = findLaunch(companies, req.identifiers.launch_library_id);
73 |
74 | if (!launch){
75 | next({status: 404, message: `Launch with launch_library_id: ${req.identifiers.launch_library_id} doesn't exists`});
76 | return;
77 | }
78 |
79 | let result = await mongoHelper.findLaunchMetadata(company.company_id, {launch_library_id: launch.launch_library_id});
80 |
81 | // If no launch was found return a "Not Found" error
82 | if (!result){
83 | next({status: 404, message: "Not Found"});
84 | return;
85 | }
86 |
87 | // Get the telemetry
88 | let { rawData, analysedData, eventData } = await s3Helper.getOneLaunch(result);
89 |
90 | if (!rawData || !analysedData || !eventData)
91 | throw new Error("Telemetry data is unavailable (even thought it should be)\nPlease report this issue on the Launch Dashboard API GitHub Repository");
92 |
93 | const {raw, analysed} = modifyData(rawData, analysedData, eventData, req.modifiers);
94 |
95 | // box the metadata and telemetry and send it
96 | res.send(
97 | {
98 | mission_id: result.mission_id,
99 | name: result.name,
100 | flight_number: result.flight_number,
101 | launch_library_id: result.launch_library_id,
102 | raw: raw,
103 | analysed: analysed,
104 | events: eventData
105 | }
106 | );
107 | }catch(ex){
108 | next(ex);
109 | }
110 | },
111 |
112 |
113 | // Get all the available data about a specific launch
114 | getLaunches: async function(req, res, next){
115 | if(!await company.exists(req.params.company)){
116 | next({status: 404, message: `Company "${req.params.company}" is not found`});
117 | return;
118 | }
119 |
120 | // Get all launches
121 | if (_.isEmpty(req.identifiers)){
122 | try{
123 | let result = await Company.findOne({company_id: req.params.company}, "launches.mission_id launches.name launches.flight_number launches.launch_library_id");
124 |
125 | if (!result)
126 | throw {status: 404, message: "Not Found`"};
127 |
128 | res.send(result.launches.sort((elm1, elm2) => elm1.flight_number - elm2.flight_number));
129 | }catch(ex){
130 | next(ex);
131 | }
132 |
133 | }else if (checkIdentifiers(req, res, async () => {
134 | try{
135 | let result = await mongoHelper.findLaunchMetadata(req.params.company, req.identifiers);
136 |
137 | // If no launch was found return a "Not Found" error
138 | if (!result){
139 | next({status: 404, message: "Not Found"});
140 | return;
141 | }
142 |
143 | // Get the telemetry
144 | let { rawData, analysedData, eventData } = await s3Helper.getOneLaunch(result);
145 |
146 | if (!rawData || !analysedData || !eventData)
147 | throw new Error("Telemetry data is unavailable (even thought it should be)\nPlease report this issue on the Launch Dashboard API GitHub Repository");
148 |
149 | const {raw, analysed} = modifyData(rawData, analysedData, eventData, req.modifiers);
150 |
151 | // box the metadata and telemetry and send it
152 | res.send(
153 | {
154 | mission_id: result.mission_id,
155 | name: result.name,
156 | flight_number: result.flight_number,
157 | launch_library_id: result.launch_library_id,
158 | raw: raw,
159 | analysed: analysed,
160 | events: eventData
161 | }
162 | );
163 | }catch(ex){
164 | next(ex);
165 | }
166 | }));
167 | },
168 |
169 |
170 | getLatestLaunch: async function(req, res, next){
171 | if(!await company.exists(req.params.company)){
172 | next({status: 404, message: `Company "${req.params.company}" is not found`});
173 | return;
174 | }
175 |
176 |
177 | try{
178 | const flight_numbers = await Company.findOne({company_id: req.params.company}, "launches.flight_number");
179 |
180 | if (flight_numbers.length === 0)
181 | throw new Error(`No launches found for ${req.params.company}`);
182 |
183 |
184 | // Inefficent but easy in JS
185 | const launches = flight_numbers.launches.sort((elm1, elm2) => elm1.flight_number - elm2.flight_number);
186 | const result = await mongoHelper.findLaunchMetadata(req.params.company, {flight_number: launches[launches.length-1].flight_number});
187 |
188 | // If no launch was found return a "Not Found" error
189 | if (!result){
190 | next({status: 404, message: "Not Found"});
191 | return;
192 | }
193 |
194 | // Get the telemetry
195 | let { rawData, analysedData, eventData } = await s3Helper.getOneLaunch(result);
196 |
197 | if (!rawData || !analysedData || !eventData)
198 | throw new Error("Telemetry data is unavailable (even thought it should be)\nPlease report this issue on the Launch Dashboard API GitHub Repository");
199 |
200 | const {raw, analysed} = modifyData(rawData, analysedData, eventData, req.modifiers);
201 |
202 | // box the metadata and telemetry and send it
203 | res.send(
204 | {
205 | mission_id: result.mission_id,
206 | name: result.name,
207 | flight_number: result.flight_number,
208 | launch_library_id: result.launch_library_id,
209 | raw: raw,
210 | analysed: analysed,
211 | events: eventData
212 | }
213 | );
214 | }catch(ex){
215 | next(ex);
216 | }
217 | },
218 |
219 |
220 | // Add a launch to the database
221 | addOne: async function(req, res, next){
222 | try{
223 | // If the company doesn't exist or if the launch already exists throw an error
224 | if(!await company.exists(req.body.company_id))
225 | throw new Error(`Company "${req.body.company_id}" doesn't exists`);
226 |
227 | if (await exists(req.body.company_id, {flight_number: req.body.flight_number}))
228 | throw new Error(`Launch "${req.body.mission_id}" already exists`);
229 |
230 |
231 | // Put the telemetry in storage
232 | let launchMetadata = await s3Helper.addOneLaunch(req.body);
233 |
234 | // Put the metadata in the database
235 | res.send(
236 | mongoHelper.addLaunchMetadata(req.body.company_id, launchMetadata)
237 | );
238 | }catch(e){
239 | next(e);
240 | }
241 | },
242 |
243 |
244 |
245 | updateOne: async function(req, res, next){
246 | // Update the telemetry in storage
247 | let launchMetadata = await s3Helper.updateOneLaunch(req.body);
248 |
249 | if (launchMetadata)
250 | throw {status: 500, message: "Failed to update launch"};
251 |
252 | // Update the metadata in the database
253 | res.send(
254 | await mongoHelper.updateOneLaunch(req.identifiers, launchMetadata)
255 | );
256 | },
257 |
258 |
259 | deleteOne: async function(req, res, next){
260 | if (!req.params.company || _.isEmpty(req.identifiers)){
261 | throw new Error("Missing \"flight_number\", \"mission_id\" or \"launch_library_id\"");
262 | }
263 | // Get launch file name (key) from db
264 | let launch = await mongoHelper.findLaunchMetadata(req.params.company, req.identifiers);
265 |
266 | if (!launch){
267 | next({status: 404, message: "Not Found"});
268 | return;
269 | }
270 |
271 | if (!await mongoHelper.deleteLaunchMetadata(req.params.company, req.identifiers)){
272 | next({status: 500, message: "Failed to delete launch"});
273 | return;
274 | }
275 |
276 | await s3Helper.deleteOneLaunch(launch);
277 |
278 | res.send(launch);
279 | },
280 |
281 |
282 |
283 | };
284 |
--------------------------------------------------------------------------------
/src/controllers/v2/launches.js:
--------------------------------------------------------------------------------
1 | const Company = require("../../models/v2/company");
2 | const s3Helper = require("../../helpers/v2/s3_helper");
3 | const mongoHelper = require("../../helpers/v2/mongo_helper");
4 | const _ = require("lodash");
5 | const { checkIdentifiers } = require("../../middleware/v2/validator");
6 | const company = require("./company");
7 | const {modifyData} = require("../../helpers/v2/telemetry_helper");
8 |
9 | async function exists(company_id, identifiers){
10 | return await mongoHelper.findLaunchMetadata(company_id, identifiers) != null;
11 | }
12 |
13 | function findLaunch(companies, launch_library_2_id){
14 | for(let company of companies){
15 | for(let launch of company.launches) {
16 | if(launch_library_2_id === launch.launch_library_2_id){
17 | return {company: company, launch: launch};
18 | }
19 | }
20 | }
21 |
22 | return {company: null, launch: null};
23 | }
24 |
25 | module.exports = {
26 | // Get information about launches from the database
27 | info: async function getInfo(req, res, next){
28 | try{
29 | // Get all launches
30 | if (_.isEmpty(req.identifiers)){
31 | let result = await Company.findOne({company_id: req.params.company}, "launches.mission_id launches.name launches.flight_number launches.launch_library_2_id");
32 |
33 | if (!result)
34 | throw {status: 404, message: "Not Found"};
35 |
36 | res.send(result.launches.sort((elm1, elm2) => elm1.flight_number - elm2.flight_number));
37 | }
38 | // Get a specific launch
39 | else{
40 | let result = await mongoHelper.findLaunchMetadata(req.params.company, req.identifiers);
41 |
42 | if (!result)
43 | throw {status: 404, message: "Not Found"};
44 |
45 | res.send({
46 | mission_id: result.mission_id,
47 | name: result.name,
48 | flight_number: result.flight_number,
49 | launch_library_2_id: result.launch_library_2_id
50 | });
51 | }
52 | }catch(ex){
53 | next(ex);
54 | }
55 | },
56 |
57 |
58 |
59 |
60 | getLaunchFromLaunchLibraryProvider: async function(req, res, next){
61 | try{
62 | if(!req.identifiers.launch_library_2_id){
63 | throw new Error("Missing \"launch_library_2_id\" or \"ccompany\" parameters");
64 | }
65 |
66 | const companies = await Company.find({});
67 | const {company, launch} = findLaunch(companies, req.identifiers.launch_library_2_id);
68 |
69 | if (!launch){
70 | next({status: 404, message: `Launch with launch_library_2_id: ${req.identifiers.launch_library_2_id} doesn't exists`});
71 | return;
72 | }
73 |
74 | let result = await mongoHelper.findLaunchMetadata(company.company_id, {launch_library_2_id: launch.launch_library_2_id});
75 |
76 | // If no launch was found return a "Not Found" error
77 | if (!result){
78 | next({status: 404, message: "Not Found"});
79 | return;
80 | }
81 |
82 | // Get the telemetry
83 | let { rawData, analysedData, eventData } = await s3Helper.getOneLaunch(result);
84 |
85 | if (!rawData || !analysedData || !eventData)
86 | throw new Error("Telemetry data is unavailable (even thought it should be)\nPlease report this issue on the Launch Dashboard API GitHub Repository");
87 |
88 | const {raw, analysed} = modifyData(rawData, analysedData, eventData, req.modifiers);
89 |
90 | // box the metadata and telemetry and send it
91 | res.send(
92 | {
93 | mission_id: result.mission_id,
94 | name: result.name,
95 | flight_number: result.flight_number,
96 | launch_library_2_id: result.launch_library_2_id,
97 | raw: raw,
98 | analysed: analysed,
99 | events: eventData
100 | }
101 | );
102 | }catch(ex){
103 | next(ex);
104 | }
105 | },
106 |
107 |
108 | // Get all the available data about a specific launch
109 | getLaunches: async function(req, res, next){
110 | if(!await company.exists(req.params.company)){
111 | next({status: 404, message: `Company "${req.params.company}" is not found`});
112 | return;
113 | }
114 |
115 | // Get all launches
116 | if (_.isEmpty(req.identifiers)){
117 | try{
118 | let result = await Company.findOne({company_id: req.params.company}, "launches.mission_id launches.name launches.flight_number launches.launch_library_2_id");
119 |
120 | if (!result)
121 | throw {status: 404, message: "Not Found`"};
122 |
123 | res.send(result.launches.sort((elm1, elm2) => elm1.flight_number - elm2.flight_number));
124 | }catch(ex){
125 | next(ex);
126 | }
127 |
128 | }else if (checkIdentifiers(req, res, async () => {
129 | try{
130 | let result = await mongoHelper.findLaunchMetadata(req.params.company, req.identifiers);
131 |
132 | // If no launch was found return a "Not Found" error
133 | if (!result){
134 | next({status: 404, message: "Not Found"});
135 | return;
136 | }
137 |
138 | // Get the telemetry
139 | let { rawData, analysedData, eventData } = await s3Helper.getOneLaunch(result);
140 |
141 | if (!rawData || !analysedData || !eventData)
142 | throw new Error("Telemetry data is unavailable (even thought it should be)\nPlease report this issue on the Launch Dashboard API GitHub Repository");
143 |
144 | const {raw, analysed} = modifyData(rawData, analysedData, eventData, req.modifiers);
145 |
146 | // box the metadata and telemetry and send it
147 | res.send(
148 | {
149 | mission_id: result.mission_id,
150 | name: result.name,
151 | flight_number: result.flight_number,
152 | launch_library_2_id: result.launch_library_2_id,
153 | raw: raw,
154 | analysed: analysed,
155 | events: eventData
156 | }
157 | );
158 | }catch(ex){
159 | next(ex);
160 | }
161 | }));
162 | },
163 |
164 |
165 | getLatestLaunch: async function(req, res, next){
166 | if(!await company.exists(req.params.company)){
167 | next({status: 404, message: `Company "${req.params.company}" is not found`});
168 | return;
169 | }
170 |
171 |
172 | try{
173 | const flight_numbers = await Company.findOne({company_id: req.params.company}, "launches.flight_number");
174 |
175 | if (flight_numbers.length === 0)
176 | throw new Error(`No launches found for ${req.params.company}`);
177 |
178 |
179 | // Inefficent but easy in JS
180 | const launches = flight_numbers.launches.sort((elm1, elm2) => elm1.flight_number - elm2.flight_number);
181 | const result = await mongoHelper.findLaunchMetadata(req.params.company, {flight_number: launches[launches.length-1].flight_number});
182 |
183 | // If no launch was found return a "Not Found" error
184 | if (!result){
185 | next({status: 404, message: "Not Found"});
186 | return;
187 | }
188 |
189 | // Get the telemetry
190 | let { rawData, analysedData, eventData } = await s3Helper.getOneLaunch(result);
191 |
192 | if (!rawData || !analysedData || !eventData)
193 | throw new Error("Telemetry data is unavailable (even thought it should be)\nPlease report this issue on the Launch Dashboard API GitHub Repository");
194 |
195 | const {raw, analysed} = modifyData(rawData, analysedData, eventData, req.modifiers);
196 |
197 | // box the metadata and telemetry and send it
198 | res.send(
199 | {
200 | mission_id: result.mission_id,
201 | name: result.name,
202 | flight_number: result.flight_number,
203 | launch_library_2_id: result.launch_library_2_id,
204 | raw: raw,
205 | analysed: analysed,
206 | events: eventData
207 | }
208 | );
209 | }catch(ex){
210 | next(ex);
211 | }
212 | },
213 |
214 |
215 | // Add a launch to the database
216 | addOne: async function(req, res, next){
217 | try{
218 | // If the company doesn't exist or if the launch already exists throw an error
219 | if(!await company.exists(req.body.company_id))
220 | throw new Error(`Company "${req.body.company_id}" doesn't exists`);
221 |
222 | if (await exists(req.body.company_id, {flight_number: req.body.flight_number}))
223 | throw new Error(`Launch "${req.body.mission_id}" already exists`);
224 |
225 |
226 | // Put the telemetry in storage
227 | let launchMetadata = await s3Helper.addOneLaunch(req.body);
228 |
229 | // Put the metadata in the database
230 | res.send(
231 | mongoHelper.addLaunchMetadata(req.body.company_id, launchMetadata)
232 | );
233 | }catch(e){
234 | next(e);
235 | }
236 | },
237 |
238 |
239 |
240 | updateOne: async function(req, res, next){
241 | // Update the telemetry in storage
242 | let launchMetadata = await s3Helper.updateOneLaunch(req.body);
243 |
244 | if (launchMetadata)
245 | throw {status: 500, message: "Failed to update launch"};
246 |
247 | // Update the metadata in the database
248 | res.send(
249 | await mongoHelper.updateOneLaunch(req.identifiers, launchMetadata)
250 | );
251 | },
252 |
253 |
254 | deleteOne: async function(req, res, next){
255 | if (!req.params.company || _.isEmpty(req.identifiers)){
256 | throw new Error("Missing \"flight_number\", \"mission_id\" or \"launch_library_2_id\"");
257 | }
258 | // Get launch file name (key) from db
259 | let launch = await mongoHelper.findLaunchMetadata(req.params.company, req.identifiers);
260 |
261 | if (!launch){
262 | next({status: 404, message: "Not Found"});
263 | return;
264 | }
265 |
266 | if (!await mongoHelper.deleteLaunchMetadata(req.params.company, req.identifiers)){
267 | next({status: 500, message: "Failed to delete launch"});
268 | return;
269 | }
270 |
271 | await s3Helper.deleteOneLaunch(launch);
272 |
273 | res.send(launch);
274 | },
275 |
276 |
277 |
278 | };
279 |
--------------------------------------------------------------------------------
/test/other/routes/analysed_test.js:
--------------------------------------------------------------------------------
1 | // Import assert to unit test the database
2 | const assert = require("assert");
3 | const controller = require("../../src/controllers/analysed");
4 | const _ = require("lodash");
5 |
6 | /*
7 |
8 | // Create a series of tests
9 | describe("Testing the /analysed endpoint is returning the correct data", function(){
10 |
11 | it("analysed/ with a valid flight_number", function(done){
12 | let req = {
13 | identifiers: {
14 | flight_number: 25
15 | },
16 | modifiers: {}
17 | };
18 |
19 | let res = {
20 | send: function(analysed) {
21 | assert(analysed.length === 1);
22 | assert(Object.keys(analysed[0]).length === 2);
23 | assert(analysed[0].stage === 2);
24 | assert(analysed[0].telemetry !== undefined);
25 | done();
26 | },
27 | next: function(err){
28 | assert(false);
29 | done();
30 | }
31 | };
32 |
33 | controller.getOne(req, res, function(err){
34 | assert(false);
35 | done();
36 | });
37 | });
38 |
39 |
40 |
41 |
42 | it("analysed/ with an empty identifiers object throws a 404 error", function(done){
43 | let req = {
44 | identifiers: {},
45 | modifiers: {}
46 | };
47 |
48 | let res = {
49 | send: function(analysed) {
50 | assert(false);
51 | done();
52 | },
53 | next: function(err){
54 | assert(false);
55 | done();
56 | }
57 | };
58 |
59 | controller.getOne(req, res, function(err){
60 | assert(err !== undefined);
61 | assert(err.status === 404);
62 | done();
63 | });
64 | });
65 |
66 |
67 |
68 |
69 | it("analysed/ with conflicting flight_number and mission_id throws a 404 error", function(done){
70 | let req = {
71 | identifiers: {
72 | flight_number: 45,
73 | mission_id: "not crs-12"
74 | },
75 | modifiers: {}
76 | };
77 |
78 | let res = {
79 | send: function(analysed) {
80 | assert(false);
81 | done();
82 | },
83 | next: function(err){
84 | assert(false);
85 | done();
86 | }
87 | };
88 |
89 | controller.getOne(req, res, function(err){
90 | assert(err !== undefined);
91 | assert(err.status === 404);
92 | done();
93 | });
94 | });
95 |
96 |
97 |
98 |
99 | it("analysed/ with a valid flight_number, start and end numeric values", function(done){
100 | let req = {
101 | identifiers: {
102 | flight_number: 45
103 | },
104 | modifiers: {
105 | start: 60,
106 | end: 70,
107 | }
108 | };
109 |
110 | let res = {
111 | send: function(analysed) {
112 | assert(analysed.length === 1);
113 | assert(Object.keys(analysed[0]).length === 2);
114 | assert(analysed[0].stage === 1);
115 | assert(analysed[0].telemetry !== undefined);
116 | analysed[0].telemetry.forEach((val) => {
117 | assert(val.time >= 60);
118 | assert(val.time <= 70);
119 | });
120 | done();
121 | },
122 | next: function(err){
123 | assert(false);
124 | done();
125 | }
126 | };
127 |
128 | controller.getOne(req, res, function(err){
129 | assert(false);
130 | done();
131 | });
132 | });
133 |
134 |
135 |
136 |
137 | it("analysed/ with a valid flight_number, start and end numeric values but start is negative", function(done){
138 | let req = {
139 | identifiers: {
140 | flight_number: 45
141 | },
142 | modifiers: {
143 | start: -5,
144 | end: 70,
145 | }
146 | };
147 |
148 | let res = {
149 | send: function(analysed) {
150 | assert(analysed.length === 1);
151 | assert(Object.keys(analysed[0]).length === 2);
152 | assert(analysed[0].stage === 1);
153 | assert(analysed[0].telemetry !== undefined);
154 | analysed[0].telemetry.forEach((val) => {
155 | assert(val.time >= -5);
156 | assert(val.time <= 70);
157 | });
158 | done();
159 | },
160 | next: function(err){
161 | assert(false);
162 | done();
163 | }
164 | };
165 |
166 | controller.getOne(req, res, function(err){
167 | assert(false);
168 | done();
169 | });
170 | });
171 |
172 |
173 |
174 |
175 | it("analysed/ with a valid flight_number but start and end are bigger than the end of the telemetry", function(done){
176 | let req = {
177 | identifiers: {
178 | flight_number: 45
179 | },
180 | modifiers: {
181 | start: 100000,
182 | end: 1000000,
183 | }
184 | };
185 |
186 | let res = {
187 | send: function(analysed) {
188 | assert(analysed.length === 1);
189 | assert(Object.keys(analysed[0]).length === 2);
190 | assert(analysed[0].stage === 1);
191 | assert(analysed[0].telemetry !== undefined);
192 | analysed.forEach((val) => assert(val.telemetry.length === 0));
193 | done();
194 | },
195 | next: function(err){
196 | assert(false);
197 | done();
198 | }
199 | };
200 |
201 | controller.getOne(req, res, function(err){
202 | assert(false);
203 | done();
204 | });
205 | });
206 |
207 |
208 |
209 |
210 | it("analysed/ with a valid flight_number, start and end are events", function(done){
211 | let req = {
212 | identifiers: {
213 | flight_number: 45
214 | },
215 | modifiers: {
216 | start: "boostback_start",
217 | end: "boostback_end",
218 | }
219 | };
220 |
221 | let res = {
222 | send: function(analysed) {
223 | assert(analysed.length === 1);
224 | assert(Object.keys(analysed[0]).length === 2);
225 | assert(analysed[0].stage === 1);
226 | assert(analysed[0].telemetry !== undefined);
227 | analysed[0].telemetry.forEach((val) => {
228 | assert(val.time >= 166);
229 | assert(val.time <= 212);
230 | });
231 | done();
232 | },
233 | next: function(err){
234 | assert(false);
235 | done();
236 | }
237 | };
238 |
239 | controller.getOne(req, res, function(err){
240 | assert(false);
241 | done();
242 | });
243 | });
244 |
245 |
246 |
247 |
248 | it("analysed/ with valid flight_number but with an invalid event in start", function(done){
249 | let req = {
250 | identifiers: {
251 | flight_number: 45,
252 | },
253 | modifiers: {
254 | start: "abc"
255 | }
256 | };
257 |
258 | let res = {
259 | send: function(analysed) {
260 | assert(false);
261 | done();
262 | },
263 | next: function(err){
264 | assert(false);
265 | done();
266 | }
267 | };
268 |
269 | controller.getOne(req, res, function(err){
270 | assert(err !== undefined);
271 | done();
272 | });
273 | });
274 |
275 |
276 |
277 | it("analysed/ with a valid flight_number and event", function(done){
278 | let req = {
279 | identifiers: {
280 | flight_number: 45
281 | },
282 | modifiers: {
283 | event: "boostback_start",
284 | }
285 | };
286 |
287 | let res = {
288 | send: function(analysed) {
289 | assert(analysed.length === 1);
290 | assert(Object.keys(analysed[0]).length === 2);
291 | assert(analysed[0].stage === 1);
292 | assert(analysed[0].telemetry !== undefined);
293 | assert(analysed[0].telemetry.length === 1);
294 | assert(_.isEqual(analysed[0].telemetry[0].toJSON(), { time: 166,
295 | velocity: 1524.714,
296 | altitude: 80.887,
297 | velocity_y: 971.201,
298 | velocity_x: 1174.682,
299 | acceleration: -3.256,
300 | downrange_distance: 64.931,
301 | angle: 39.16,
302 | q: 0 }));
303 | done();
304 | },
305 | next: function(err){
306 | assert(false);
307 | done();
308 | }
309 | };
310 |
311 | controller.getOne(req, res, function(err){
312 | assert(false);
313 | done();
314 | });
315 | });
316 |
317 |
318 |
319 |
320 |
321 | it("analysed/ with a valid flight_number and an invalid event should return an error", function(done){
322 | let req = {
323 | identifiers: {
324 | flight_number: 45
325 | },
326 | modifiers: {
327 | event: "not a real event",
328 | }
329 | };
330 |
331 | let res = {
332 | send: function(analysed) {
333 | assert(false);
334 | done();
335 | },
336 | next: function(err){
337 |
338 | assert(false);
339 | done();
340 | }
341 | };
342 |
343 | controller.getOne(req, res, function(err){
344 |
345 | assert(err !== undefined);
346 | done();
347 | });
348 | });
349 |
350 |
351 |
352 |
353 | it("analysed/ with a valid flight_number and event = null should return an error", function(done){
354 | let req = {
355 | identifiers: {
356 | flight_number: 45
357 | },
358 | modifiers: {
359 | event: null,
360 | }
361 | };
362 |
363 | let res = {
364 | send: function(analysed) {
365 | assert(false);
366 | done();
367 | },
368 | next: function(err){
369 | assert(false);
370 | done();
371 | }
372 | };
373 |
374 | controller.getOne(req, res, function(err){
375 | assert(true);
376 | done();
377 | });
378 | });
379 |
380 | });
381 |
382 |
383 | */
384 |
--------------------------------------------------------------------------------