all-airports
Version:
Serves as an independent data scraping module, complete with ontology and full scraping ability for the airports of the world
377 lines (376 loc) • 18.6 kB
JavaScript
;
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
Object.defineProperty(exports, "__esModule", { value: true });
var csv = require("csvtojson");
var getUuid = require("uuid-by-string");
var funktologies_1 = require("funktologies");
var constants_1 = require("../constants/constants");
var globalStore_1 = require("../constants/globalStore");
var materialLookupTable = {
'\'CONCRETE\'': 'Concrete',
'ALUM': 'ALUMINUM',
'ALUMINUM': 'ALUMINUM',
'ASB': 'Asbestos Cement',
'ASFALT': 'Asphalt',
'ASP': 'Asphalt',
'ASPH': 'Asphalt',
'ASPHALT': 'Asphalt',
'ASPHALT CONCRETE': 'Concrete (Asphalt)',
'ASPHALT MIX': 'Asphalt (Mix)',
'ASPHALTIC CONCRETE': ' Concrete (Asphalt)',
'BIT': 'Bituminous asphalt or tarmac',
'BITUMEN': 'Bitumen',
'BITUMINOUS': 'Bitumen',
'BLACK CLAY': 'Clay (Black)',
'BLACK SILT': 'Silt (Black)',
'BRI': 'Bricks',
'BRICK': 'Bricks',
'BROWN CLAY': 'Clay (Brown)',
'BROWN CLAY GRAVEL': 'Gravel (Brown Clay)',
'BROWN GRAVEL': 'Gravel (Brown)',
'BROWN SILT CLAY': 'Clay (Brown Silt)',
'CALICHE': 'Cement (Caliche)',
'CINDERS': 'Gravel (Cinders)',
'CL': 'Clay',
'CLA': 'Clay',
'CLAY': 'Clay',
'COM': 'Composite',
'COMPACTED EARTH': 'Earth (Compacted)',
'CON': 'Concrete',
'CONC': 'Concrete',
'CONCRETE': 'Concrete',
'COP': 'Composite',
'COR': 'Coral (fine crushed coral reef structures)',
'CORAL': 'Coral (fine crushed coral reef structures)',
'CORAL SAND': 'Sand (Crushed Coral)',
'CRUSHED ROCK': 'Crushed Rock',
'CRUSHED STONE': 'Crushed Stone',
'DECK': 'Deck',
'DIRT': 'Dirt',
'DIRT(CALICHE)': 'Dirt (Caliche)',
'EARTH': 'Earth',
'FROZEN LAKE': 'Ice (Frozen Lake)',
'GRAAS': 'Grass',
'GRADED EARTH': 'Earth (Graded)',
'GRAIN': 'Grain',
'GRAS': 'Grass',
'GRASS': 'Grass',
'GRASS CORAL': 'Coral (Grass)',
'GRASS DIRT': 'Dirt (Grass)',
'GRASS OR EARTH NOT GRADED OR ROLLED': 'Earth/Grass (Not Graded or rolled)',
'GRASS RED SILTY CLAY': 'Clay (Grassed Red Silt)',
'GRASS RED SILTY SAND': 'Sand (Grassed Red Silt)',
'GRASSED BLACK CLAY': 'Clay (Grassed Black)',
'GRASSED BLACK CLAY SAND': 'Sand (Grassed Black Clay)',
'GRASSED BLACK CLAY SILT': 'Silt (Grassed Black Clay)',
'GRASSED BLACK SAND': 'Sand (Grassed Black)',
'GRASSED BLACK SILT': 'Silt (Grassed Black)',
'GRASSED BLACK SILT CLAY': 'Clay (Grassed Black Silt)',
'GRASSED BLACK SOIL': 'Soil (Grassed Black)',
'GRASSED BLACKCLAY': 'Clay (Grassed Black)',
'GRASSED BROWN CLAY': 'Clay (Grassed Brown)',
'GRASSED BROWN GRAVEL': 'Gravel (Grassed Brown)',
'GRASSED BROWN SANDY CLAY': 'Clay (Grassed Brown Sandy)',
'GRASSED BROWN SILT CLAY': 'Clay (Grassed Brown Silt)',
'GRASSED BROWN SILT LOAM': 'Loam (Grassed Brown Silt)',
'GRASSED BROWN SILTY CLAY': 'Clay (Grassed Brown Silt)',
'GRASSED CLAY': 'Clay (Grassed)',
'GRASSED CLAY SILT CLAY': 'Clay (Grassed Silt)',
'GRASSED GRAVEL': 'Gravel (Grassed)',
'GRASSED GREY CLAY': 'Clay (Grassed Grey)',
'GRASSED GREY GRAVEL': 'Gravel (Grassed Grey)',
'GRASSED GREY SAND': 'Sand (Grassed Grey)',
'GRASSED GREY SILT CLAY': 'Clay (Grassed Grey Silt)',
'GRASSED GREY SILT SAND': 'Sand (Grassed Grey Silt)',
'GRASSED LIMESTONE GRAVEL': 'Gravel (Grassed Limestone)',
'GRASSED RED CLAY': 'Clay (Grassed Red)',
'GRASSED RED SILT': 'Silt (Grassed Red)',
'GRASSED RED SILT CLAY': 'Clay (Grassed Red Silt)',
'GRASSED RED SILT SAND': 'Sand (Grassed Red Silt)',
'GRASSED RED SILTY CLAY': 'Clay (Grassed Red Silt)',
'GRASSED RED SILTY SAND': 'Sand (Grassed Red Silt)',
'GRASSED RIVER GRAVEL': 'Gravel (Grassed Gravel)',
'GRASSED SAND': 'Sand (Grassed)',
'GRASSED SANDY LOAM': 'Loam (Grassed sandy)',
'GRASSED SILT CLAY': 'Clay (Grassed Silt)',
'GRASSED WHITE GRAVEL': 'Gravel (Grassed White)',
'GRASSED WHITE LIME STONE': 'Limestone (Grassed White)',
'GRASSED YELLOW CLAY': 'Clay (Grassed Yellow)',
'GRASSED YELLOW GRAVEL': 'Gravel (Grassed Yellow)',
'GRASSED YELLOW SILT CLAY': 'Clay (Grassed Yellow Silt)',
'GRASSY': 'Grass',
'GRAV': 'Gravel',
'GRAVEL': 'Gravel',
'GRE': 'Earth/Grass (Graded or rolled)',
'GREY CLAY': 'Clay (Grey)',
'GREY GRAVEL': 'Gravel (Grey)',
'GREY SILT CLAY': 'Clay (Grey Silt)',
'GROUND': 'Earth',
'GRS': 'Grass',
'GRV': 'Gravel',
'GRVL': 'Gravel',
'GVL': 'Gravel',
'HARD CLAY': 'Clay (Hard)',
'HARD LOAM': 'Loam (Hard)',
'HARD MUD': 'Mud (Hard)',
'HARD SAND': 'Sand (HARD)',
'ICE': 'Ice',
'LANDING MATS': 'Marston Matting',
'LAT': 'Laterite',
'LIMESTONE': 'Limestone',
'LOOSE GRAVEL': 'Gravel (Loose)',
'MAC': 'Macadam',
'MAICILLO': 'Sand (Maicillo)',
'MARSTON MATTING': 'Marston Matting',
'MAT': 'Marston Matting',
'MATS': 'Marston Matting',
'MEMBRANES': 'Marston Matting',
'MET': 'Metal',
'METAL': 'Metal',
'MOSS': 'Earth (Moss)',
'NATURAL SOIL': 'Natural Soil',
'NEOPRENE': 'Neoprene',
'OILED DIRT': 'Dirt (Oiled)',
'OILED GRAVEL': 'Gravel (Oiled)',
'OILGRAVEL': 'Gravel (Oiled)',
'OLD ASP': 'Asphalt (Old)',
'OLIGRAVEL': 'Gravel (Oiled)',
'PACKED': 'Dirt (Packed)',
'PACKED DIRT': 'Dirt (Packed)',
'PACKED GRAVEL': 'Gravel (Packed)',
'PAD': 'Blast Pads',
'PAVED': 'Pavement',
'PAVEMENT': 'Pavement',
'PEM': 'Partially concrete, asphalt or bitumen-bound macadam',
'PER': 'Permanent surface, details unknown',
'PFC': 'Porous Friction Course',
'PIERCED STEEL PLANKING': 'Marston Matting',
'PSP': 'Marston Matting',
'RED CLAY': 'Clay (Red)',
'RED CLAY GRAVEL': 'Gravel (Red Clay)',
'RED GRAVEL': 'Gravel (Red)',
'RED SILT CLAY': 'Clay (Red Silt)',
'ROCK': 'Rock',
'ROCKY GRAVEL': 'Gravel (Rocky)',
'ROLLED EARTH': 'Earth (Rolled)',
'ROOF': 'Rooftop',
'ROOF-TOP': 'Rooftop',
'ROOF/TOP': 'Rooftop',
'ROOFTOP': 'Rooftop',
'SAN': 'Sand',
'SAND': 'Sand',
'SAND GRASS': 'Sand (Grass)',
'SANDY SOIL': 'Soil (Sandy)',
'SHELLS': 'Shells',
'SLAG': 'Slag',
'SMT': 'Sommerfeld Tracking',
'SN': 'Sand',
'SNO': 'Snow',
'SNOW': 'Snow',
'SOD': 'Sod',
'SOFT GRAVEL': 'Gravel (Soft)',
'SOFT SAND': 'Sand (Soft)',
'SOIL': 'Soil',
'STEEL': 'Steel',
'STONE': 'Stone',
'STONE DUST': 'Stone (Dust)',
'TARMAC': 'Tarmac',
'TOP': 'Rooftop',
'TREATED': 'Treated',
'TREATED GRAVEL': 'Gravel (Treated)',
'TREATED SAND': 'Sand (Treated)',
'TRTD': 'Treated',
'TRTD GRVL': 'Gravel (Treated)',
'TURF': 'Turf',
'U': 'Unknown',
'UNK': 'Unknown',
'UNKNOWN': 'Unknown',
'UNPAVED': 'Unknown (Unpaved)',
'WATER': 'Water',
'WHITE GRAVEL': 'Gravel (White)',
'WOOD': 'Wood',
'YELLOW GRAVEL': 'Gravel (Yellow)',
};
var conditionLookupTable = {
'F': 'Fair',
'G': 'Good',
'P': 'Poor',
'f': 'Fair',
'g': 'Good',
'p': 'Poor'
};
function getRunwaysFromOurAirports() {
return __awaiter(this, void 0, void 0, function () {
var runwayData, jsonifiedData;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
runwayData = [];
return [4 /*yield*/, csv({
headers: ['id', 'refId', 'ident', 'length', 'width', 'surfMat', 'lighted', 'closed'],
noheader: false
}).fromFile('src/assets/runways-ourairports.csv')];
case 1:
jsonifiedData = _a.sent();
jsonifiedData.forEach(function (datum) { return runwayData.push(CSV(datum.id, datum.refId, datum.ident, datum.length, datum.width, datum.surfMat, datum.lighted, datum.closed)); });
Object.values(runwayData).forEach(function (runway) {
if (!runway.length || !runway.width || !runway.ident) {
return;
}
var airportId = constants_1.consts.ONTOLOGY.INST_AIRPORT + getUuid(runway.ident);
var airport = globalStore_1.store.airports[airportId];
// If an airport doesn't already exist in the store for this runway,
// we can't attach the runway to anything.
if (airport && runway.length && runway.width) {
var airportObjProperties = airport.objectProperties;
var runMap_1 = funktologies_1.getRelation(airportObjProperties, constants_1.consts.ONTOLOGY.HAS_RUNWAY);
var rId = constants_1.consts.ONTOLOGY.INST_RUNWAY + getUuid(runway.ident);
if (!runMap_1) {
var objectProp = {};
if (globalStore_1.store.runways[rId]) {
objectProp[constants_1.consts.ONTOLOGY.HAS_RUNWAY] = globalStore_1.store.runways[rId];
}
else {
objectProp = funktologies_1.entityMaker(constants_1.consts.ONTOLOGY.HAS_RUNWAY, constants_1.consts.ONTOLOGY.ONT_RUNWAY, rId, "Runway for " + (airport.datatypeProperties[constants_1.consts.ONTOLOGY.DT_NAME] || runway.ident));
globalStore_1.store.runways[rId] = objectProp[constants_1.consts.ONTOLOGY.HAS_RUNWAY];
}
runMap_1 = objectProp[constants_1.consts.ONTOLOGY.HAS_RUNWAY];
airport.objectProperties.push(funktologies_1.entityRefMaker(constants_1.consts.ONTOLOGY.HAS_RUNWAY, objectProp));
}
runMap_1.datatypeProperties[constants_1.consts.ONTOLOGY.DT_LENGTH] = Number(runway.length);
runMap_1.datatypeProperties[constants_1.consts.ONTOLOGY.DT_WIDTH] = Number(runway.width);
runMap_1.datatypeProperties[constants_1.consts.ONTOLOGY.DT_UNIT] = 'ft';
if (runway.surfMat) {
runway.surfMat = runway.surfMat.replace(',', ' - ');
// Catches edge case where single letters specifiy condition of the runway material.
var hyphenList = runway.surfMat.split('-').map(function (sm) { return sm.trim(); });
var lastDescriptor = hyphenList[hyphenList.length - 1];
var hasCondition = (lastDescriptor && lastDescriptor.length === 1) || null;
var condition = '';
if (hasCondition) {
condition = conditionLookupTable[lastDescriptor];
}
// Ensure synonyms of same material aren't counted as extra
var surfaceMaterials_1 = runway.surfMat.split('/').map(function (sm) { return sm.trim(); });
// The longer list is
if (hyphenList.length > 1) {
if (surfaceMaterials_1.length > 1) {
surfaceMaterials_1 = [];
hyphenList.forEach(function (item) { return surfaceMaterials_1.push.apply(surfaceMaterials_1, item.split('/').map(function (sm) { return sm.trim(); })); });
}
else {
surfaceMaterials_1 = hyphenList;
}
}
var convertedSurList_1 = [];
if (!hasCondition) {
surfaceMaterials_1.forEach(function (mat) {
convertedSurList_1.push(materialLookup(mat));
});
convertedSurList_1 = convertedSurList_1.filter(function (x) { return !!x; });
// Remove undefined, and duplications
var fistSurf_1 = convertedSurList_1.shift();
if (fistSurf_1) {
convertedSurList_1 = convertedSurList_1.filter(function (x) { return x !== fistSurf_1; });
convertedSurList_1.unshift(fistSurf_1);
}
}
if (!convertedSurList_1.length) {
return;
}
if (convertedSurList_1[0] === 'ROOF' || convertedSurList_1.length === 1) {
makeSurfaceMaterial(airport, runMap_1, runway.ident, materialLookup(runway.surfMat), false, condition);
}
else {
convertedSurList_1.forEach(function (mat) {
makeSurfaceMaterial(airport, runMap_1, runway.ident, mat, true);
});
}
}
}
});
return [2 /*return*/];
}
});
});
}
exports.getRunwaysFromOurAirports = getRunwaysFromOurAirports;
;
function makeSurfaceMaterial(airport, runMap, runwayId, sMat, isComposite, condition) {
if (!sMat) {
return;
}
var runwayObjProperties = runMap.objectProperties;
var mapSurfMat = funktologies_1.getRelation(runwayObjProperties, constants_1.consts.ONTOLOGY.HAS_SURFACE_MATERIAL);
var smId = constants_1.consts.ONTOLOGY.INST_SURFACE_MATERIAL + getUuid(runwayId) + getUuid(sMat);
if (!mapSurfMat) {
var surfMatObjProp = {};
if (globalStore_1.store.surfaceMaterials[smId]) {
surfMatObjProp[constants_1.consts.ONTOLOGY.HAS_SURFACE_MATERIAL] = globalStore_1.store.surfaceMaterials[smId];
}
else {
surfMatObjProp = funktologies_1.entityMaker(constants_1.consts.ONTOLOGY.HAS_SURFACE_MATERIAL, constants_1.consts.ONTOLOGY.ONT_SURFACE_MATERIAL, smId, "Surface Material for the runway at " + (airport.name || runwayId));
globalStore_1.store.surfaceMaterials[smId] = surfMatObjProp[constants_1.consts.ONTOLOGY.HAS_SURFACE_MATERIAL];
}
mapSurfMat = surfMatObjProp[constants_1.consts.ONTOLOGY.HAS_SURFACE_MATERIAL];
runMap.objectProperties.push(funktologies_1.entityRefMaker(constants_1.consts.ONTOLOGY.HAS_SURFACE_MATERIAL, surfMatObjProp));
}
if (condition) {
mapSurfMat.datatypeProperties[constants_1.consts.ONTOLOGY.DT_CONDITION] = condition;
}
mapSurfMat.datatypeProperties[constants_1.consts.ONTOLOGY.DT_IS_COMPOSITE] = isComposite;
mapSurfMat.datatypeProperties[constants_1.consts.ONTOLOGY.DT_MATERIAL] = sMat;
}
function materialLookup(abbrev) {
// if (!materialLookupTable[abbrev.toUpperCase()]) {
// store.debugLogger(`3, ${abbrev} ~ ${materialLookupTable[abbrev.toUpperCase()]}`);
// }
return materialLookupTable[abbrev.toUpperCase()] || abbrev || '';
}
function CSV(id, refId, ident, length, width, surfMat, lighted, closed) {
return {
closed: !!closed,
id: id,
ident: ident,
length: length,
lighted: !!lighted,
refId: refId,
surfMat: surfMat,
width: width
};
}
;