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)
}
Пример #2
0
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)
}
Пример #4
0
func addHandler(rw http.ResponseWriter, req *http.Request) {
	if req.Method == "POST" {
		dbmap := db.InitDb(State{}, "state")
		defer dbmap.Db.Close()

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

		err = dbmap.Insert(&State{Name: form["name"][0], Acronym: form["acronym"][0]})
		common.CheckError(err)
	}

	type Page struct {
		PageName string
		Title    string
	}

	p := Page{
		PageName: "state",
		Title:    "Add New Concert",
	}

	common.Templates = template.Must(template.ParseFiles("templates/state/add.html", common.LayoutPath))
	err := common.Templates.ExecuteTemplate(rw, "base", p)
	common.CheckError(err)
}
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 userViewOneHandler(rw http.ResponseWriter, req *http.Request) {
	params := mux.Vars(req)
	id := params["id"]

	type Page struct {
		PageName string
		Title    string
		Band     Band
		Concerts []concert.Concert
	}

	band := FindOne(id)
	concerts := concert.FindConcertsByBand(id)

	p := Page{
		PageName: "user_band",
		Title:    "View One Controller: " + id,
		Band:     band,
		Concerts: concerts,
	}

	common.Templates = template.Must(template.ParseFiles("templates/band/userViewOne.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
}
Пример #9
0
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))
}
Пример #10
0
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
}
Пример #11
0
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
}
Пример #12
0
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
}
Пример #13
0
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
}
Пример #14
0
func FindAll() []State {
	dbmap := db.InitDb(State{}, "state")
	defer dbmap.Db.Close()

	var states []State
	_, err := dbmap.Select(&states, "SELECT * FROM state ORDER BY acronym")
	common.CheckError(err)

	return states
}
Пример #15
0
func FindAll() []Ticket {
	dbmap := db.InitDb(Ticket{}, "ticket_record")
	defer dbmap.Db.Close()

	var tickets []Ticket
	_, err := dbmap.Select(&tickets, "SELECT * FROM ticket_records ORDER BY timestamp")
	common.CheckError(err)

	return tickets
}
Пример #16
0
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)
}
Пример #18
0
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) {
	dbmap := db.InitDb(Band{}, "band")
	defer dbmap.Db.Close()

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

	newBand := Band{Name: strings.ToUpper(form["name"][0]), Website: form["website"][0]}
	insertBand(newBand)

	http.Redirect(rw, req, "add", http.StatusFound)
}
Пример #20
0
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)
}
Пример #21
0
func saveHandler(rw http.ResponseWriter, req *http.Request) {
	err := req.ParseForm()
	common.CheckError(err)
	form := req.Form

	state := State{
		Name:    common.IssetInForm(form["name"], 0),
		Acronym: common.IssetInForm(form["acronym"], 0),
	}

	insertState(state)

	http.Redirect(rw, req, "add", http.StatusFound)
}
func addHandler(rw http.ResponseWriter, req *http.Request) {
	type Page struct {
		PageName string
		Title    string
	}

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

	common.Templates = template.Must(template.ParseFiles("templates/band/add.html", common.LayoutPath))
	err := common.Templates.ExecuteTemplate(rw, "base", p)
	common.CheckError(err)
}
Пример #23
0
func loginHandler(rw http.ResponseWriter, req *http.Request) {
	type Page struct {
		PageName string
		Title    string
	}

	p := Page{
		PageName: "login",
		Title:    "Login",
	}

	common.Templates = template.Must(template.ParseFiles("templates/home/login.html", common.LayoutPath))
	err := common.Templates.ExecuteTemplate(rw, "base", p)
	common.CheckError(err)
}
Пример #24
0
func FindConcertsByBand(bandId string) []Concert {
	dbmap := db.InitDb(Concert{}, "concert")
	defer dbmap.Db.Close()

	var concerts []Concert
	_, err := dbmap.Select(&concerts, `
        SELECT c.*
        FROM band_concert bc
        JOIN concert c
        ON c.id = bc.concert_id
        WHERE bc.band_id = ?
        ORDER BY name`, bandId)
	common.CheckError(err)

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

	ticket := Ticket{
		Price:      common.IssetInForm(form["price"], 0),
		ConcertId:  common.IssetInForm(form["concert_id"], 0),
		RetailerId: common.IssetInForm(form["retailer_id"], 0),
		Timestamp:  common.IssetInForm(form["datetime"], 0),
	}

	insertTicket(ticket)

	http.Redirect(rw, req, "add", http.StatusFound)
}
func adminViewOneHandler(rw http.ResponseWriter, req *http.Request) {
	params := mux.Vars(req)
	id := params["id"]

	type Page struct {
		PageName string
		Title    string
	}

	p := Page{
		PageName: "admin_concert",
		Title:    "View One Controller: " + id,
	}

	common.Templates = template.Must(template.ParseFiles("templates/concert/adminViewOne.html", common.LayoutPath))
	err := common.Templates.ExecuteTemplate(rw, "base", p)
	common.CheckError(err)
}
Пример #27
0
func editHandler(rw http.ResponseWriter, req *http.Request) {
	params := mux.Vars(req)
	id := params["id"]

	type Page struct {
		PageName string
		Title    string
	}

	p := Page{
		PageName: "retailer",
		Title:    "Edit Controller: " + id,
	}

	common.Templates = template.Must(template.ParseFiles("templates/retailer/edit.html", common.LayoutPath))
	err := common.Templates.ExecuteTemplate(rw, "base", p)
	common.CheckError(err)
}
func adminViewAllHandler(rw http.ResponseWriter, req *http.Request) {
	type Page struct {
		PageName string
		Title    string
		Concerts []Concert
	}

	concerts := FindAll()

	p := Page{
		PageName: "admin_concert",
		Title:    "View All Concerts",
		Concerts: concerts,
	}

	common.Templates = template.Must(template.ParseFiles("templates/concert/adminViewAll.html", common.LayoutPath))
	err := common.Templates.ExecuteTemplate(rw, "base", p)
	common.CheckError(err)
}
Пример #29
0
func viewAllHandler(rw http.ResponseWriter, req *http.Request) {
	type Page struct {
		PageName  string
		Title     string
		Retailers []Retailer
	}

	retailers := FindAll()

	p := Page{
		PageName:  "retailer",
		Title:     "View All Retailers",
		Retailers: retailers,
	}

	common.Templates = template.Must(template.ParseFiles("templates/retailer/viewAll.html", common.LayoutPath))
	err := common.Templates.ExecuteTemplate(rw, "base", p)
	common.CheckError(err)
}
func userViewAllHandler(rw http.ResponseWriter, req *http.Request) {
	type Page struct {
		PageName string
		Title    string
		Bands    []BandAndConcertsCount
	}

	bandsWithConcertsCount := FindBandsAndConcerts()

	p := Page{
		PageName: "user_band",
		Title:    "View All Bands",
		Bands:    bandsWithConcertsCount,
	}

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