207 lines
5.2 KiB
Go
207 lines
5.2 KiB
Go
package main
|
|
|
|
import (
|
|
"database/sql"
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"net/url"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
_ "github.com/go-sql-driver/mysql"
|
|
"github.com/spf13/viper"
|
|
)
|
|
|
|
// Global Variables
|
|
var db *sql.DB
|
|
var dbUser, dbPass, dbHost, dbPort, dbName string
|
|
|
|
type media struct {
|
|
ID string `json: "id"`
|
|
YTID string `json: "yt-id"`
|
|
Url string `json: "url"`
|
|
Localpath string `json: "localpath"`
|
|
Size int `json: "size"`
|
|
Sha256sum string `json: "sha256sum"`
|
|
Length int `json: "length"`
|
|
Title string `json: "title"`
|
|
Author string `json: "author"`
|
|
}
|
|
|
|
// read db cred
|
|
func readdbCred() {
|
|
dbCred := viper.New()
|
|
dbCred.SetConfigName("db-cred")
|
|
dbCred.AddConfigPath(".")
|
|
dbCred.SetConfigType("yaml")
|
|
err := dbCred.ReadInConfig()
|
|
check(err)
|
|
dbUser = dbCred.GetString("dbUser")
|
|
dbPass = dbCred.GetString("dbPass")
|
|
dbHost = dbCred.GetString("dbHost")
|
|
dbPort = dbCred.GetString("dbPort")
|
|
dbName = dbCred.GetString("dbName")
|
|
return
|
|
}
|
|
|
|
// check error
|
|
func check(err error) {
|
|
if err != nil {
|
|
panic(err.Error())
|
|
}
|
|
}
|
|
|
|
func opendb() (db *sql.DB) {
|
|
// open db
|
|
sqlopen := fmt.Sprintf(dbUser + ":" + dbPass + "@tcp(" + dbHost + ":" + dbPort + ")/" + dbName)
|
|
var err error
|
|
db, err = sql.Open("mysql", sqlopen)
|
|
check(err)
|
|
fmt.Println("Successfully connected to the database")
|
|
return db
|
|
}
|
|
|
|
func dbinit() {
|
|
dbinit, err := db.Query("CREATE TABLE IF NOT EXISTS `media` (`id` INT NOT NULL AUTO_INCREMENT, `ytid` VARCHAR(100), `url` VARCHAR(255), `localpath` TEXT(65535), `size` INT, `sha256sum` VARCHAR(255), `length` INT, `title` VARCHAR(255), `author` VARCHAR(255), PRIMARY KEY (`id`));")
|
|
if err != nil {
|
|
fmt.Println("Error while creating table")
|
|
panic(err.Error())
|
|
}
|
|
defer dbinit.Close()
|
|
fmt.Println("DB-Init successfull")
|
|
}
|
|
|
|
func dbentrycount() {
|
|
var count int
|
|
dbcount, err := db.Query("SELECT COUNT(*) FROM testdb.media;")
|
|
if err != nil {
|
|
fmt.Println("Error while counting rows from table")
|
|
panic(err.Error())
|
|
}
|
|
defer dbcount.Close()
|
|
for dbcount.Next() {
|
|
err = dbcount.Scan(&count)
|
|
if err != nil {
|
|
panic(err.Error())
|
|
}
|
|
}
|
|
fmt.Printf("There are %v entries in the database\n", count)
|
|
}
|
|
func get_api_db(c *gin.Context) {
|
|
dbquery := fmt.Sprintf("SELECT * FROM testdb.media")
|
|
media, err := getJSON(dbquery)
|
|
check(err)
|
|
c.Data(http.StatusOK, "application/json", media)
|
|
}
|
|
|
|
// func getMedia() []media {
|
|
// dbquery := fmt.Sprintf("SELECT * FROM testdb.media")
|
|
// rows, err := db.Query(dbquery)
|
|
// check(err)
|
|
// var MediaDB []media
|
|
// for rows.Next() {
|
|
// err := rows.Scan(&id, &yt-id, &url, &localpath, &size, &sha256sum, &length, &title, &author)
|
|
// if err != nil {
|
|
// if err == sql.ErrNoRows {
|
|
// log.Println("no rows found in DB")
|
|
// } else {
|
|
// panic(err)
|
|
// }
|
|
// } else {
|
|
// MediaDB = append(MediaDB, media{ID: id, YTID: yt - id, Url: url, Localpath: localpath, Size: size, Sha256sum: sha256sum, Length: length, Title: title, Author: author})
|
|
// }
|
|
// }
|
|
// return MediaDB
|
|
// }
|
|
|
|
func getJSON(sqlString string) ([]byte, error) {
|
|
rows, err := db.Query(sqlString)
|
|
check(err)
|
|
defer rows.Close()
|
|
columns, err := rows.Columns()
|
|
if err != nil {
|
|
return []byte("Error while generating json"), err
|
|
}
|
|
count := len(columns)
|
|
tableData := make([]map[string]interface{}, 0)
|
|
values := make([]interface{}, count)
|
|
valuePtrs := make([]interface{}, count)
|
|
for rows.Next() {
|
|
for i := 0; i < count; i++ {
|
|
valuePtrs[i] = &values[i]
|
|
}
|
|
rows.Scan(valuePtrs...)
|
|
entry := make(map[string]interface{})
|
|
for i, col := range columns {
|
|
var v interface{}
|
|
val := values[i]
|
|
b, ok := val.([]byte)
|
|
if ok {
|
|
v = string(b)
|
|
} else {
|
|
v = val
|
|
}
|
|
entry[col] = v
|
|
}
|
|
tableData = append(tableData, entry)
|
|
}
|
|
jsonData, err := json.Marshal(tableData)
|
|
if err != nil {
|
|
return []byte("Error while generating json"), err
|
|
}
|
|
return jsonData, nil
|
|
}
|
|
|
|
func get_test_ping(c *gin.Context) {
|
|
c.String(http.StatusOK, "pong")
|
|
}
|
|
func get_api_add_ytid(c *gin.Context) {
|
|
newSong_ytid := c.Param("ytid")
|
|
newSong_url := "https://www.youtube.com/watch?v=" + newSong_ytid
|
|
_, err := url.ParseRequestURI(newSong_url)
|
|
check(err)
|
|
is_available := ytid_in_db(newSong_ytid)
|
|
c.String(http.StatusOK, is_available)
|
|
}
|
|
|
|
func ytid_in_db(ytid string) string {
|
|
sqlString := fmt.Sprintf("SELECT COUNT(ytid) FROM testdb.media WHERE ytid LIKE \"%v\";", ytid)
|
|
var count int
|
|
err := db.QueryRow(sqlString).Scan(&count)
|
|
check(err)
|
|
if count == 0 {
|
|
return "Song is not available"
|
|
}
|
|
if count == 1 {
|
|
return "Song is available"
|
|
}
|
|
error_return := fmt.Sprintf("Rows returned: %s --> there is an Issue within the database", string(count))
|
|
return error_return
|
|
}
|
|
|
|
func get_api_get_ytid(c *gin.Context) {
|
|
ytid := c.Param("ytid")
|
|
sqlString := fmt.Sprintf("SELECT * FROM testdb.media WHERE ytid LIKE \"%v\";", ytid)
|
|
json, err := getJSON(sqlString)
|
|
check(err)
|
|
c.Data(http.StatusOK, "application/json", json)
|
|
}
|
|
|
|
func main() {
|
|
readdbCred()
|
|
db = opendb()
|
|
defer db.Close()
|
|
|
|
dbinit()
|
|
dbentrycount()
|
|
|
|
router := gin.Default()
|
|
router.GET("/api/db", get_api_db)
|
|
router.GET("/api/add/:ytid", get_api_add_ytid)
|
|
router.GET("/api/get/:ytid", get_api_get_ytid)
|
|
//router.GET("/api/download/:ytid", get_api_download_ytid)
|
|
router.GET("/test/ping", get_test_ping)
|
|
//router.GET("/api/songs", getMedia)
|
|
router.Run("127.0.0.1:8000")
|
|
}
|