GoGronkh/gserver/webapp.go

package main

import (
    "html/template"
    "strings"
    "net/http"

    . "git.1750studios.com/gronkhDE/gogronkh/gserver/utlis"

    "git.1750studios.com/gronkhDE/gogronkh/database"

    "github.com/gin-gonic/gin"
)

func GetIndex(c *gin.Context) {
    var EPs []database.Episode
    database.Db.Order("aired desc").Limit(50).Find(&EPs)
    var data []gin.H
    for _, EP := range EPs {     
        var LP database.LetsPlay
        var AT database.Author
        database.Db.Model(&EP).Related(&LP).Related(&AT)
        data = append(data, gin.H{"EP": EP, "LP": LP, "AT": AT})
    }
    c.HTML(http.StatusOK, "index.html", gin.H{
        "title": "Neue Episoden",
        "data": data,
        "page": "index",
    })
}

func GetLps(c *gin.Context) {
    var LPs []database.LetsPlay
    database.Db.Where("aired IS NOT NULL and merge_id IS NULL").Order("name asc").Find(&LPs)
    var data []gin.H
    for _, LP := range LPs {
        var AT database.Author
        database.Db.Model(&LP).Related(&AT)
        data = append(data, gin.H{"LP": LP, "AT": AT})
    }
    c.HTML(http.StatusOK, "lps.html", gin.H{
        "title": "Let's Plays",
        "data": data,
        "page": "lps",
    })
}

func GetLt(c *gin.Context) {
    if tslug, ok := CleanParam(c.Param("tslug")); ok {
        //LT in URL
        var LT database.LetsTest
        if database.Db.Where("slug = ?", tslug).First(&LT).Error == nil {
            //LT found
            var AT database.Author
            database.Db.Model(&LT).Related(&AT)
            LT.Descr.String = descRegEx.ReplaceAllString(LT.Descr.String, "<hr />")
            LT.Descr.String = strings.Replace(LT.Descr.String, "\n", "<br />", -1)
            c.HTML(http.StatusOK, "lt.html", gin.H{
                "title": LT.Name.String,
                "data": gin.H{"LT": LT, "AT": AT, "DESC": template.HTML(LT.Descr.String)},
                "page": "lt",
            })
        } else {
            //LT not found
            c.AbortWithStatus(404)
        }
    } else {
        var LTs []database.LetsTest
        database.Db.Order("name asc").Find(&LTs)
        var data []gin.H
        for _, LT := range LTs {
            var AT database.Author
            database.Db.Model(&LT).Related(&AT)
            data = append(data, gin.H{"LT": LT, "AT": AT})
        }
        c.HTML(http.StatusOK, "lts.html", gin.H{
            "title": "Let's Tests",
            "data": data,
            "page": "lts",
        })
    }
}

func GetAt(c *gin.Context) {
    if aslug, ok := CleanParam(c.Param("aslug")); ok {
        //AT in URL
        var AT database.Author
        if database.Db.Where("slug = ?", aslug).First(&AT).Error == nil {
            //AT found
            var LPs []database.LetsPlay
            var LTs []database.LetsTest
            var EPs []database.Episode
            var DEPs []gin.H
            database.Db.Model(&AT).Where("aired IS NOT NULL").Limit(5).Order("aired desc").Related(&LPs).Related(&LTs).Related(&EPs)
            for _, EP := range EPs {
                var ELP database.LetsPlay
                database.Db.Model(&EP).Related(&ELP)

                DEPs = append(DEPs, gin.H{"LP": ELP, "EP": EP})
            }
            var data gin.H = gin.H{"AT": AT, "LPs": LPs, "LTs": LTs, "EPs": DEPs,}
            c.HTML(http.StatusOK, "at.html", gin.H{
                "title": AT.Name.String,
                "data": data,
                "page": "at",
            })
        } else {
            //LT not found
            c.AbortWithStatus(404)
        }
    } else {
        var ATs []database.Author
        var data []gin.H
        database.Db.Order("name asc").Find(&ATs)
        for _, AT := range ATs {
            data = append(data, gin.H{"AT": AT})
        }
        c.HTML(http.StatusOK, "ats.html", gin.H{
            "title": "Sprecher",
            "data": data,
            "page": "ats",

        })
    }
}

func GetAtLps(c *gin.Context) {
    if aslug, ok := CleanParam(c.Param("aslug")); ok {
        var AT database.Author
        if database.Db.Where("slug = ?", aslug).First(&AT).Error == nil {
            var LPs []database.LetsPlay
            database.Db.Model(&AT).Where("aired IS NOT NULL AND merge_id IS NULL").Order("name asc").Related(&LPs)
            var data []gin.H
            for _, LP := range LPs {
                data = append(data, gin.H{"LP": LP})
            }
            c.HTML(http.StatusOK, "alps.html", gin.H{
                "title": "Let's Plays von " + AT.Name.String,
                "AT": AT,
                "data": data,
                "page": "ats",
            })
        }
    }
}

