Esempio n. 1
0
func (h *DBHandler) scenarioStubsHandler(rw http.ResponseWriter, req *http.Request) {
	// stubo ID, should be stored in database
	id := bone.GetValue(req, "id")
	u, err := strconv.ParseUint(id, 10, 64)
	if err != nil {
		http.Error(rw, "Bad stubo ID.", 400)
		return
	}
	var stubo Stubo
	// getting stubo from database
	stubo = h.getStuboDetails(u)

	// getting all scenarios
	client := &Client{&http.Client{}}
	scenarioName := bone.GetValue(req, "scenario")
	stuboURI := stubo.Protocol + "://" + stubo.Hostname + ":" + stubo.Port

	stubs, err := client.getScenarioStubs(stuboURI, scenarioName)
	if err != nil {
		http.Error(rw, "Failed to get scenario stubs from Stubo!", 400)
		return
	}

	newmap := map[string]interface{}{"metatitle": "Scenario Stubs", "Scenario": scenarioName, "Stubo": stubo, "Stubs": stubs}
	h.r.HTML(rw, http.StatusOK, "scenarioStubs", newmap)
}
Esempio n. 2
0
func varHandler(rw http.ResponseWriter, req *http.Request) {
	varr := bone.GetValue(req, "var")
	test := bone.GetValue(req, "test")
	log.Println("VAR = ", varr)
	log.Println("TEST = ", test)

	rw.Write([]byte(varr + " " + test))
}
Esempio n. 3
0
func (ss *StaticServer) PutKey(rw http.ResponseWriter, req *http.Request) {
	key := bone.GetValue(req, "key")
	value := bone.GetValue(req, "value")
	ss.setS3RootIfPresent(key, value)

	if err := ss.mkv.Upsert(key, value); err != nil {
		util.WriteError(rw, "STAT-201", err)
		return
	}
	util.WriteJSON(rw, value)
}
Esempio n. 4
0
func (ss *StaticServer) GetIDForHash(rw http.ResponseWriter, req *http.Request) {
	name := bone.GetValue(req, "idname")
	hash := bone.GetValue(req, "hash")

	id, err := ss.mkv.GetIDFor(name, hash)

	if err != nil {
		util.WriteError(rw, "STAT-251", err)
		return
	}
	util.WriteJSON(rw, id)
}
Esempio n. 5
0
// Get the ADCP from the given serial number value.
func vaultAPIAdcpSerialGetHandler(w http.ResponseWriter, r *http.Request) {
	// Get the value of the "id" parameters.
	id := bone.GetValue(r, "id")

	switch r.Method {
	case "GET":
		{
			adcp := getAdcp(id)

			fmt.Printf("Get ADCP from serial: %s  %v", id, adcp)

			// Set data type and OK status
			w.Header().Set("Content-Type", "application/json; charset=UTF-8")
			w.WriteHeader(http.StatusOK)

			if err := json.NewEncoder(w).Encode(adcp); err != nil {
				panic(err)
			}
		}
	case "POST":
		{

		}
	default:
		{

		}

	}
}
Esempio n. 6
0
func DeliveryHandler(w http.ResponseWriter, r *http.Request) {
	keyId := bone.GetValue(r, "key")
	c := appengine.NewContext(r)
	key, err := datastore.DecodeKey(keyId)
	var dbRequest MainRequest
	if err = datastore.Get(c, key, &dbRequest); err != nil {
		c.Errorf("%s", err)
	}

	var status *postmates.Status

	if dbRequest.Pm_delivery_id == "" {
		status, err = postmates.RescueDelivery(c)
		if status != nil {
			dbRequest.Pm_delivery_id = status.ID
			if _, err := datastore.Put(c, key, &dbRequest); err != nil {
				c.Errorf("%s", err)
			}
		}
	} else {
		status, err = postmates.GetStatus(c, dbRequest.Pm_delivery_id)
		if err != nil {
			c.Errorf("%s", err)
		}
	}

	// send back important info
	err = json.NewEncoder(w).Encode(&status)
	if err != nil {
		c.Errorf("%s", err)
	}
}
Esempio n. 7
0
func (h *DBHandler) stuboDetailedHandler(rw http.ResponseWriter, req *http.Request) {
	id := bone.GetValue(req, "id")
	u, err := strconv.ParseUint(id, 10, 64)
	if err != nil {
		http.Error(rw, "Bad stubo ID.", 400)
		return
	}
	var stubo Stubo
	// getting stubo from database
	stubo = h.getStuboDetails(u)
	stuboURI := stubo.Protocol + "://" + stubo.Hostname + ":" + stubo.Port

	// getting all scenarios
	client := &Client{&http.Client{}}
	scenarios, err := client.getScenarios(stuboURI)
	if err != nil {
		http.Error(rw, "Failed to get scenarios from Stubo!", 400)
		return
	}
	log.WithFields(log.Fields{
		"id":             id,
		"url_path":       req.URL.Path,
		"scenario_count": len(scenarios),
	}).Info("Stubo details fetched")

	newmap := map[string]interface{}{"metatitle": "Stubo Details", "Stubo": stubo, "Scenarios": scenarios}
	h.r.HTML(rw, http.StatusOK, "stuboDetails", newmap)
}
Esempio n. 8
0
/**
 * GetDevice()
 */
