func statusHandler(c *gin.Context) {
response := map[string]string{
"msg": "Let's Heat those Seats!!\n",
"status": "Success",
}
c.JSON(http.StatusOK, response)
}
func roomGET(c *gin.Context) {
roomid := c.Param("roomid")
userid := fmt.Sprint(rand.Int31())
c.HTML(200, "chat_room", gin.H{
"roomid": roomid,
"userid": userid,
})
}
// ListEvents should return a JSON list of events for a particular stadium.
func ListEvents(c *gin.Context) {
stadium := c.Param("stadium")
if stadium == "" {
errMsg := "Error: no stadium specified when requesting events!"
fmt.Println(errMsg)
c.JSON(http.StatusBadRequest, map[string]string{"status": errMsg})
}
// Store the new event in the DB
dbConn, dbErr := db.GetDBConnection()
if dbErr != nil {
fmt.Printf("Found err: %s\n", dbErr.Error())
c.JSON(http.StatusInternalServerError,
map[string]string{"status": "Error cannot connect to DB!"})
return
}
// Find the `sid` by which the events will be selected
var outStadium model.Stadium
dbConn.Table("stadiums").Where("name = ?", stadium).First(&outStadium)
fmt.Printf("Found sid=%d\n", outStadium.Sid)
fmt.Printf("Getting events for stadium: %s\n", stadium)
// Select all events in the events table by the `sid`
eventList := make([]model.Event, 0, 3)
dbConn.Where(&model.Event{Sid: outStadium.Sid}).Find(&eventList)
response := make(map[string][]model.Event)
response["events"] = eventList
c.JSON(http.StatusOK, response)
}
func roomPOST(c *gin.Context) {
roomid := c.Param("roomid")
userid := c.PostForm("user")
message := c.PostForm("message")
room(roomid).Submit(userid + ": " + message)
c.JSON(200, gin.H{
"status": "success",
"message": message,
})
}
func roomPOST(c *gin.Context) {
roomid := c.Param("roomid")
nick := c.Query("nick")
message := c.PostForm("message")
message = strings.TrimSpace(message)
validMessage := len(message) > 1 && len(message) < 200
validNick := len(nick) > 1 && len(nick) < 14
if !validMessage || !validNick {
c.JSON(400, gin.H{
"status": "failed",
"error": "the message or nickname is too long",
})
return
}
post := gin.H{
"nick": html.EscapeString(nick),
"message": html.EscapeString(message),
}
messages.Add("inbound", 1)
room(roomid).Submit(post)
c.JSON(200, post)
}
func stream(c *gin.Context) {
roomid := c.Param("roomid")
listener := openListener(roomid)
defer closeListener(roomid, listener)
c.Stream(func(w io.Writer) bool {
c.SSEvent("message", <-listener)
return true
})
}
func streamRoom(c *gin.Context) {
roomid := c.Param("roomid")
listener := openListener(roomid)
ticker := time.NewTicker(1 * time.Second)
users.Add("connected", 1)
defer func() {
closeListener(roomid, listener)
ticker.Stop()
users.Add("disconnected", 1)
}()
c.Stream(func(w io.Writer) bool {
select {
case msg := <-listener:
messages.Add("outbound", 1)
c.SSEvent("message", msg)
case <-ticker.C:
c.SSEvent("stats", Stats())
}
return true
})
}
func rateLimit(c *gin.Context) {
ip := c.ClientIP()
value := int(ips.Add(ip, 1))
if value%50 == 0 {
fmt.Printf("ip: %s, count: %d\n", ip, value)
}
if value >= 200 {
if value%200 == 0 {
fmt.Println("ip blocked")
}
c.Abort()
c.String(503, "you were automatically banned :)")
}
}
func roomGET(c *gin.Context) {
roomid := c.Param("roomid")
nick := c.Query("nick")
if len(nick) < 2 {
nick = ""
}
if len(nick) > 13 {
nick = nick[0:12] + "..."
}
c.HTML(200, "room_login.templ.html", gin.H{
"roomid": roomid,
"nick": nick,
"timestamp": time.Now().Unix(),
})
}
// CreateEvent is responsible for reading and parsing the JSON
// string from the request body and persisting it ... somewhere.
func CreateEvent(c *gin.Context) {
var evt model.Event
fmt.Printf("Content-Type from request: %s\n", c.ContentType())
err := c.Bind(&evt)
if err == nil {
fmt.Printf("Creating event: %v...\n", evt)
// Store the new event in the DB
dbConn, dbErr := db.GetDBConnection()
if dbErr != nil {
fmt.Printf("Found err: %s\n", dbErr.Error())
c.JSON(http.StatusInternalServerError,
map[string]string{"status": "Error cannot connect to DB!"})
return
}
// Find the `sid` value that should be used when inserting the new event
var outStadium model.Stadium
dbConn.Table("stadiums").Where("name = ?", evt.Stadium.Name).First(&outStadium)
fmt.Printf("Found sid=%d\n", outStadium.Sid)
if outStadium.Sid == 0 {
fmt.Println("Didn't find a stadium with that name!!")
c.JSON(http.StatusBadRequest, map[string]string{"status": "Error no stadium with that name"})
return
}
evt.Sid = outStadium.Sid
dbConn.Create(&evt)
c.JSON(http.StatusCreated, map[string]string{"status": "Success"})
} else {
errMsg := fmt.Sprintf("Error: %s", err.Error())
fmt.Println(errMsg)
c.JSON(http.StatusBadRequest, map[string]string{"status": errMsg})
}
}
func index(c *gin.Context) {
c.Redirect(301, "/room/hn")
}
func roomDELETE(c *gin.Context) {
roomid := c.Param("roomid")
deleteBroadcast(roomid)
}