package main

    import (
        "context"
        "fmt"
        "html/template"
        "net/http"
        "simplystdatastore/config"
        "strconv"

        "github.com/gorilla/mux"

        "cloud.google.com/go/datastore"
    )

    type user struct {
        ID       int64
        UserName string
        Password string
        First    string
        Last     string
    }

    var tpl *template.Template

    func init() {

        tpl = template.Must(template.ParseGlob("templates/*"))

    }

    func main() {

        http.HandleFunc("/", index)
        http.HandleFunc("/signup", signup)
        http.HandleFunc("/edit", signup)
        http.Handle("/favicon.ico", http.NotFoundHandler())
        http.ListenAndServe(":8080", nil)
    }

    func index(w http.ResponseWriter, req *http.Request) {
        var users []*user

        ctx := context.Background()
        // Create a query to fetch all Task entities, ordered by "created".
        query := datastore.NewQuery("user")
        _, err := config.Userkind.GetAll(ctx, query, &users)
        if err != nil {
            fmt.Println(err)
        }
        fmt.Println(query)
        fmt.Println(&users)
        //fmt.Println(keys)
        tpl.ExecuteTemplate(w, "index.html", users)

    }

    func edit(w http.ResponseWriter, req *http.Request) {
        var user *user
        ctx := context.Background()
        id, err := strconv.ParseInt(mux.Vars(req)["id"], 10, 64)

        if err != nil {
            fmt.Println(err)
        }
        k := datastore.IDKey("user", id, nil)

        if _, err := config.Userkind.Put(ctx, k, user); err != nil {
            fmt.Println(err)
        }

        tpl.ExecuteTemplate(w, "edit.html", user)

    }

    func userFromForm(r *http.Request) (*user, error) {
        user := &user{
            UserName: r.FormValue("username"),
            Password: r.FormValue("password"),
            First:    r.FormValue("firstname"),
            Last:     r.FormValue("lastname"),
        }
        return user, nil

    }

    func signup(w http.ResponseWriter, req *http.Request) {

        // process form submission
        if req.Method == http.MethodPost {
            user, err := userFromForm(req)

            if err != nil {
                fmt.Println(err)
            }

            ctx := context.Background()
            k := datastore.IncompleteKey("user", nil)
            k, err = config.Userkind.Put(ctx, k, user)
            if err != nil {
                fmt.Println(err)
            }

            //err = config.Userscollection.Insert(user)

            // redirect
            http.Redirect(w, req, "/", http.StatusSeeOther)
            return
        }

        tpl.ExecuteTemplate(w, "signup.html", nil)
    }

package config

    import (
        "context"
        "fmt"

        "cloud.google.com/go/datastore"
    )

    //Userkind datastore table
    var Userkind *datastore.Client

    func init() {

        projectID := "simplyst-test"

        ctx := context.Background()
        client, err := datastore.NewClient(ctx, projectID)
        if err != nil {
            fmt.Println("Error from init method client call ===>", err)

        }
        t, err := client.NewTransaction(ctx)
        if err != nil {
            fmt.Println("Error from init method NewTransaction  call ===>", err)

        }
        if err := t.Rollback(); err != nil {
            fmt.Println("datastoredb: could not connect", err)
        }

        Userkind = client
        fmt.Println("You connected to your google datastore.")
    }