func GetAtLts(c *gin.Context) {
    if aslug, ok := CleanParam(c.Param("aslug")); ok {
        var AT database.Author
        if database.Db.Where("slug = ?", aslug).First(&AT).Error == nil {
            var LTs []database.LetsTest
            database.Db.Model(&AT).Where("aired IS NOT NULL").Order("name asc").Related(&LTs)
            var data []gin.H
            for _, LT := range LTs {
                data = append(data, gin.H{"LT": LT})
            }
            c.HTML(http.StatusOK, "alts.html", gin.H{
                "title": "Let's Tests von " + AT.Name.String,
                "AT": AT,
                "data": data,
                "page": "ats",
            })
        }
    }
}

func GetAtEps(c *gin.Context) {
    if aslug, ok := CleanParam(c.Param("aslug")); ok {
        var AT database.Author
        if database.Db.Where("slug = ?", aslug).First(&AT).Error == nil {
            var EPs []database.Episode
            database.Db.Model(&AT).Where("aired IS NOT NULL").Order("aired desc").Related(&EPs)
            var data []gin.H
            for _, EP := range EPs {
                var LP database.LetsPlay
                database.Db.Model(&EP).Related(&LP)
                data = append(data, gin.H{"EP" : EP, "LP" : LP})
            }
            c.HTML(http.StatusOK, "aeps.html", gin.H{
                "title": "Episoden von " + AT.Name.String,
                "AT": AT,
                "data": data,
                "page": "ats",
            })
        }
    }
}

func GetLEpisode(c *gin.Context) {
    if lslug, ok := CleanParam(c.Param("lslug")); ok {
        //LP in URL
        var LP database.LetsPlay
        if database.Db.Where("slug = ?", lslug).First(&LP).Error == nil {
            //LP found
            if eslug, ok := CleanParam(c.Param("eslug")); ok {
                //EP in URL
                var EP database.Episode
                var AT database.Author
                if database.Db.Where("slug = ?", eslug).First(&EP).Error == nil {
                    database.Db.Model(&EP).Related(&AT)
                    EP.Descr.String = descRegEx.ReplaceAllString(EP.Descr.String, "<hr />")
                    EP.Descr.String = strings.Replace(EP.Descr.String, "\n", "<br />", -1)
                    var next database.Episode
                    var previous database.Episode
                    database.Db.Where("aired::date > ?::date and lets_play_id = ?", EP.Aired, EP.LetsPlayID).Order("aired asc").First(&next)
                    database.Db.Where("aired::date < ?::date and lets_play_id = ?", EP.Aired, EP.LetsPlayID).Order("aired desc").First(&previous)
                    c.HTML(http.StatusOK, "episode.html", gin.H{
                        "title": EP.Name.String + " – " + LP.Name.String,
                        "data": gin.H{"EP": EP, "LP": LP, "AT": AT, "DESC": template.HTML(EP.Descr.String), "NEXT": next, "PREV": previous},
                        "page": "ep",
                    })
                } else {
                    //EP not found
                    var EPs []database.Episode
                    var AT database.Author
                    database.Db.Model(&LP).Order("episode asc").Related(&EPs)
                    database.Db.Model(&LP).Related(&AT)
                    var DEP []gin.H
                    for _, EP := range EPs {
                        ints := []rune(EP.Descr.String)
                        if len(ints) > 230 {
                            EP.Descr.String = string(ints[:230]) + "…"
                        }
                        DEP = append(DEP, gin.H{"EP": EP, "LP": LP,})
                    }
                    var data gin.H = gin.H{"LP": LP, "AT": AT, "EPs": DEP}
                    c.HTML(http.StatusNotFound, "lp.html", gin.H{
                        "title": LP.Name.String,
                        "data": data,
                        "message": Message{Type: "alert", String: "Fehler 404: Episode nicht gefunden!"},
                        "page": "lp",
                    })
                }
            } else {
                //No EP in URL
                var EPs []database.Episode
                var AT database.Author
                database.Db.Model(&LP).Order("season asc").Order("episode asc").Related(&EPs)
                database.Db.Model(&LP).Related(&AT)
                var DEP []gin.H
                for _, EP := range EPs {
                    ints := []rune(EP.Descr.String)
                    if len(ints) > 230 {
                        EP.Descr.String = string(ints[:230]) + "…"
                    }
                    DEP = append(DEP, gin.H{"EP": EP, "LP": LP,})
                }
                var data gin.H = gin.H{"LP": LP, "AT": AT, "EPs": DEP}
                c.HTML(http.StatusOK, "lp.html", gin.H{
                    "title": LP.Name.String,
                    "data": data,
                    "page": "lp",
                })
            } 
        } else {
            if eslug, ok := CleanParam(c.Param("eslug")); ok {
                var EP database.Episode
                var LP database.LetsPlay
                if database.Db.Where("slug = ?", eslug).First(&EP).Error == nil {
                    database.Db.Model(&EP).Related(&LP)
                    c.Redirect(301, "/lets-play/" + LP.Slug.String + "/" + EP.Slug.String)
                } else {
                    c.AbortWithStatus(404)
                }
            } else {
                c.AbortWithStatus(404)
            }
        }
    }
}