func GetDevice(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json; charset=utf-8")

	Db := db.MgoDb{}
	Db.Init()
	defer Db.Close()

	id := bone.GetValue(r, "device_id")

	result := models.Device{}
	err := Db.C("devices").Find(bson.M{"id": id}).One(&result)
	if err != nil {
		log.Print(err)
		w.WriteHeader(http.StatusNotFound)
		str := `{"response": "not found", "id": "` + id + `"}`
		if err != nil {
			log.Print(err)
		}
		io.WriteString(w, str)
		return
	}

	w.WriteHeader(http.StatusOK)
	res, err := json.Marshal(result)
	if err != nil {
		log.Print(err)
	}
	io.WriteString(w, string(res))
}
Esempio n. 9
0
// Handle a request tho the root reesource
func usernameHandler(w http.ResponseWriter, r *http.Request) {
	username := bone.GetValue(r, "username")

	if err := json.NewEncoder(w).Encode(username); err != nil {
		panic(err)
	}
}
Esempio n. 10
0
// Set the Compass Cal Selected value.  This will invert the value that is in the database.
func vaultAPICompassCalSelectGetHandler(w http.ResponseWriter, r *http.Request) {
	// Get the value of the "id" parameters.
	id := bone.GetValue(r, "id")

	switch r.Method {
	case "GET":
		{
			compassCal := getCompassCalResultsID(id)
			compassCal.IsSelected = !compassCal.IsSelected // Invert the value

			// Pass the data back to the database
			updateCompassCal(compassCal)

			fmt.Printf("given CompassCal: %v\n", compassCal)

			// Set data type and OK status
			w.Header().Set("Content-Type", "application/json; charset=UTF-8")
			w.WriteHeader(http.StatusOK)

			if err := json.NewEncoder(w).Encode(compassCal); err != nil {
				panic(err)
			}
		}
	case "POST":
		{

		}
	default:
		{

		}

	}
}
Esempio n. 11
0
// Get the ADCP Cert info the given serial number value.
func vaultAPIAdcpCertGetHandler(w http.ResponseWriter, r *http.Request) {
	// Get the value of the "id" parameters.
	serialNum := bone.GetValue(r, "id") // Get the value of the "id" parameters in the URL.

	switch r.Method {
	case "GET":
		{
			adcp := getAdcp(serialNum)                                 // Get the ADCP data from the DB
			adcpCert := &AdcpCert{Adcp: *adcp}                         // Set the ADCP to struct
			adcpCert.CompassCal = getCompassCalCertData(serialNum)     // Get Compass Cal from the DB
			adcpCert.TankTest = getTankTestResultCertData(serialNum)   // Get Tank Test from the DB
			adcpCert.SnrTest = getSnrTestResultCertData(serialNum)     // Get SNR Test from the DB
			adcpCert.WaterTest = getWaterTestResultCertData(serialNum) // Get Water Test from the DB

			fmt.Printf("Get ADCP from serial: %s  %v", serialNum, adcpCert)

			// Set data type and OK status
			w.Header().Set("Content-Type", "application/json; charset=UTF-8")
			w.WriteHeader(http.StatusOK)

			if err := json.NewEncoder(w).Encode(adcpCert); err != nil {
				panic(err)
			}
		}
	case "POST":
		{

		}
	default:
		{

		}

	}
}
Esempio n. 12
0
func main() {
	db, err := sql.Open("postgres", "user=laptop dbname=estelle_test sslmode=disable")
	if err != nil {
		log.Fatal(err)
	}

	r := render.New(render.Options{
		Directory:  "views",
		Extensions: []string{".html"},
	})

	mux := bone.New()
	ServeResource := assets.ServeResource
	mux.HandleFunc("/img/", ServeResource)
	mux.HandleFunc("/css/", ServeResource)
	mux.HandleFunc("/js/", ServeResource)

	mux.HandleFunc("/pages", func(w http.ResponseWriter, req *http.Request) {
		rows, err := db.Query("SELECT id, title FROM pages")
		if err != nil {
			log.Fatal(err)
		}
		defer rows.Close()
		type yourtype struct {
			Id    int
			Title string
		}

		s := []yourtype{}
		for rows.Next() {
			var t yourtype
			if err := rows.Scan(&t.Id, &t.Title); err != nil {
				log.Fatal(err)
			}
			fmt.Printf("%s", t.Title)
			s = append(s, t)
		}
		r.HTML(w, http.StatusOK, "foofoo", s)
	})

	mux.HandleFunc("/bar", func(w http.ResponseWriter, req *http.Request) {
		r.HTML(w, http.StatusOK, "bar", nil)
	})

	mux.HandleFunc("/home/:id", func(w http.ResponseWriter, req *http.Request) {
		id := bone.GetValue(req, "id")
		r.HTML(w, http.StatusOK, "index", id)
	})

	mux.HandleFunc("/foo", func(w http.ResponseWriter, req *http.Request) {
		r.HTML(w, http.StatusOK, "foo", nil)
	})

	mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
		r.HTML(w, http.StatusOK, "index", nil)
	})

	http.ListenAndServe(":8080", mux)
}
Esempio n. 13
0
func (ss *StaticServer) RemoveKey(rw http.ResponseWriter, req *http.Request) {
	key := bone.GetValue(req, "key")

	err := ss.mkv.Remove(key)

	if err != nil {
		util.WriteError(rw, "STAT-231", err)
	}
}
Esempio n. 14
0
func dumpHandler(w http.ResponseWriter, r *http.Request) {
	database := bone.GetValue(r, "name")
	ignore := r.FormValue("ignore")
	// ignore=cache*,voting*
	tableIgnore := make([]string, 0)
	if ignore != "" {
		tableIgnore = strings.Split(ignore, ",")
	}
	// limit=5000
	limitStr := r.FormValue("limit")
	var limit int64
	if limitStr != "" {
		var err error
		limit, err = strconv.ParseInt(limitStr, 0, 0)
		if err != nil {
			w.WriteHeader(http.StatusBadRequest)
			w.Write([]byte(`Invalid limit variable supplied`))
			log.Println(err)
			return
		}
	}

	log.Printf("Dump of %s requested from %s", database, r.RemoteAddr)

	dumpReady := make(chan DumpReady, 1)
	dumpSent := make(chan bool, 1)
	dr := &DumpRequest{
		ID:          database,
		Name:        database,
		TableIgnore: tableIgnore,
		Limit:       int(limit),
		Finished:    dumpReady,
		Sent:        dumpSent,
	}
	dumpQueue <- dr

	dur := <-dumpReady
	if dur.Error != nil {
		w.WriteHeader(http.StatusNotFound)
		w.Write([]byte(fmt.Sprint(dur.Error)))
		log.Println(dur.Error)
	} else {
		w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=%s-db-dump.tar.gz", database))
		w.Header().Set("Content-Type", "application/x-gzip")
		w.Header().Set("Content-Transfer-Encoding", "binary")

		http.ServeFile(w, r, dur.File)

		log.Printf("Dump of %s sent to %s", database, r.RemoteAddr)
	}

	//w.(http.Flusher).Flush()

	// Notify that the file has been sent to the client
	dumpSent <- true
}
Esempio n. 15
0
func (ss *StaticServer) GenID(rw http.ResponseWriter, req *http.Request) {
	name := bone.GetValue(req, "idname")

	id, err := ss.mkv.GetNextID(name)

	if err != nil {
		util.WriteError(rw, "STAT-261", err)
	}
	util.WriteJSON(rw, id)
}
Esempio n. 16
0
func ImageHandler(w http.ResponseWriter, r *http.Request) {
	val := bone.GetValue(r, "rows")
	re := regexp.MustCompile("\\d*")
	rowsStr := re.FindString(val)
	rows, err := strconv.Atoi(rowsStr)
	if err != nil {
		fmt.Fprint(w, "Please pass in number of row")
		return
	}
	if rows > 5000 {
		fmt.Fprint(w, "Please pass in a row equal or smaller than 5000")
		return
	}

	cachedImage, ok := cache[rows]
	if ok {
		w.Header().Set("Content-type", "image/png")
		w.Header().Set("Cache-control", "public, max-age=259200")
		w.Write(cachedImage.Bytes())
		return
	}

	ctx, err := cloudAuthContext(r)
	if err == nil {
		rc, err := storage.NewReader(ctx, bucket, rowsStr+".png")
		if err == nil {
			image, err := ioutil.ReadAll(rc)
			rc.Close()
			if err == nil {
				w.Header().Set("Content-type", "image/png")
				w.Header().Set("Cache-control", "public, max-age=259200")
				w.Write(image)
				return
			}
		}
	}

	m := image.NewPaletted(image.Rectangle{Min: image.Point{0, 0}, Max: image.Point{rows, rows}}, bwPalette)

	m.Pix[m.PixOffset(rows-1, 0)] = 1
	for row := 1; row < rows; row++ {
		m.Pix[m.PixOffset(rows-1, row)] = 1
		for j := rows - row; j < rows-1; j++ {
			mid := m.PixOffset(j, row-1)
			left, right := mid-1, mid+1
			m.Pix[m.PixOffset(j, row)] = rulesUint8[m.Pix[left]][m.Pix[mid]][m.Pix[right]]
		}
	}
	w.Header().Set("Content-type", "image/png")
	w.Header().Set("Cache-control", "public, max-age=259200")
	buf := new(bytes.Buffer)
	png.Encode(buf, m)
	cache[rows] = buf
	w.Write(buf.Bytes())
}
Esempio n. 17
0
func (ss *StaticServer) FindKey(rw http.ResponseWriter, req *http.Request) {
	key := bone.GetValue(req, "key")

	s, err := ss.mkv.FindOne(key)

	if err != nil {
		util.WriteNewWebError(rw, http.StatusNotFound, "STAT-221", "Couldn't find key "+key+": "+err.Error())
		return
	}
	util.WriteJSON(rw, s)
}
Esempio n. 18
0
// stuboDestroyHandler deletes a stubo instance from the db.
func (h *DBHandler) stuboDestroyHandler(rw http.ResponseWriter, req *http.Request) {
	id := bone.GetValue(req, "id")
	stubo := Stubo{}
	h.db.Delete(&stubo, id)

	log.WithFields(log.Fields{
		"id":       id,
		"url_path": req.URL.Path,
	}).Info("Stubo deleted")

	h.r.JSON(rw, http.StatusOK, map[string]string{"data": "Stubo instance deleted!"})
}
Esempio n. 19
0
// Get the Ringing Tank Test data with the given serial number from the vault.
func vaultAPITankSelectedSerialRingingHandler(w http.ResponseWriter, r *http.Request) {
	// Get the value of the "id" parameters.
	serial := bone.GetValue(r, "id")

	// Set data type and OK status
	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
	w.WriteHeader(http.StatusOK)

	if err := json.NewEncoder(w).Encode(getTankTestResultsSelectedType(serial, "Ringing")); err != nil {
		panic(err)
	}
}
Esempio n. 20
0
// RedirectKey return a http.Handler that redirects to the URL in the store
func RedirectKey(store storage.Database) func(http.ResponseWriter, *http.Request) {
	return func(w http.ResponseWriter, r *http.Request) {
		key := bone.GetValue(r, "key")

		status, err := store.Get(key)
		if err != nil {
			http.Error(w, err.Error(), http.StatusNotFound)
		} else {
			store.Incr(key)
			http.Redirect(w, r, html.EscapeString(status.URL), 301)
		}
	}
}
Esempio n. 21
0
// Update the Product.
func productUpdateHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method == "GET" {

		// Get the value of the "id" parameters.
		productNum := bone.GetValue(r, "id")
		product := getProduct(productNum)
		productData := &ProductUpdate{}
		productData.Product = *product

		displayProductUpdateTemplate(w, productData)
	} else {
		// Parse the form
		formData, err := forms.Parse(r)
		CheckError(err)

		// Check token
		token := r.Form.Get("token")
		if token != "" {
			// check token validity
			fmt.Println("Good token")
		} else {
			// give error if no token
			fmt.Println("Bad token")
		}

		// Validate data
		val := formData.Validator()
		val.Require("PartNumber")

		// Use data to create a user object
		product := getProduct(formData.Get("PartNumber"))
		product.PartNumber = formData.Get("PartNumber")
		product.Desc = formData.Get("Desc")
		product.ReferenceDes = formData.Get("ReferenceDes")
		product.UnitPrice = formData.GetFloat("UnitPrice")
		product.ListPrice = formData.GetFloat("ListPrice")
		product.Type = formData.Get("Type")
		product.Qty = formData.GetInt("Qty")
		product.UnitOfMeasure = formData.Get("UnitOfMeasure")
		product.Cost = formData.GetFloat("Cost")
		product.Modified = time.Now().Local()

		fmt.Printf("Product Update: %s\n", product.PartNumber)

		// Update the Product in DB
		updateProduct(product)

		// Go to the list of Products
		http.Redirect(w, r, "/product", http.StatusFound)
	}
}
Esempio n. 22
0
func GetMovie(rw http.ResponseWriter, req *http.Request) {
	id := bone.GetValue(req, "id")
	movie := &Movie{}
	err := db.C("movie").FindId(bson.ObjectIdHex(id)).One(movie)
	if err != nil {
		errLog.NewHTTPErr("NOT FOUND", "This movie doesn't exist").LogHTTP(req).SendHTTP(rw, 404)
		return
	}
	err = json.NewEncoder(rw).Encode(movie)
	if err != nil {
		errLog.NewHTTPErr("NOT FOUND", err).LogHTTP(req).SendHTTP(rw, 404)
		return
	}
}
Esempio n. 23
0
func (p *proxyAdminServer) DeleteProxyIteraction(response http.ResponseWriter, request *http.Request) {
	idString := bone.GetValue(request, "id")

	id := uuid.Parse(idString)

	p.Db.Update(func(tx *bolt.Tx) error {

		b := tx.Bucket([]byte("Proxies"))
		err := b.Delete([]byte(id))

		return err
	})

	response.WriteHeader(204)
}
Esempio n. 24
0
/**
 * UpdateChannel()
 */
