Golang common.CheckError函数代码示例

func saveBandRecordToConcertHandler(rw http.ResponseWriter, req *http.Request) {
	err := req.ParseForm()
	common.CheckError(err)
	form := req.Form

	concertId, err := strconv.ParseInt(form["concert_id"][0], 10, 64)
	common.CheckError(err)

	bandId, err := strconv.ParseInt(form["band_id"][0], 10, 64)

	dbmap := db.InitDb(BandConcert{}, "band_concert")
	defer dbmap.Db.Close()

	bandConcert := BandConcert{BandId: bandId, ConcertId: concertId}
	err = dbmap.SelectOne(&bandConcert, "SELECT * FROM concertsap.concert_band WHERE band_id=? AND concert_id=?", bandConcert.BandId, bandConcert.ConcertId)

	if err != nil {
		insertBandConcert(bandConcert)
		err = dbmap.SelectOne(&bandConcert, "SELECT * FROM concertsap.concert_band WHERE band_id=? AND concert_id=?", bandConcert.BandId, bandConcert.ConcertId)
	}

	formDate := form["date"][0]
	formTime := form["time"][0]
	bandConcertRecord := BandConcertRecord{BandId: bandConcert.BandId, ConcertId: bandConcert.ConcertId, Date: formDate, Time: formTime}
	insertBandConcertRecord(bandConcertRecord)

	http.Redirect(rw, req, "addBandRecordToConcert", http.StatusFound)
}

func addHandler(rw http.ResponseWriter, req *http.Request) {
	if req.Method == "POST" {
		dbmap := db.InitDb(Retailer{}, "retailer")
		defer dbmap.Db.Close()

		err := req.ParseForm()
		common.CheckError(err)
		form := req.Form

		err = dbmap.Insert(&Retailer{Name: form["name"][0], Website: form["website"][0]})
		common.CheckError(err)
	}

	type Page struct {
		PageName string
		Title    string
	}

	p := Page{
		PageName: "retailer",
		Title:    "Add Controller",
	}

	common.Templates = template.Must(template.ParseFiles("templates/retailer/add.html", common.LayoutPath))
	err := common.Templates.ExecuteTemplate(rw, "base", p)
	common.CheckError(err)
}

func saveBandsToConcertHandler(rw http.ResponseWriter, req *http.Request) {
	dbmap := db.InitDb(Band{}, "band")
	defer dbmap.Db.Close()

	err := req.ParseForm()
	common.CheckError(err)
	form := req.Form

	concertId, err := strconv.ParseInt(form["concert_id"][0], 10, 64)
	common.CheckError(err)

	r, err := regexp.Compile(`([^<]+)<br>`)
	common.CheckError(err)
	rawBands := form["parsedInput"][0]
	bandMatches := r.FindAllStringSubmatch(rawBands, -1)

	for _, bandName := range bandMatches {
		newBand := Band{Name: bandName[1]}
		err = dbmap.SelectOne(&newBand, "SELECT * FROM concertsap.band WHERE name=?", strings.ToUpper(newBand.Name))

		if err != nil {
			insertBand(newBand)
			err = dbmap.SelectOne(&newBand, "SELECT * FROM concertsap.band WHERE name=?", newBand.Name)
		}

		newBandConcert := BandConcert{BandId: newBand.Id, ConcertId: concertId}
		insertBandConcert(newBandConcert)
	}

	http.Redirect(rw, req, "addBandsToConcert", http.StatusFound)
}

func userViewOneHandler(rw http.ResponseWriter, req *http.Request) {
	params := mux.Vars(req)
	id := params["id"]

	type Page struct {
		PageName     string
		Title        string
		Concert      Concert
		ConcertState int
		UntilDays    int
	}

	concert := FindOne(id)

	var concertState int
	var untilDays int

	tStart, terr := time.Parse("2006-01-02 15:04:05", concert.Start+" 23:59:59")
	common.CheckError(terr)

	tEnd, terr := time.Parse("2006-01-02 15:04:05", concert.End+" 23:59:59")
	common.CheckError(terr)

	if time.Now().After(tEnd) {
		// Concert is in the past - concertState = 1
		concertState = 1
		untilDays = int(time.Since(tEnd).Hours()/24) + 1
	} else if time.Now().After(tStart) {
		// Concert is now! - concertState = 2
		concertState = 2
		untilDays = int(time.Since(tEnd).Hours()/24) + 1
	} else {
		// Concert is in the future - concertState = 3
		concertState = 3
		untilDays = -1*int(time.Since(tStart).Hours()/24) + 1
	}

	p := Page{
		PageName:     "user_concert",
		Title:        "View One Controller: " + id,
		Concert:      concert,
		ConcertState: concertState,
		UntilDays:    untilDays,
	}

	common.Templates = template.Must(template.ParseFiles("templates/concert/userViewOne.html", common.LayoutPath))
	err := common.Templates.ExecuteTemplate(rw, "base", p)
	common.CheckError(err)
}

