func intensityMeasuredLatest(w http.ResponseWriter, r *http.Request) { if err := intensityMeasuredLatestD.CheckParams(r.URL.Query()); err != nil { web.BadRequest(w, r, err.Error()) return } if r.URL.Query().Get("type") != "measured" { web.BadRequest(w, r, "type must be measured.") return } var d string err := db.QueryRow( `SELECT row_to_json(fc) FROM ( SELECT 'FeatureCollection' as type, COALESCE(array_to_json(array_agg(f)), '[]') as features FROM (SELECT 'Feature' as type, ST_AsGeoJSON(s.location)::json as geometry, row_to_json(( select l from ( select mmi ) as l )) as properties from (select location, mmi FROM impact.intensity_measured) as s ) As f ) as fc`).Scan(&d) if err != nil { web.ServiceUnavailable(w, r, err) return } b := []byte(d) web.Ok(w, r, &b) }
func alertLevel(w http.ResponseWriter, r *http.Request) { if len(r.URL.Query()) != 0 { web.BadRequest(w, r, "incorrect number of query parameters.") return } var d string err := db.QueryRow(`SELECT row_to_json(fc) FROM ( SELECT 'FeatureCollection' as type, array_to_json(array_agg(f)) as features FROM (SELECT 'Feature' as type, ST_AsGeoJSON(v.location)::json as geometry, row_to_json((SELECT l FROM ( SELECT id AS "volcanoID", title AS "volcanoTitle", alert_level as "level", activity, hazards ) as l )) as properties FROM (qrt.volcano JOIN qrt.volcanic_alert_level using (alert_level)) as v ) As f ) as fc`).Scan(&d) if err != nil { web.ServiceUnavailable(w, r, err) return } b := []byte(d) web.Ok(w, r, &b) }
// just quake regions at the moment. func regions(w http.ResponseWriter, r *http.Request) { if err := regionsD.CheckParams(r.URL.Query()); err != nil { web.BadRequest(w, r, err.Error()) return } if r.URL.Query().Get("type") != "quake" { web.BadRequest(w, r, "type must be quake.") return } var d string err := db.QueryRow(`SELECT row_to_json(fc) FROM ( SELECT 'FeatureCollection' as type, array_to_json(array_agg(f)) as features FROM (SELECT 'Feature' as type, ST_AsGeoJSON(q.geom)::json as geometry, row_to_json((SELECT l FROM ( SELECT regionname as "regionID", title, groupname as group ) as l )) as properties FROM qrt.region as q where groupname in ('region', 'north', 'south')) as f ) as fc`).Scan(&d) if err != nil { web.ServiceUnavailable(w, r, err) return } w.Header().Set("Surrogate-Control", web.MaxAge86400) b := []byte(d) web.Ok(w, r, &b) }
func quake(w http.ResponseWriter, r *http.Request) { if len(r.URL.Query()) != 0 { web.BadRequest(w, r, "incorrect number of query parameters.") return } publicID := r.URL.Path[quakeLen:] // TODO bother with this? if !publicIDRe.MatchString(publicID) { web.BadRequest(w, r, "invalid publicID: "+publicID) return } var d string // Check that the publicid exists in the DB. This is needed as the handle method will return empty // JSON for an invalid publicID. err := db.QueryRow("select publicid FROM qrt.quake_materialized where publicid = $1", publicID).Scan(&d) if err == sql.ErrNoRows { web.NotFound(w, r, "invalid publicID: "+publicID) return } if err != nil { web.ServiceUnavailable(w, r, err) return } err = db.QueryRow( `SELECT row_to_json(fc) FROM ( SELECT 'FeatureCollection' as type, array_to_json(array_agg(f)) as features FROM (SELECT 'Feature' as type, ST_AsGeoJSON(q.origin_geom)::json as geometry, row_to_json((SELECT l FROM ( SELECT publicid AS "publicID", to_char(origintime, 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"') as "time", depth, magnitude, type, agency, locality, qrt.mmi_to_intensity(maxmmi) as intensity, qrt.mmi_to_intensity(mmi_newzealand) as "regionIntensity", qrt.quake_quality(status, usedphasecount, magnitudestationcount) as quality, to_char(updatetime, 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"') as "modificationTime" ) as l )) as properties FROM qrt.quake_materialized as q where publicid = $1 ) As f ) as fc`, publicID).Scan(&d) if err != nil { web.ServiceUnavailable(w, r, err) return } b := []byte(d) web.Ok(w, r, &b) }
func felt(w http.ResponseWriter, r *http.Request) { if err := feltD.CheckParams(r.URL.Query()); err != nil { web.BadRequest(w, r, err.Error()) return } publicID := r.URL.Query().Get("publicID") var d string err := db.QueryRow("select publicid FROM qrt.quake_materialized where publicid = $1", publicID).Scan(&d) if err == sql.ErrNoRows { web.NotFound(w, r, "invalid publicID: "+publicID) return } if err != nil { web.ServiceUnavailable(w, r, err) return } res, err := client.Get(feltURL + publicID + ".geojson") defer res.Body.Close() if err != nil { web.ServiceUnavailable(w, r, err) return } b, err := ioutil.ReadAll(res.Body) if err != nil { web.ServiceUnavailable(w, r, err) return } // Felt returns a 400 when it should probably be a 404. Tapestry quirk? switch { case 200 == res.StatusCode: web.Ok(w, r, &b) return case 4 == res.StatusCode/100: web.NotFound(w, r, string(b)) return case 5 == res.StatusCode/500: web.ServiceUnavailable(w, r, errors.New("error proxying felt resports. Shrug.")) return } web.ServiceUnavailable(w, r, errors.New("unknown response from felt.")) }
func news(w http.ResponseWriter, r *http.Request) { if len(r.URL.Query()) != 0 { web.BadRequest(w, r, "incorrect number of query parameters.") return } j, err := fetchRSS(newsURL) if err != nil { web.ServiceUnavailable(w, r, err) return } w.Header().Set("Surrogate-Control", web.MaxAge300) web.Ok(w, r, &j) }
func intensityReportedLatest(w http.ResponseWriter, r *http.Request) { if err := intensityReportedLatestD.CheckParams(r.URL.Query()); err != nil { web.BadRequest(w, r, err.Error()) return } if r.URL.Query().Get("type") != "reported" { web.BadRequest(w, r, "type must be reported.") return } zoom := r.URL.Query().Get("zoom") if !zoomRe.MatchString(r.URL.Query().Get("zoom")) { web.BadRequest(w, r, "Invalid zoom") return } var d string err := db.QueryRow( `SELECT row_to_json(fc) FROM ( SELECT 'FeatureCollection' as type, COALESCE(array_to_json(array_agg(f)), '[]') as features FROM (SELECT 'Feature' as type, ST_AsGeoJSON(s.location)::json as geometry, row_to_json(( select l from ( select max_mmi, min_mmi, count ) as l )) as properties from (select st_pointfromgeohash(geohash` + zoom + `) as location, min(mmi) as min_mmi, max(mmi) as max_mmi, count(mmi) as count FROM impact.intensity_reported WHERE time >= (now() - interval '60 minutes') group by (geohash` + zoom + `)) as s ) As f ) as fc`).Scan(&d) if err != nil { web.ServiceUnavailable(w, r, err) return } b := []byte(d) web.Ok(w, r, &b) }
func siteType(w http.ResponseWriter, r *http.Request) { if err := siteTypeD.CheckParams(r.URL.Query()); err != nil { web.BadRequest(w, r, err.Error()) return } v := r.URL.Query() if v.Get("methodID") != "" && v.Get("typeID") == "" { web.BadRequest(w, r, "typeID must be specified when methodID is specified.") return } var typeID, methodID, within string if v.Get("typeID") != "" { typeID = v.Get("typeID") if !validType(w, r, typeID) { return } if v.Get("methodID") != "" { methodID = v.Get("methodID") if !validTypeMethod(w, r, typeID, methodID) { return } } } if v.Get("within") != "" { within = strings.Replace(v.Get("within"), "+", "", -1) if !validPoly(w, r, within) { return } } w.Header().Set("Content-Type", web.V1GeoJSON) b, err := geoJSONSites(typeID, methodID, within) if err != nil { web.ServiceUnavailable(w, r, err) return } web.Ok(w, r, &b) }
func method(w http.ResponseWriter, r *http.Request) { if err := methodD.CheckParams(r.URL.Query()); err != nil { web.BadRequest(w, r, err.Error()) return } typeID := r.URL.Query().Get("typeID") if typeID != "" && !validType(w, r, typeID) { return } var d string var err error switch typeID { case "": err = db.QueryRow( `select row_to_json(fc) from (select array_to_json(array_agg(m)) as method from (select methodid as "methodID", method.name, method.description, method.reference from fits.type join fits.type_method using (typepk) join fits.method using (methodpk)) as m) as fc`).Scan(&d) default: err = db.QueryRow( `select row_to_json(fc) from (select array_to_json(array_agg(m)) as method from (select methodid as "methodID", method.name, method.description, method.reference from fits.type join fits.type_method using (typepk) join fits.method using (methodpk) where type.typeID = $1) as m) as fc`, typeID).Scan(&d) } if err != nil { web.ServiceUnavailable(w, r, err) return } w.Header().Set("Content-Type", web.V1JSON) b := []byte(d) web.Ok(w, r, &b) }
func region(w http.ResponseWriter, r *http.Request) { if len(r.URL.Query()) != 0 { web.BadRequest(w, r, "incorrect number of query parameters.") return } regionID := r.URL.Path[regionLen:] var d string err := db.QueryRow("select regionname FROM qrt.region where regionname = $1", regionID).Scan(&d) if err == sql.ErrNoRows { web.BadRequest(w, r, "invalid regionID: "+regionID) return } if err != nil { web.ServiceUnavailable(w, r, err) return } err = db.QueryRow(`SELECT row_to_json(fc) FROM ( SELECT 'FeatureCollection' as type, array_to_json(array_agg(f)) as features FROM (SELECT 'Feature' as type, ST_AsGeoJSON(q.geom)::json as geometry, row_to_json((SELECT l FROM ( SELECT regionname as "regionID", title, groupname as group ) as l )) as properties FROM qrt.region as q where regionname = $1 ) as f ) as fc`, regionID).Scan(&d) if err != nil { web.ServiceUnavailable(w, r, err) return } w.Header().Set("Surrogate-Control", web.MaxAge86400) b := []byte(d) web.Ok(w, r, &b) }
func typeH(w http.ResponseWriter, r *http.Request) { if len(r.URL.Query()) != 0 { web.BadRequest(w, r, "incorrect number of query params.") return } w.Header().Set("Content-Type", web.V1JSON) var d string err := db.QueryRow( `select row_to_json(fc) from (select array_to_json(array_agg(t)) as type from (select typeid as "typeID", type.name, symbol as unit, description from fits.type join fits.unit using (unitpk)) as t) as fc`).Scan(&d) if err != nil { web.ServiceUnavailable(w, r, err) return } b := []byte(d) web.Ok(w, r, &b) }
func site(w http.ResponseWriter, r *http.Request) { if err := siteD.CheckParams(r.URL.Query()); err != nil { web.BadRequest(w, r, err.Error()) return } networkID := r.URL.Query().Get("networkID") siteID := r.URL.Query().Get("siteID") if !validSite(w, r, networkID, siteID) { return } w.Header().Set("Content-Type", web.V1GeoJSON) b, err := geoJSONSite(networkID, siteID) if err != nil { web.ServiceUnavailable(w, r, err) return } web.Ok(w, r, &b) }
func quakes(w http.ResponseWriter, r *http.Request) { if err := quakesD.CheckParams(r.URL.Query()); err != nil { web.BadRequest(w, r, err.Error()) return } v := r.URL.Query() number := v.Get("number") regionID := v.Get("regionID") intensity := v.Get("intensity") quality := strings.Split(v.Get("quality"), ",") if !numberRe.MatchString(number) { web.BadRequest(w, r, "Invalid query parameter number: "+number) return } if !intensityRe.MatchString(intensity) { web.BadRequest(w, r, "Invalid intensity: "+intensity) return } for _, q := range quality { if !qualityRe.MatchString(q) { web.BadRequest(w, r, "Invalid quality: "+q) return } } var d string err := db.QueryRow("select regionname FROM qrt.region where regionname = $1 AND groupname in ('region', 'north', 'south')", regionID).Scan(&d) if err == sql.ErrNoRows { web.BadRequest(w, r, "invalid quake regionID: "+regionID) return } if err != nil { web.ServiceUnavailable(w, r, err) return } err = db.QueryRow( `SELECT row_to_json(fc) FROM ( SELECT 'FeatureCollection' as type, COALESCE(array_to_json(array_agg(f)), '[]') as features FROM (SELECT 'Feature' as type, ST_AsGeoJSON(q.origin_geom)::json as geometry, row_to_json((SELECT l FROM ( SELECT publicid AS "publicID", to_char(origintime, 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"') as "time", depth, magnitude, type, agency, locality, intensity, intensity_`+regionID+` as "regionIntensity", quality, to_char(updatetime, 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"') as "modificationTime" ) as l )) as properties FROM qrt.quakeinternal_v2 as q where maxmmi >= qrt.intensity_to_mmi($1) AND quality in ('`+strings.Join(quality, `','`)+`') AND ST_Contains((select geom from qrt.region where regionname = $3), ST_Shift_Longitude(origin_geom)) limit $2 ) as f ) as fc`, intensity, number, regionID).Scan(&d) if err != nil { web.ServiceUnavailable(w, r, err) return } b := []byte(d) web.Ok(w, r, &b) }
func intensityReported(w http.ResponseWriter, r *http.Request) { if err := intensityReportedD.CheckParams(r.URL.Query()); err != nil { web.BadRequest(w, r, err.Error()) return } if r.URL.Query().Get("type") != "reported" { web.BadRequest(w, r, "type must be reported.") return } zoom := r.URL.Query().Get("zoom") if !zoomRe.MatchString(r.URL.Query().Get("zoom")) { web.BadRequest(w, r, "Invalid zoom") return } // Check that the publicid exists in the DB. // If it does we keep the origintime - we need it later on. publicID := r.URL.Query().Get("publicID") originTime := time.Time{} err := db.QueryRow("select origintime FROM qrt.quake_materialized where publicid = $1", publicID).Scan(&originTime) if err == sql.ErrNoRows { web.NotFound(w, r, "invalid publicID: "+publicID) return } if err != nil { web.ServiceUnavailable(w, r, err) return } query := `SELECT row_to_json(fc) FROM ( SELECT 'FeatureCollection' as type, COALESCE(array_to_json(array_agg(f)), '[]') as features FROM (SELECT 'Feature' as type, ST_AsGeoJSON(s.location)::json as geometry, row_to_json(( select l from ( select max_mmi, min_mmi, count ) as l )) as properties from (select st_pointfromgeohash(geohash` + zoom + `) as location, min(mmi) as min_mmi, max(mmi) as max_mmi, count(mmi) as count FROM impact.intensity_reported WHERE time >= $1 AND time <= $2 group by (geohash` + zoom + `)) as s ) As f ) as fc` var d string err = db.QueryRow(query, originTime.Add(time.Duration(-1*time.Minute)), originTime.Add(time.Duration(15*time.Minute))).Scan(&d) if err != nil { web.ServiceUnavailable(w, r, err) return } b := []byte(d) web.Ok(w, r, &b) }
/** * query end point for observation statistics including: max, min, mean, std, first and last values * http://fits.geonet.org.nz/observation/stats?typeID=e&siteID=HOLD&networkID=CG&days=100 */ func observationStats(w http.ResponseWriter, r *http.Request) { //1. check query parameters if err := observationD.CheckParams(r.URL.Query()); err != nil { web.BadRequest(w, r, err.Error()) return } v := r.URL.Query() typeID := v.Get("typeID") networkID := v.Get("networkID") siteID := v.Get("siteID") if !validType(w, r, typeID) { return } var days int var err error var tmin, tmax time.Time if v.Get("days") != "" { days, err = strconv.Atoi(v.Get("days")) if err != nil || days > 365000 { web.BadRequest(w, r, "Invalid days query param.") return } tmax = time.Now().UTC() tmin = tmax.Add(time.Duration(days*-1) * time.Hour * 24) } var methodID string if v.Get("methodID") != "" { methodID = v.Get("methodID") if !validTypeMethod(w, r, typeID, methodID) { return } } //2. Find the unit var unit string err = db.QueryRow("select symbol FROM fits.type join fits.unit using (unitPK) where typeID = $1", typeID).Scan(&unit) if err == sql.ErrNoRows { web.NotFound(w, r, "unit not found for typeID: "+typeID) return } if err != nil { web.ServiceUnavailable(w, r, err) return } // retrieve values using existing functions values, err := loadObs(networkID, siteID, typeID, methodID, tmin) if err != nil { web.ServiceUnavailable(w, r, err) return } mean, stdDev, err := stddevPop(networkID, siteID, typeID, methodID, tmin) if err != nil { web.ServiceUnavailable(w, r, err) return } stats := obstats{Unit: unit, Mean: mean, StddevPopulation: stdDev} //4. get maximum, minimum, first, last values stats.First = values[0] stats.Last = values[len(values)-1] iMin, iMax, _ := extremes(values) stats.Minimum = values[iMin] stats.Maximum = values[iMax] //5. send result response w.Header().Set("Content-Type", web.V1JSON) b, err := json.Marshal(stats) if err != nil { web.ServiceUnavailable(w, r, err) return } web.Ok(w, r, &b) }