gpxhydrant/osm/osm.go

package osm

import (
	"bytes"
	"encoding/xml"
	"fmt"
	"io"
	"io/ioutil"
	"math"
	"net/http"
	"strconv"
	"time"
)

const (
	liveAPIBaseURL = "http://api.openstreetmap.org/api/0.6"
	devAPIBaseURL  = "http://api06.dev.openstreetmap.org/api/0.6"
)

// Client represents an OSM client which is capable of RW operations on the OpenStreetMap
type Client struct {
	username string
	password string

	APIBaseURL  string
	HTTPClient  *http.Client
	CurrentUser *User

	DebugHTTPRequests bool
}

// New instantiates a new client and retrieves information about the current user. Set useDevServer to true to change the API URL to the api06.dev.openstreetmap.org server.
func New(username, password string, useDevServer bool) (*Client, error) {
	out := &Client{
		username: username,
		password: password,

		APIBaseURL: liveAPIBaseURL,
		HTTPClient: http.DefaultClient,

		DebugHTTPRequests: false,
	}

	if useDevServer {
		out.APIBaseURL = devAPIBaseURL
	}

	u := &Wrap{User: &User{}}
	if err := out.doParse("GET", "/user/details", nil, u); err != nil {
		return nil, err
	}
	out.CurrentUser = u.User

	return out, nil
}

func (c *Client) doPlain(method, path string, body io.Reader) (string, error) {
	responseBody, err := c.do(method, path, body)
	if err != nil {
		return "", err
	}
	defer responseBody.Close()

	data, err := ioutil.ReadAll(responseBody)
	if err != nil {
		return "", err
	}

	return string(data), nil
}

func (c *Client) do(method, path string, body io.Reader) (io.ReadCloser, error) {
	var reqBodyBuffer *bytes.Buffer = nil
	if body != nil {
		reqBodyBuffer = bytes.NewBufferString("")
		io.Copy(reqBodyBuffer, body)

		body = bytes.NewBuffer(reqBodyBuffer.Bytes())
	}

	req, _ := http.NewRequest(method, c.APIBaseURL+path, body)
	req.SetBasicAuth(c.username, c.password)

	if method != "GET" {
		req.Header.Set("Content-Type", "text/xml; charset=utf-8")
	}

	res, err := c.HTTPClient.Do(req)
	if err != nil {
		return nil, err
	}

	resBody := bytes.NewBufferString("")
	io.Copy(resBody, res.Body)

	if c.DebugHTTPRequests {
		buf := bytes.NewBufferString("")
		fmt.Fprintf(buf, "---------- REQUEST ----------\n")
		fmt.Fprintf(buf, "%s %s\n", method, req.URL.String())
		for k, v := range req.Header {
			fmt.Fprintf(buf, "%s: %s\n", k, v[0])
		}
		fmt.Fprintf(buf, "\n")
		if reqBodyBuffer != nil {
			trunc := int(math.Min(float64(reqBodyBuffer.Len()), 1024))
			fmt.Fprintf(buf, "%s\n\n", reqBodyBuffer.String()[0:trunc])
		}

		fmt.Fprintf(buf, "---------- RESPONSE ----------\n")
		for k, v := range res.Header {
			fmt.Fprintf(buf, "%s: %s\n", k, v[0])
		}
		fmt.Fprintf(buf, "\n")
		trunc := int(math.Min(float64(resBody.Len()), 1024))
		fmt.Fprintf(buf, "%s\n", resBody.String()[0:trunc])

		fmt.Println(buf.String())
	}

	if res.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("OSM API responded with status code %d", res.StatusCode)
	}

	return ioutil.NopCloser(resBody), nil
}

func (c *Client) doParse(method, path string, body io.Reader, output interface{}) error {
	responseBody, err := c.do(method, path, body)
	if err != nil {
		return err
	}
	defer responseBody.Close()

	if output != nil {
		return xml.NewDecoder(responseBody).Decode(output)
	}

	return nil
}

// Wrap is a mostly internal used struct which holds requests to / responses from the API.
// You will get a Wrap object when querying map objects from the API
type Wrap struct {
	XMLName    xml.Name     `xml:"osm"`
	User       *User        `xml:"user,omitempty"`
	Changesets []*Changeset `xml:"changeset,omitempty"`
	Nodes      []*Node      `xml:"node,omitempty"`
}

