data_source_menu.go

package main

import (
    "fmt"
    "time"
    "sort"
    "strings"
    "strconv"
    "log"
    "net/http"
    "encoding/json"
    "github.com/hashicorp/terraform/helper/schema"
)

func dataSourceMenu() *schema.Resource {
	return &schema.Resource{
		Read:   resourceMenuRead,
		Schema: map[string]*schema.Schema{
		"store_id": &schema.Schema{
				Type:     schema.TypeString,
				Required: true,
			},
        "menu": &schema.Schema{
				Type:     schema.TypeList,
				Computed: true,
                Elem: &schema.Resource{
                    Schema: map[string]*schema.Schema{
                        "name": &schema.Schema{
                            Type: schema.TypeString,
                            Computed: true,
                        },
                        "code": &schema.Schema{
                            Type: schema.TypeString,
                            Computed: true,
                        },
                        "price_cents": &schema.Schema{
                            Type: schema.TypeInt,
                            Computed: true,
                        },
                    },
                },
			},
        },
    }
}

func resourceMenuRead(d *schema.ResourceData, m interface{}) error {
    var client = &http.Client{Timeout: 10 * time.Second}
    store_id := d.Get("store_id").(string)
    menuitems, err := getAllMenuItems(fmt.Sprintf("https://order.dominos.com/power/store/%s/menu?lang=en&structured=true", store_id), client)
    if err != nil {
        return err
    }
    menu := make([]map[string]interface{}, 0, len(menuitems))
    for i := range menuitems {
        menu = append(menu, map[string]interface{}{"name": menuitems[i].Name, "code": menuitems[i].Code, "price_cents": menuitems[i].PriceCents})
    }
    if err := d.Set("menu", menu); err != nil {
        return err
    }
    log.Printf("len menu: %d", len(menu))
    d.SetId(store_id)
    return nil
}

type MenuItem struct {
    Code string
    Name string
    PriceCents int64
}

func getMenuApiObject(url string, client *http.Client) (map[string]interface{}, error) {
    r, err := client.Get(url)
    if err != nil {
        return nil, err
    }
    defer r.Body.Close()
    resp := make(map[string]interface{})
    err = json.NewDecoder(r.Body).Decode(&resp)
    return resp, err
}

func getAllMenuItems(url string, client *http.Client) ([]MenuItem, error) {
    resp, err := getMenuApiObject(url, client)
    if err != nil {
        return nil, err
    }
    products := resp["Variants"].(map[string]interface{})
    all_products := make([]MenuItem, 0, len(products))
    log.Printf("len products: %d", len(products))
    for name, d := range products {
        dict := d.(map[string]interface{})
        price := dict["Price"].(string)
        price = strings.Replace(price, ".", "", 1)
        price_cents, err := strconv.ParseInt(price, 10, 64)
        if err != nil {
            continue
        }
        all_products = append(all_products, MenuItem{
            Code: name,
            Name: dict["Name"].(string),
            PriceCents: price_cents,
        })
    }
    sort.Slice(all_products, func(i, j int) bool {
        return all_products[i].Code < all_products[j].Code
    })
    // for each entry in Products, make a MenuItem struct and return it.
    return all_products, nil
}