package main

import (

	"encoding/json"

	"fmt"

	//"io/ioutil"

	"log"

	"net/http"

	"net/url"

	"os"

	"strings"

	"time"

)

const IssueURL = "https://api.github.com/search/issues"

type IssuesSearchResult struct {

	TotalCount int `json:"total_count"`

	Items      []*Issue

}

type Issue struct {

	Number   int

	HTMLURL  string `json:"html_url"`

	Title    string

	State    string

	User     *User

	CreateAt time.Time `json:"create_at"`

	Body     string

}

type User struct {

	Login   string

	HTMLURL string `json:"html_url"`

}

func SearchIssues(terms []string) (*IssuesSearchResult, error) {

	q := url.QueryEscape(strings.Join(terms, " "))

	urls := IssueURL + "?q=" + q

	resp, err := http.Get(urls)

	if err != nil {

		return nil, err

	}

	defer resp.Body.Close()

	fmt.Println("start encode ...")

	/*web, err := ioutil.ReadAll(resp.Body)

	if err != nil {

		return nil, err

	}

	fmt.Printf("web:%s\n==============\n", web)

	*/

	if resp.StatusCode != http.StatusOK {

		return nil, fmt.Errorf("search query failed: %s", resp.Status)

	}

	var result IssuesSearchResult

	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {

		return nil, err

	}

	return &result, nil

}

func main() {

	result, err := SearchIssues(os.Args[1:])

	if err != nil {

		log.Fatal(err)

	}

	fmt.Printf("%d issue: \n", result.TotalCount)

	for _, item := range result.Items {

		fmt.Printf("#<%-5d> <%9.9s> <%.55s>\n\n", item.Number, item.User.Login, item.Title)

	}

}

package  main

import (

        "encoding/json"

        "fmt"

        "html"

        "io/ioutil"

        "log"

        "net/http"

)

type Cmd struct {

        ReqType int

        FileName string

}

func main() {

        http.HandleFunc("/bar", func (w http.ResponseWriter, r *http.Request){

                fmt.Fprintf(w, "Hello, %q", html.EscapeString(r.URL.Path))

                if r.Method == "POST" {

                        b, err := ioutil.ReadAll(r.Body)

                        if err != nil {

                                log.Println("Read failed:", err)

                        }

                        defer r.Body.Close()

                        cmd := &Cmd{}

                        err = json.Unmarshal(b, cmd)

                        if err != nil {

                                log.Println("json format error:", err)

                        }

                        log.Println("cmd:", cmd)

                } else {

                        log.Println("ONly support Post")

                        fmt.Fprintf(w, "Only support post")

                }

        })

        log.Fatal(http.ListenAndServe(":8080", nil))

}

//post json

package main

import (

    "bytes"

    "encoding/json"

    "io/ioutil"

    "log"

    "net/http"

)

type Cmd struct {

    ReqType int

    FileName string

}

func main() {

    url := "http://127.0.0.1:8080/bar"

    contentType := "application/json;charset=utf-8"

    cmd := Cmd{ReqType: 12, FileName: "plugin"}

    b ,err := json.Marshal(cmd)

    if err != nil {

        log.Println("json format error:", err)

        return

    }

    body := bytes.NewBuffer(b)

    resp, err := http.Post(url, contentType, body)

    if err != nil {

        log.Println("Post failed:", err)

        return

    }

    defer resp.Body.Close()

    content, err := ioutil.ReadAll(resp.Body)

    if err != nil {

        log.Println("Read failed:", err)

        return

    }

    log.Println("content:", string(content))

}