func addHandler(rw http.ResponseWriter, req *http.Request) {
	type Page struct {
		PageName  string
		Title     string
		Concerts  []concert.Concert
		Retailers []retailer.Retailer
		Now       string
	}

	concerts := concert.FindAll()
	retailers := retailer.FindAll()
	t := time.Now()

	p := Page{
		PageName:  "ticket",
		Title:     "Add Controller",
		Concerts:  concerts,
		Retailers: retailers,
		Now:       t.Format("2006-01-02 15:04:05"),
	}

	common.Templates = template.Must(template.ParseFiles("templates/ticket/add.html", common.LayoutPath))
	err := common.Templates.ExecuteTemplate(rw, "base", p)
	common.CheckError(err)
}

func FindBandConcert(concertId string) []BandJoinedConcert {
	dbmap := db.InitDb(BandConcert{}, "band_concert")
	defer dbmap.Db.Close()

	var concertIdString string

	if concertId != "" {
		concertIdString = "AND c.id = " + concertId
	}

	var bandConcerts []BandJoinedConcert
	_, err := dbmap.Select(&bandConcerts, `
        SELECT b.id AS band_id,
            b.name AS band_name,
            b.website AS band_website,
            c.id AS concert_id,
            c.name AS concert_name,
            c.address AS concert_address,
            c.state_id AS concert_state_id,
            c.website AS concert_website,
            c.start AS concert_start,
            c.end AS concert_end
        FROM band_concert bc
        JOIN band b
        ON b.id = bc.band_id
        JOIN concert c
        ON c.id = bc.concert_id
        `+concertIdString+`
        ORDER BY b.name`)
	common.CheckError(err)

	return bandConcerts
}

func ConcertBandHandler(rw http.ResponseWriter, req *http.Request) {
	params := mux.Vars(req)
	id := params["id"]

	json, err := json.Marshal(band.FindBandConcert(id))
	common.CheckError(err)

	fmt.Fprintf(rw, "%v", string(json))
}

func FindOne(id string) Concert {
	dbmap := db.InitDb(Concert{}, "concert")
	defer dbmap.Db.Close()

	var concert Concert
	err := dbmap.SelectOne(&concert, "SELECT * FROM concert WHERE id = ? ORDER BY name", id)
	common.CheckError(err)

	return concert
}

func FindAll() []Concert {
	dbmap := db.InitDb(Concert{}, "concert")
	defer dbmap.Db.Close()

	var concerts []Concert
	_, err := dbmap.Select(&concerts, "SELECT * FROM concert ORDER BY name")
	common.CheckError(err)

	return concerts
}

func FindOne(id string) Band {
	dbmap := db.InitDb(Band{}, "band")
	defer dbmap.Db.Close()

	var band Band
	err := dbmap.SelectOne(&band, "SELECT * FROM band WHERE id = ? ORDER BY name", id)
	common.CheckError(err)

	return band
}

func FindBandsAndConcerts() []BandAndConcertsCount {
	dbmap := db.InitDb(Band{}, "band")
	defer dbmap.Db.Close()

	var bandsAndConcertsCount []BandAndConcertsCount
	_, err := dbmap.Select(&bandsAndConcertsCount, "SELECT b.id, b.name, COUNT(*) AS count_count FROM band_concert bc JOIN band b ON bc.band_id = b.id GROUP BY b.id ORDER BY b.name")
	common.CheckError(err)

	return bandsAndConcertsCount
}

func FindAll() []Band {
	dbmap := db.InitDb(Band{}, "band")
	defer dbmap.Db.Close()

	var bands []Band
	_, err := dbmap.Select(&bands, "SELECT * FROM band ORDER BY name")
	common.CheckError(err)

	return bands
}

func saveHandler(rw http.ResponseWriter, req *http.Request) {
	err := req.ParseForm()
	common.CheckError(err)
	form := req.Form

	stateId, err := strconv.ParseInt(common.IssetInForm(form["state_id"], 0), 10, 64)
	common.CheckError(err)

	concert := Concert{
		Name:    common.IssetInForm(form["name"], 0),
		Address: common.IssetInForm(form["address"], 0),
		StateId: stateId,
		Website: common.IssetInForm(form["website"], 0),
		Start:   common.IssetInForm(form["start"], 0),
		End:     common.IssetInForm(form["end"], 0),
	}

	insertConcert(concert)

	http.Redirect(rw, req, "add", http.StatusFound)
}

func InitDb(i interface{}, dbName string) *gorp.DbMap {
	// connect to db using standard Go database/sql API
	// use whatever database/sql driver you wish
	db, err := sql.Open("mysql", "root:@tcp(127.0.0.1:3306)/concertsap")
	common.CheckError(err)

	// construct a gorp DbMap
	dbmap := &gorp.DbMap{Db: db, Dialect: gorp.MySQLDialect{}}

	dbmap.AddTableWithName(i, dbName).SetKeys(true, "id")

	return dbmap
}

func saveHandler(rw http.ResponseWriter, req *http.Request) {
	err := req.ParseForm()
	common.CheckError(err)
	form := req.Form

	retailer := Retailer{
		Name:    common.IssetInForm(form["name"], 0),
		Website: common.IssetInForm(form["website"], 0),
	}

	insertRetailer(retailer)

	http.Redirect(rw, req, "add", http.StatusFound)
}