func UpdateChannel(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json; charset=utf-8")

	Db := db.MgoDb{}
	Db.Init()
	defer Db.Close()

	data, err := ioutil.ReadAll(r.Body)
	if err != nil {
		panic(err)
	}

	if len(data) == 0 {
		w.WriteHeader(http.StatusBadRequest)
		str := `{"response": "no data provided"}`
		io.WriteString(w, str)
		return
	}

	var body map[string]interface{}
	if err := json.Unmarshal(data, &body); err != nil {
		panic(err)
	}

	/**
	if validateJsonSchema("channel", body) != true {
		println("Invalid schema")
		w.WriteHeader(http.StatusBadRequest)
		str := `{"response": "invalid json schema in request"}`
		io.WriteString(w, str)
		return
	}
	**/

	id := bone.GetValue(r, "channel_id")

	// Publish the channel update.
	// This will be catched by the MQTT main client (subscribed to all channel topics)
	// and then written in the DB in the MQTT handler
	token := clients.MqttClient.Publish("mainflux/"+id, 0, false, string(data))
	token.Wait()

	// Wait on status from MQTT handler (which executes DB write)
	status := <-clients.WriteStatusChannel
	w.WriteHeader(status.Nb)
	str := `{"response": "` + status.Str + `"}`
	io.WriteString(w, str)
}
Esempio n. 25
0
func (ss *StaticServer) PostKey(rw http.ResponseWriter, req *http.Request) {
	key := bone.GetValue(req, "key")

	body, err := ioutil.ReadAll(req.Body)
	if err != nil {
		util.WriteWebError(rw, util.NewWebError(http.StatusBadRequest, "STAT-211", err.Error()))
	}
	b := string(body)
	value := getJSON(b)
	ss.setS3RootIfPresent(key, value)

	if err := ss.mkv.Upsert(key, value); err != nil {
		util.WriteError(rw, "STAT-212", err)
		return
	}
	util.WriteJSON(rw, value)
}
Esempio n. 26
0
// Display the RMA Report
func rmaReportHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Println("method:", r.Method) // get request method

	if r.Method == "GET" {

		rmaID := bone.GetValue(r, "id") // Get the value of the "id" parameters in the URL.
		rma := getRma(rmaID)            // Get the RMA
		rmaReport := &RmaReport{}       // Set the RMA Report
		rmaReport.RMA = *rma

		t, _ := template.ParseFiles("header.html", "rma_report.html", "footer.html")
		t.ExecuteTemplate(w, "header", nil)
		t.ExecuteTemplate(w, "content", rmaReport)
		t.ExecuteTemplate(w, "footer", nil)
		t.Execute(w, rmaReport)
	}
}
Esempio n. 27
0
func GetMovieByTitle(rw http.ResponseWriter, req *http.Request) {
	title := bone.GetValue(req, "title")
	movie := &Movie{}
	err := db.C("movie").Find(bson.M{"title": title}).One(movie)
	if err != nil {
		data := GetMovieData(title)
		err = json.NewEncoder(rw).Encode(&data)
		if err != nil {
			errLog.NewHTTPErr("NOT FOUND", "This movie doesn't exist").LogHTTP(req).SendHTTP(rw, 404)
			return
		}
		return
	}
	err = json.NewEncoder(rw).Encode(movie)
	if err != nil {
		errLog.NewHTTPErr("NOT FOUND", err).LogHTTP(req).SendHTTP(rw, 404)
		return
	}
}
Esempio n. 28
0
func RequestHandler(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	keyString := bone.GetValue(r, "key")
	decodedKey, err := datastore.DecodeKey(keyString)
	if err != nil {
		c.Errorf("Error decoding key %s", err)
	}
	var purchase_request MainRequest
	if err = datastore.Get(c, decodedKey, &purchase_request); err != nil {
		c.Errorf("Error retrieving request key from database", err)
	}

	// render the template
	request_template, err := template.ParseFiles("request.html")
	if err != nil {
		c.Errorf("Error parsing template %s", err)
	}
	request_template.ExecuteTemplate(w, "request", purchase_request)
}
Esempio n. 29
0
/**
 * GetChannel()
 */