// Changeset contains information about a changeset in the API. You need to create a changeset before submitting any changes to the API.
type Changeset struct {
	XMLName      xml.Name  `xml:"changeset"`
	ID           int64     `xml:"id,attr,omitempty"`
	User         string    `xml:"user,attr,omitempty"`
	UID          int64     `xml:"uid,attr,omitempty"`
	CreatedAt    time.Time `xml:"created_at,attr,omitempty"`
	ClosedAt     time.Time `xml:"closed_at,attr,omitempty"`
	Open         bool      `xml:"open,attr,omitempty"`
	MinLat       float64   `xml:"min_lat,attr,omitempty"`
	MinLon       float64   `xml:"min_lon,attr,omitempty"`
	MaxLat       float64   `xml:"max_lat,attr,omitempty"`
	MaxLon       float64   `xml:"max_lon,attr,omitempty"`
	CommentCount int64     `xml:"comments_count,attr,omitempty"`

	Tags []Tag `xml:"tag"`
}

// GetMyChangesets retrieves a list of (open) changesets from the API
func (c *Client) GetMyChangesets(onlyOpen bool) ([]*Changeset, error) {
	urlPath := fmt.Sprintf("/changesets?user=%d&open=%s", c.CurrentUser.ID, strconv.FormatBool(onlyOpen))

	r := &Wrap{}
	return r.Changesets, c.doParse("GET", urlPath, nil, r)
}

// CreateChangeset creates a new changeset
func (c *Client) CreateChangeset() (*Changeset, error) {
	body := bytes.NewBufferString(xml.Header)

	enc := xml.NewEncoder(body)
	enc.Indent("", " ")

	if err := enc.Encode(Wrap{Changesets: []*Changeset{{}}}); err != nil {
		return nil, err
	}

	res, err := c.doPlain("PUT", "/changeset/create", body)
	if err != nil {
		return nil, err
	}

	cs := &Wrap{}
	if err := c.doParse("GET", fmt.Sprintf("/changeset/%s", res), nil, cs); err != nil {
		return nil, err
	}

	if len(cs.Changesets) != 1 {
		return nil, fmt.Errorf("Unable to retrieve new changeset #%s", res)
	}

	return cs.Changesets[0], nil
}

// SaveChangeset updates or creates a changeset
func (c *Client) SaveChangeset(cs *Changeset) error {
	urlPath := "/changeset/create"

	if cs.ID > 0 {
		urlPath = fmt.Sprintf("/changeset/%d", cs.ID)
	}

	data := Wrap{Changesets: []*Changeset{cs}}

	body := bytes.NewBufferString(xml.Header)

	enc := xml.NewEncoder(body)
	enc.Indent("", " ")

	if err := enc.Encode(data); err != nil {
		return err
	}

	_, err := c.doPlain("PUT", urlPath, body)
	return err
}

// RetrieveMapObjects queries all objects within the passed bounds. You need to ensure the min values are below the max values.
func (c *Client) RetrieveMapObjects(minLat, minLon, maxLat, maxLon float64) (*Wrap, error) {
	urlPath := fmt.Sprintf("/map?bbox=%.7f,%.7f,%.7f,%.7f", minLat, minLon, maxLat, maxLon)
	res := &Wrap{}
	return res, c.doParse("GET", urlPath, nil, res)
}

// User contains information about an User in the OpenStreetMap
type User struct {
	XMLName        xml.Name  `xml:"user"`
	ID             int64     `xml:"id,attr"`
	DisplayName    string    `xml:"display_name,attr"`
	AccountCreated time.Time `xml:"account_created,attr"`

	Description string `xml:"description"`
}

// Node represents one node in the OpenStreetMap
type Node struct {
	XMLName   xml.Name `xml:"node"`
	ID        int64    `xml:"id,attr,omitempty"`
	Version   int64    `xml:"version,attr,omitempty"`
	Changeset int64    `xml:"changeset,attr,omitempty"`
	User      string   `xml:"user,attr,omitempty"`
	UID       int64    `xml:"uid,attr,omitempty"`
	Latitude  float64  `xml:"lat,attr"`
	Longitude float64  `xml:"lon,attr"`

	Tags []Tag `xml:"tag"`
}

// SaveNode creates or updates a node with an association to the passed changeset which needs to be open and known to the API.
func (c *Client) SaveNode(n *Node, cs *Changeset) error {
	if n.ID > 0 && n.Version == 0 {
		return fmt.Errorf("When an ID is set the version must be present")
	}

	urlPath := "/node/create"

	if n.ID > 0 {
		urlPath = fmt.Sprintf("/node/%d", n.ID)
	}

	n.Changeset = cs.ID

	data := Wrap{Nodes: []*Node{n}}

	body := bytes.NewBufferString(xml.Header)

	enc := xml.NewEncoder(body)
	enc.Indent("", " ")

	if err := enc.Encode(data); err != nil {
		return err
	}

	_, err := c.doPlain("PUT", urlPath, body)
	return err
}

// Tag represents a key-value pair used in all objects inside OpenStreetMap
type Tag struct {
	XMLName xml.Name `xml:"tag"`
	Key     string   `xml:"k,attr"`
	Value   string   `xml:"v,attr"`
}