func GetChannel(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json; charset=utf-8")

	Db := db.MgoDb{}
	Db.Init()
	defer Db.Close()

	id := bone.GetValue(r, "channel_id")

	var vlimit int
	var err error
	s := r.URL.Query().Get("vlimit")
	if len(s) == 0 {
		// Set default limit to -5
		vlimit = -5
	} else {
		vlimit, err = strconv.Atoi(s)
		if err != nil {
			w.WriteHeader(http.StatusBadRequest)
			str := `{"response": "wrong limit"}`
			io.WriteString(w, str)
			return
		}
	}

	result := models.Channel{}
	if err := Db.C("channels").Find(bson.M{"id": id}).
		Select(bson.M{"values": bson.M{"$slice": vlimit}}).
		One(&result); err != nil {
		log.Print(err)
		w.WriteHeader(http.StatusNotFound)
		str := `{"response": "not found", "id": "` + id + `"}`
		io.WriteString(w, str)
		return
	}

	w.WriteHeader(http.StatusOK)
	res, err := json.Marshal(result)
	if err != nil {
		log.Print(err)
	}
	io.WriteString(w, string(res))
}
Esempio n. 30
0
// Update the ADCP data
func adcpCertHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Println("method:", r.Method) // get request method

	if r.Method == "GET" {

		serialNum := bone.GetValue(r, "id")                        // Get the value of the "id" parameters in the URL.
		adcp := getAdcp(serialNum)                                 // Get the ADCP data from the DB
		adcpCert := &AdcpCert{Adcp: *adcp}                         // Set the ADCP to struct
		adcpCert.CompassCal = getCompassCalCertData(serialNum)     // Get Compass Cal from the DB
		adcpCert.TankTest = getTankTestResultCertData(serialNum)   // Get Tank Test from the DB
		adcpCert.SnrTest = getSnrTestResultCertData(serialNum)     // Get SNR Test from the DB
		adcpCert.WaterTest = getWaterTestResultCertData(serialNum) // Get Water Test from the DB

		t, _ := template.ParseFiles("header.html", "adcp_cert.html", "footer.html")
		t.ExecuteTemplate(w, "header", nil)
		t.ExecuteTemplate(w, "content", adcpCert)
		t.ExecuteTemplate(w, "footer", nil)
		t.Execute(w, adcpCert)
	}
}