lukas/OpenMediaCenter
1
0
Fork 0
Code Issues 8 Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'APIDoc_handling_mechanics' into 'master'

Browse Source 
Api mechanics

See merge request lukas/openmediacenter!46
This commit is contained in:
Lukas Heiligenbrunner 2021-05-25 20:52:09 +00:00
commit e3c7fe514b
16 changed files with 1294 additions and 180 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

110
apiGo/api/Actors.go
View File

@ -12,32 +12,83 @@ func AddActorsHandlers() {
}
func getActorsFromDB() {
AddHandler("getAllActors", ActorNode, nil, func() []byte {
/**
* @api {post} /api/actor [getAllActors]
* @apiDescription Get all available Actors
* @apiName getAllActors
* @apiGroup Actor
*
* @apiSuccess {Object[]} . Array of Actors available
* @apiSuccess {uint32} .ActorId Actor Id
* @apiSuccess {string} .Name Actor Name
* @apiSuccess {string} .Thumbnail Portrait Thumbnail
*/
AddHandler("getAllActors", ActorNode, func(info *HandlerInfo) []byte {
query := "SELECT actor_id, name, thumbnail FROM actors"
return jsonify(readActorsFromResultset(database.Query(query)))
})
var gaov struct {
/**
* @api {post} /api/actor [getActorsOfVideo]
* @apiDescription Get all actors playing in one video
* @apiName getActorsOfVideo
* @apiGroup Actor
*
* @apiParam {int} MovieId ID of video
*
* @apiSuccess {Object[]} . Array of Actors available
* @apiSuccess {uint32} .ActorId Actor Id
* @apiSuccess {string} .Name Actor Name
* @apiSuccess {string} .Thumbnail Portrait Thumbnail
*/
AddHandler("getActorsOfVideo", ActorNode, func(info *HandlerInfo) []byte {
var args struct {
MovieId int
}
AddHandler("getActorsOfVideo", ActorNode, &gaov, func() []byte {
if err := FillStruct(&args, info.Data); err != nil {
fmt.Println(err.Error())
return nil
}
query := fmt.Sprintf(`SELECT a.actor_id, name, thumbnail FROM actors_videos
JOIN actors a on actors_videos.actor_id = a.actor_id
WHERE actors_videos.video_id=%d`, gaov.MovieId)
WHERE actors_videos.video_id=%d`, args.MovieId)
return jsonify(readActorsFromResultset(database.Query(query)))
})
var gai struct {
/**
* @api {post} /api/actor [getActorInfo]
* @apiDescription Get all infos for an actor
* @apiName getActorInfo
* @apiGroup Actor
*
* @apiParam {int} ActorId ID of Actor
*
* @apiSuccess {VideoUnloadedType[]} Videos Array of Videos this actor plays in
* @apiSuccess {uint32} Videos.MovieId Video Id
* @apiSuccess {string} Videos.MovieName Video Name
*
* @apiSuccess {Info} Info Infos about the actor
* @apiSuccess {uint32} Info.ActorId Actor Id
* @apiSuccess {string} Info.Name Actor Name
* @apiSuccess {string} Info.Thumbnail Actor Thumbnail
*/
AddHandler("getActorInfo", ActorNode, func(info *HandlerInfo) []byte {
var args struct {
ActorId int
}
AddHandler("getActorInfo", ActorNode, &gai, func() []byte {
if err := FillStruct(&args, info.Data); err != nil {
fmt.Println(err.Error())
return nil
}
query := fmt.Sprintf(`SELECT movie_id, movie_name FROM actors_videos
JOIN videos v on v.movie_id = actors_videos.video_id
WHERE actors_videos.actor_id=%d`, gai.ActorId)
WHERE actors_videos.actor_id=%d`, args.ActorId)
videos := readVideosFromResultset(database.Query(query))
query = fmt.Sprintf("SELECT actor_id, name, thumbnail FROM actors WHERE actor_id=%d", gai.ActorId)
query = fmt.Sprintf("SELECT actor_id, name, thumbnail FROM actors WHERE actor_id=%d", args.ActorId)
actor := readActorsFromResultset(database.Query(query))[0]
var result = struct {
@ -53,20 +104,51 @@ func getActorsFromDB() {
}
func saveActorsToDB() {
var ca struct {
/**
* @api {post} /api/video [createActor]
* @apiDescription Create a new Actor
* @apiName createActor
* @apiGroup Actor
*
* @apiParam {string} ActorName Name of new Actor
*
* @apiSuccess {string} result 'success' if successfully or error message if not
*/
AddHandler("createActor", ActorNode, func(info *HandlerInfo) []byte {
var args struct {
ActorName string
}
AddHandler("createActor", ActorNode, &ca, func() []byte {
if err := FillStruct(&args, info.Data); err != nil {
fmt.Println(err.Error())
return nil
}
query := "INSERT IGNORE INTO actors (name) VALUES (?)"
return database.SuccessQuery(query, ca.ActorName)
return database.SuccessQuery(query, args.ActorName)
})
var aatv struct {
/**
* @api {post} /api/video [addActorToVideo]
* @apiDescription Add Actor to Video
* @apiName addActorToVideo
* @apiGroup Actor
*
* @apiParam {int} ActorId Id of Actor
* @apiParam {int} MovieId Id of Movie to add to
*
* @apiSuccess {string} result 'success' if successfully or error message if not
*/
AddHandler("addActorToVideo", ActorNode, func(info *HandlerInfo) []byte {
var args struct {
ActorId int
MovieId int
}
AddHandler("addActorToVideo", ActorNode, &aatv, func() []byte {
query := fmt.Sprintf("INSERT IGNORE INTO actors_videos (actor_id, video_id) VALUES (%d,%d)", aatv.ActorId, aatv.MovieId)
if err := FillStruct(&args, info.Data); err != nil {
fmt.Println(err.Error())
return nil
}
query := fmt.Sprintf("INSERT IGNORE INTO actors_videos (actor_id, video_id) VALUES (%d,%d)", args.ActorId, args.MovieId)
return database.SuccessQuery(query)
})
}

72
apiGo/api/ApiBase.go
View File

@ -4,6 +4,7 @@ import (
"bytes"
"encoding/json"
"fmt"
"gopkg.in/oauth2.v3"
"net/http"
"openmediacenter/apiGo/api/oauth"
)
@ -18,22 +19,27 @@ const (
TVShowNode = iota
)
type HandlerInfo struct {
ID string
Token string
Data map[string]interface{}
}
type actionStruct struct {
Action string
}
type Handler struct {
action string
handler func() []byte
arguments interface{}
handler func(info *HandlerInfo) []byte
apiNode int
}
var handlers []Handler
var handlers = make(map[string]Handler)
func AddHandler(action string, apiNode int, n interface{}, h func() []byte) {
func AddHandler(action string, apiNode int, h func(info *HandlerInfo) []byte) {
// append new handler to the handlers
handlers = append(handlers, Handler{action, h, n, apiNode})
handlers[fmt.Sprintf("%s/%d", action, apiNode)] = Handler{action, h, apiNode}
}
func ServerInit() {
@ -47,27 +53,39 @@ func ServerInit() {
oauth.InitOAuth()
}
func handleAPICall(action string, requestBody string, apiNode int) []byte {
for i := range handlers {
if handlers[i].action == action && handlers[i].apiNode == apiNode {
// call the handler and return
if handlers[i].arguments != nil {
// decode the arguments to the corresponding arguments object
err := json.Unmarshal([]byte(requestBody), &handlers[i].arguments)
if err != nil {
fmt.Printf("failed to decode arguments of action %s :: %s\n", action, requestBody)
}
}
return handlers[i].handler()
}
}
func handleAPICall(action string, requestBody string, apiNode int, info *HandlerInfo) []byte {
handler, ok := handlers[fmt.Sprintf("%s/%d", action, apiNode)]
if !ok {
// handler doesn't exist!
fmt.Printf("no handler found for Action: %d/%s\n", apiNode, action)
return nil
}
// check if info even exists
if info == nil {
info = &HandlerInfo{}
}
// parse the arguments
var args map[string]interface{}
err := json.Unmarshal([]byte(requestBody), &args)
if err != nil {
fmt.Printf("failed to decode arguments of action %s :: %s\n", action, requestBody)
} else {
// check if map has an action
if _, ok := args["action"]; ok {
delete(args, "action")
}
info.Data = args
}
// call the handler
return handler.handler(info)
}
func handlefunc(rw http.ResponseWriter, req *http.Request, node int) {
func handlefunc(rw http.ResponseWriter, req *http.Request, node int, tokenInfo *oauth2.TokenInfo) {
// only allow post requests
if req.Method != "POST" {
return
@ -83,5 +101,13 @@ func handlefunc(rw http.ResponseWriter, req *http.Request, node int) {
fmt.Println("failed to read action from request! :: " + body)
}
rw.Write(handleAPICall(t.Action, body, node))
// load userid from received token object
id := (*tokenInfo).GetClientID()
userinfo := &HandlerInfo{
ID: id,
Token: (*tokenInfo).GetCode(),
}
rw.Write(handleAPICall(t.Action, body, node, userinfo))
}

30
apiGo/api/ApiBase_test.go
View File

@ -5,13 +5,13 @@ import (
)
func cleanUp() {
handlers = nil
handlers = make(map[string]Handler)
}
func TestAddHandler(t *testing.T) {
cleanUp()
AddHandler("test", ActorNode, nil, func() []byte {
AddHandler("test", ActorNode, func(info *HandlerInfo) []byte {
return nil
})
if len(handlers) != 1 {
@ -23,13 +23,13 @@ func TestCallOfHandler(t *testing.T) {
cleanUp()
i := 0
AddHandler("test", ActorNode, nil, func() []byte {
AddHandler("test", ActorNode, func(info *HandlerInfo) []byte {
i++
return nil
})
// simulate the call of the api
handleAPICall("test", "", ActorNode)
handleAPICall("test", "", ActorNode, nil)
if i != 1 {
t.Errorf("Unexpected number of Lambda calls : %d/1", i)
@ -39,26 +39,32 @@ func TestCallOfHandler(t *testing.T) {
func TestDecodingOfArguments(t *testing.T) {
cleanUp()
var myvar struct {
AddHandler("test", ActorNode, func(info *HandlerInfo) []byte {
var args struct {
Test string
TestInt int
}
AddHandler("test", ActorNode, &myvar, func() []byte {
err := FillStruct(&args, info.Data)
if err != nil {
t.Errorf("Error parsing args: %s", err.Error())
return nil
}
if args.TestInt != 42 || args.Test != "myString" {
t.Errorf("Wrong parsing of argument parameters : %d/42 - %s/myString", args.TestInt, args.Test)
}
return nil
})
// simulate the call of the api
handleAPICall("test", `{"Test":"myString","TestInt":42}`, ActorNode)
if myvar.TestInt != 42 || myvar.Test != "myString" {
t.Errorf("Wrong parsing of argument parameters : %d/42 - %s/myString", myvar.TestInt, myvar.Test)
}
handleAPICall("test", `{"Test":"myString","TestInt":42}`, ActorNode, nil)
}
func TestNoHandlerCovers(t *testing.T) {
cleanUp()
ret := handleAPICall("test", "", ActorNode)
ret := handleAPICall("test", "", ActorNode, nil)
if ret != nil {
t.Error("Expect nil return within unhandled api action")

44
apiGo/api/Helpers.go
View File

@ -3,8 +3,10 @@ package api
import (
"database/sql"
"encoding/json"
"errors"
"fmt"
"openmediacenter/apiGo/api/types"
"reflect"
)
// MovieId - MovieName : pay attention to the order!
@ -85,3 +87,45 @@ func jsonify(v interface{}) []byte {
}
return str
}
// setField set a specific field of an object with an object provided
func setField(obj interface{}, name string, value interface{}) error {
structValue := reflect.ValueOf(obj).Elem()
structFieldValue := structValue.FieldByName(name)
if !structFieldValue.IsValid() {
return fmt.Errorf("no such field: %s in obj", name)
}
if !structFieldValue.CanSet() {
return fmt.Errorf("cannot set %s field value", name)
}
structFieldType := structFieldValue.Type()
val := reflect.ValueOf(value)
if structFieldType != val.Type() {
if val.Type().ConvertibleTo(structFieldType) {
// if type is convertible - convert and set
structFieldValue.Set(val.Convert(structFieldType))
} else {
return errors.New("provided value type didn't match obj field type and isn't convertible")
}
} else {
// set value if type is the same
structFieldValue.Set(val)
}
return nil
}
// FillStruct fill a custom struct with objects of a map
func FillStruct(i interface{}, m map[string]interface{}) error {
for k, v := range m {
err := setField(i, k, v)
if err != nil {
return err
}
}
return nil
}

95
apiGo/api/Settings.go
View File

@ -2,6 +2,7 @@ package api
import (
"encoding/json"
"fmt"
"openmediacenter/apiGo/api/types"
"openmediacenter/apiGo/database"
"openmediacenter/apiGo/database/settings"
@ -17,11 +18,43 @@ func AddSettingsHandlers() {
}
func getSettingsFromDB() {
AddHandler("loadGeneralSettings", SettingsNode, nil, func() []byte {
/**
* @api {post} /api/settings [loadGeneralSettings]
* @apiDescription Get the settings object
* @apiName loadGeneralSettings
* @apiGroup Settings
*
* @apiSuccess {Object} Settings Settings object
* @apiSuccess {string} Settings.VideoPath webserver path to the videos
* @apiSuccess {string} Settings.EpisodePath webserver path to the tvshows
* @apiSuccess {string} Settings.MediacenterName overall name of the mediacenter
* @apiSuccess {string} Settings.Password new server password (-1 if no password set)
* @apiSuccess {bool} Settings.TMDBGrabbing TMDB grabbing support to grab tag info and thumbnails
* @apiSuccess {bool} Settings.DarkMode Darkmode enabled?
* @apiSuccess {uint32} Settings.VideoNr total number of videos
* @apiSuccess {float32} Settings.DBSize total size of database
* @apiSuccess {uint32} Settings.DifferentTags number of different tags available
* @apiSuccess {uint32} Settings.TagsAdded number of different tags added to videos
* @apiSuccess {string} Settings.PathPrefix
*/
AddHandler("loadGeneralSettings", SettingsNode, func(info *HandlerInfo) []byte {
result := database.GetSettings()
return jsonify(result)
})
AddHandler("loadInitialData", SettingsNode, nil, func() []byte {
/**
* @api {post} /api/settings [loadInitialData]
* @apiDescription load startdata to display on homepage
* @apiName loadInitialData
* @apiGroup Settings
*
* @apiSuccess {string} VideoPath webserver path to the videos
* @apiSuccess {string} EpisodePath webserver path to the tvshows
* @apiSuccess {string} MediacenterName overall name of the mediacenter
* @apiSuccess {string} Pasword new server password (-1 if no password set)
* @apiSuccess {bool} DarkMode Darkmode enabled?
*/
AddHandler("loadInitialData", SettingsNode, func(info *HandlerInfo) []byte {
sett := settings.LoadSettings()
type InitialDataTypeResponse struct {
@ -52,10 +85,32 @@ func getSettingsFromDB() {
}
func saveSettingsToDB() {
var sgs struct {
/**
* @api {post} /api/settings [saveGeneralSettings]
* @apiDescription Save the global settings provided
* @apiName saveGeneralSettings
* @apiGroup Settings
*
* @apiParam {Object} Settings Settings object
* @apiParam {string} Settings.VideoPath webserver path to the videos
* @apiParam {string} Settings.EpisodePath webserver path to the tvshows
* @apiParam {string} Settings.MediacenterName overall name of the mediacenter
* @apiParam {string} Settings.Password new server password (-1 if no password set)
* @apiParam {bool} Settings.TMDBGrabbing TMDB grabbing support to grab tag info and thumbnails
* @apiParam {bool} Settings.DarkMode Darkmode enabled?
*
* @apiSuccess {string} result 'success' if successfully or error message if not
*/
AddHandler("saveGeneralSettings", SettingsNode, func(info *HandlerInfo) []byte {
// todo correct type here!
var args struct {
Settings types.SettingsType
}
AddHandler("saveGeneralSettings", SettingsNode, &sgs, func() []byte {
if err := FillStruct(&args, info.Data); err != nil {
fmt.Println(err.Error())
return nil
}
query := `
UPDATE settings SET
video_path=?,
@ -66,24 +121,46 @@ func saveSettingsToDB() {
DarkMode=?
WHERE 1`
return database.SuccessQuery(query,
sgs.Settings.VideoPath, sgs.Settings.EpisodePath, sgs.Settings.Password,
sgs.Settings.MediacenterName, sgs.Settings.TMDBGrabbing, sgs.Settings.DarkMode)
args.Settings.VideoPath, args.Settings.EpisodePath, args.Settings.Password,
args.Settings.MediacenterName, args.Settings.TMDBGrabbing, args.Settings.DarkMode)
})
}
// methods for handling reindexing and cleanup of db gravity
func reIndexHandling() {
AddHandler("startReindex", SettingsNode, nil, func() []byte {
/**
* @api {post} /api/settings [startReindex]
* @apiDescription Start Database video reindex Job
* @apiName startReindex
* @apiGroup Settings
*
* @apiSuccess {string} result 'success' if successfully or error message if not
*/
AddHandler("startReindex", SettingsNode, func(info *HandlerInfo) []byte {
videoparser.StartReindex()
return database.ManualSuccessResponse(nil)
})
AddHandler("startTVShowReindex", SettingsNode, nil, func() []byte {
/**
* @api {post} /api/settings [startTVShowReindex]
* @apiDescription Start Database TVShow reindex job
* @apiName startTVShowReindex
* @apiGroup Settings
*
* @apiSuccess {string} result 'success' if successfully or error message if not
*/
AddHandler("startTVShowReindex", SettingsNode, func(info *HandlerInfo) []byte {
videoparser.StartTVShowReindex()
return database.ManualSuccessResponse(nil)
})
AddHandler("cleanupGravity", SettingsNode, nil, func() []byte {
/**
* @api {post} /api/settings [cleanupGravity]
* @apiDescription Start Database cleanup job
* @apiName cleanupGravity
* @apiGroup Settings
*/
AddHandler("cleanupGravity", SettingsNode, func(info *HandlerInfo) []byte {
videoparser.StartCleanup()
return nil
})

85
apiGo/api/TVShows.go
View File

@ -6,17 +6,46 @@ import (
)
func AddTvshowHandlers() {
AddHandler("getTVShows", TVShowNode, nil, func() []byte {
/**
* @api {post} /api/tvshow [getTVShows]
* @apiDescription get all available tv shows
* @apiName getTVShows
* @apiGroup TVshow
*
* @apiSuccess {Object[]} .
* @apiSuccess {uint32} .Id tvshow id
* @apiSuccess {string} .Name tvshow name
*/
AddHandler("getTVShows", TVShowNode, func(info *HandlerInfo) []byte {
query := "SELECT id, name FROM tvshow"
rows := database.Query(query)
return jsonify(readTVshowsFromResultset(rows))
})
var ge struct {
/**
* @api {post} /api/tvshow [getEpisodes]
* @apiDescription get all Episodes of a TVShow
* @apiName getEpisodes
* @apiGroup TVshow
*
* @apiParam {uint32} ShowID id of tvshow to get episodes from
*
* @apiSuccess {Object[]} .
* @apiSuccess {uint32} .ID episode id
* @apiSuccess {string} .Name episode name
* @apiSuccess {uint8} .Season Season number
* @apiSuccess {uint8} .Episode Episode number
*/
AddHandler("getEpisodes", TVShowNode, func(info *HandlerInfo) []byte {
var args struct {
ShowID uint32
}
AddHandler("getEpisodes", TVShowNode, &ge, func() []byte {
query := fmt.Sprintf("SELECT id, name, season, episode FROM tvshow_episodes WHERE tvshow_id=%d", ge.ShowID)
if err := FillStruct(&args, info.Data); err != nil {
fmt.Println(err.Error())
return nil
}
query := fmt.Sprintf("SELECT id, name, season, episode FROM tvshow_episodes WHERE tvshow_id=%d", args.ShowID)
rows := database.Query(query)
type Episode struct {
@ -41,15 +70,34 @@ func AddTvshowHandlers() {
return jsonify(episodes)
})
var le struct {
/**
* @api {post} /api/tvshow [loadEpisode]
* @apiDescription load all info of episode
* @apiName loadEpisode
* @apiGroup TVshow
*
* @apiParam {uint32} ID id of episode
*
* @apiSuccess {uint32} TVShowID episode id
* @apiSuccess {string} Name episode name
* @apiSuccess {uint8} Season Season number
* @apiSuccess {uint8} Episode Episode number
* @apiSuccess {string} Path webserver path of video file
*/
AddHandler("loadEpisode", TVShowNode, func(info *HandlerInfo) []byte {
var args struct {
ID uint32
}
AddHandler("loadEpisode", TVShowNode, &le, func() []byte {
if err := FillStruct(&args, info.Data); err != nil {
fmt.Println(err.Error())
return nil
}
query := fmt.Sprintf(`
SELECT tvshow_episodes.name, season, tvshow_id, episode, filename, t.foldername
FROM tvshow_episodes
JOIN tvshow t on t.id = tvshow_episodes.tvshow_id
WHERE tvshow_episodes.id=%d`, le.ID)
WHERE tvshow_episodes.id=%d`, args.ID)
row := database.QueryRow(query)
var ret struct {
@ -73,17 +121,32 @@ WHERE tvshow_episodes.id=%d`, le.ID)
return jsonify(ret)
})
var rtn struct {
/**
* @api {post} /api/tvshow [readThumbnail]
* @apiDescription Load Thubnail of specific episode
* @apiName readThumbnail
* @apiGroup TVshow
*
* @apiParam {int} Id id of episode to load thumbnail
*
* @apiSuccess {string} . Base64 encoded Thubnail
*/
AddHandler("readThumbnail", TVShowNode, func(info *HandlerInfo) []byte {
var args struct {
Id int
}
AddHandler("readThumbnail", TVShowNode, &rtn, func() []byte {
if err := FillStruct(&args, info.Data); err != nil {
fmt.Println(err.Error())
return nil
}
var pic []byte
query := fmt.Sprintf("SELECT thumbnail FROM tvshow WHERE id=%d", rtn.Id)
query := fmt.Sprintf("SELECT thumbnail FROM tvshow WHERE id=%d", args.Id)
err := database.QueryRow(query).Scan(&pic)
if err != nil {
fmt.Printf("the thumbnail of movie id %d couldn't be found", rtn.Id)
fmt.Printf("the thumbnail of movie id %d couldn't be found", args.Id)
return nil
}

83
apiGo/api/Tags.go
View File

@ -13,14 +13,30 @@ func AddTagHandlers() {
}
func deleteFromDB() {
var dT struct {
/**
* @api {post} /api/tags [deleteTag]
* @apiDescription Start Database video reindex Job
* @apiName deleteTag
* @apiGroup Tags
*
* @apiParam {bool} [Force] force delete tag with its constraints
* @apiParam {int} TagId id of tag to delete
*
* @apiSuccess {string} result 'success' if successfully or error message if not
*/
AddHandler("deleteTag", TagNode, func(info *HandlerInfo) []byte {
var args struct {
TagId int
Force bool
}
AddHandler("deleteTag", TagNode, &dT, func() []byte {
if err := FillStruct(&args, info.Data); err != nil {
fmt.Println(err.Error())
return nil
}
// delete key constraints first
if dT.Force {
query := fmt.Sprintf("DELETE FROM video_tags WHERE tag_id=%d", dT.TagId)
if args.Force {
query := fmt.Sprintf("DELETE FROM video_tags WHERE tag_id=%d", args.TagId)
err := database.Edit(query)
// respond only if result not successful
@ -29,7 +45,7 @@ func deleteFromDB() {
}
}
query := fmt.Sprintf("DELETE FROM tags WHERE tag_id=%d", dT.TagId)
query := fmt.Sprintf("DELETE FROM tags WHERE tag_id=%d", args.TagId)
err := database.Edit(query)
if err == nil {
@ -39,7 +55,7 @@ func deleteFromDB() {
// check with regex if its the key constraint error
r := regexp.MustCompile("^.*a foreign key constraint fails.*$")
if r.MatchString(err.Error()) {
return []byte(`{"result":"not empty tag"}`)
return database.ManualSuccessResponse(fmt.Errorf("not empty tag"))
} else {
return database.ManualSuccessResponse(err)
}
@ -48,27 +64,68 @@ func deleteFromDB() {
}
func getFromDB() {
AddHandler("getAllTags", TagNode, nil, func() []byte {
/**
* @api {post} /api/tags [getAllTags]
* @apiDescription get all available Tags
* @apiName getAllTags
* @apiGroup Tags
*
* @apiSuccess {Object[]} array of tag objects
* @apiSuccess {uint32} TagId
* @apiSuccess {string} TagName name of the Tag
*/
AddHandler("getAllTags", TagNode, func(info *HandlerInfo) []byte {
query := "SELECT tag_id,tag_name from tags"
return jsonify(readTagsFromResultset(database.Query(query)))
})
}
func addToDB() {
var ct struct {
/**
* @api {post} /api/tags [createTag]
* @apiDescription create a new tag
* @apiName createTag
* @apiGroup Tags
*
* @apiParam {string} TagName name of the tag
*
* @apiSuccess {string} result 'success' if successfully or error message if not
*/
AddHandler("createTag", TagNode, func(info *HandlerInfo) []byte {
var args struct {
TagName string
}
AddHandler("createTag", TagNode, &ct, func() []byte {
if err := FillStruct(&args, info.Data); err != nil {
fmt.Println(err.Error())
return nil
}
query := "INSERT IGNORE INTO tags (tag_name) VALUES (?)"
return database.SuccessQuery(query, ct.TagName)
return database.SuccessQuery(query, args.TagName)
})
var at struct {
/**
* @api {post} /api/tags [addTag]
* @apiDescription Add new tag to video
* @apiName addTag
* @apiGroup Tags
*
* @apiParam {int} TagId Tag id to add to video
* @apiParam {int} MovieId Video Id of video to add tag to
*
* @apiSuccess {string} result 'success' if successfully or error message if not
*/
AddHandler("addTag", TagNode, func(info *HandlerInfo) []byte {
var args struct {
MovieId int
TagId int
}
AddHandler("addTag", TagNode, &at, func() []byte {
if err := FillStruct(&args, info.Data); err != nil {
fmt.Println(err.Error())
return nil
}
query := "INSERT IGNORE INTO video_tags(tag_id, video_id) VALUES (?,?)"
return database.SuccessQuery(query, at.TagId, at.MovieId)
return database.SuccessQuery(query, args.TagId, args.MovieId)
})
}

208
apiGo/api/Video.go
View File

@ -16,18 +16,35 @@ func AddVideoHandlers() {
}
func getVideoHandlers() {
var mrq struct {
/**
* @api {post} /api/video [getMovies]
* @apiDescription Request available Videos
* @apiName GetMovies
* @apiGroup video
*
* @apiParam {int} [Tag=all] id of VideoTag to get videos
*
* @apiSuccess {Object[]} . List of Videos
* @apiSuccess {number} .MovieId Id of Video
* @apiSuccess {String} .MovieName Name of video
*/
AddHandler("getMovies", VideoNode, func(info *HandlerInfo) []byte {
var args struct {
Tag int
}
AddHandler("getMovies", VideoNode, &mrq, func() []byte {
if err := FillStruct(&args, info.Data); err != nil {
fmt.Println(err.Error())
return nil
}
var query string
// 1 is the id of the ALL tag
if mrq.Tag != 1 {
if args.Tag != 1 {
query = fmt.Sprintf(`SELECT movie_id,movie_name FROM videos
INNER JOIN video_tags vt on videos.movie_id = vt.video_id
INNER JOIN tags t on vt.tag_id = t.tag_id
WHERE t.tag_id = '%d'
ORDER BY likes DESC, create_date, movie_name`, mrq.Tag)
ORDER BY likes DESC, create_date, movie_name`, args.Tag)
} else {
query = "SELECT movie_id,movie_name FROM videos ORDER BY create_date DESC, movie_name"
}
@ -38,33 +55,69 @@ func getVideoHandlers() {
return str
})
var rtn struct {
/**
* @api {post} /api/video [readThumbnail]
* @apiDescription Load Thubnail of specific Video
* @apiName readThumbnail
* @apiGroup video
*
* @apiParam {int} Movieid id of video to load thumbnail
*
* @apiSuccess {string} . Base64 encoded Thubnail
*/
AddHandler("readThumbnail", VideoNode, func(info *HandlerInfo) []byte {
var args struct {
Movieid int
}
AddHandler("readThumbnail", VideoNode, &rtn, func() []byte {
if err := FillStruct(&args, info.Data); err != nil {
fmt.Println(err.Error())
return nil
}
var pic []byte
query := fmt.Sprintf("SELECT thumbnail FROM videos WHERE movie_id=%d", rtn.Movieid)
query := fmt.Sprintf("SELECT thumbnail FROM videos WHERE movie_id=%d", args.Movieid)
err := database.QueryRow(query).Scan(&pic)
if err != nil {
fmt.Printf("the thumbnail of movie id %d couldn't be found", rtn.Movieid)
fmt.Printf("the thumbnail of movie id %d couldn't be found", args.Movieid)
return nil
}
return pic
})
var grm struct {
/**
* @api {post} /api/video [getRandomMovies]
* @apiDescription Load random videos
* @apiName getRandomMovies
* @apiGroup video
*
* @apiParam {int} Number number of random videos to load
*
* @apiSuccess {Object[]} Tags Array of tags occuring in selection
* @apiSuccess {string} Tags.TagName Tagname
* @apiSuccess {uint32} Tags.TagId Tag ID
*
* @apiSuccess {Object[]} Videos Array of the videos
* @apiSuccess {string} Videos.MovieName Video Name
* @apiSuccess {int} Videos.MovieId Video ID
*/
AddHandler("getRandomMovies", VideoNode, func(info *HandlerInfo) []byte {
var args struct {
Number int
}
AddHandler("getRandomMovies", VideoNode, &grm, func() []byte {
if err := FillStruct(&args, info.Data); err != nil {
fmt.Println(err.Error())
return nil
}
var result struct {
Tags []types.Tag
Videos []types.VideoUnloadedType
}
query := fmt.Sprintf("SELECT movie_id,movie_name FROM videos ORDER BY RAND() LIMIT %d", grm.Number)
query := fmt.Sprintf("SELECT movie_id,movie_name FROM videos ORDER BY RAND() LIMIT %d", args.Number)
result.Videos = readVideosFromResultset(database.Query(query))
var ids string
@ -99,13 +152,30 @@ func getVideoHandlers() {
return str
})
var gsk struct {
/**
* @api {post} /api/video [getSearchKeyWord]
* @apiDescription Get videos for search keyword
* @apiName getSearchKeyWord
* @apiGroup video
*
* @apiParam {string} KeyWord Keyword to search for
*
* @apiSuccess {Object[]} . List of Videos
* @apiSuccess {number} .MovieId Id of Video
* @apiSuccess {String} .MovieName Name of video
*/
AddHandler("getSearchKeyWord", VideoNode, func(info *HandlerInfo) []byte {
var args struct {
KeyWord string
}
AddHandler("getSearchKeyWord", VideoNode, &gsk, func() []byte {
if err := FillStruct(&args, info.Data); err != nil {
fmt.Println(err.Error())
return nil
}
query := fmt.Sprintf(`SELECT movie_id,movie_name FROM videos
WHERE movie_name LIKE '%%%s%%'
ORDER BY likes DESC, create_date DESC, movie_name`, gsk.KeyWord)
ORDER BY likes DESC, create_date DESC, movie_name`, args.KeyWord)
result := readVideosFromResultset(database.Query(query))
// jsonify results
@ -116,12 +186,47 @@ func getVideoHandlers() {
// function to handle stuff for loading specific videos and startdata
func loadVideosHandlers() {
var lv struct {
/**
* @api {post} /api/video [loadVideo]
* @apiDescription Load all data for a specific video
* @apiName loadVideo
* @apiGroup video
*
* @apiParam {int} MovieId ID of video
*
* @apiSuccess {string} MovieName Videoname
* @apiSuccess {uint32} MovieId Video ID
* @apiSuccess {string} MovieUrl Url to video file
* @apiSuccess {string} Poster Base64 encoded Poster
* @apiSuccess {uint64} Likes Number of likes
* @apiSuccess {uint16} Quality Video FrameWidth
* @apiSuccess {uint16} Length Video Length in seconds
*
*
* @apiSuccess {Object[]} Tags Array of tags of video
* @apiSuccess {string} Tags.TagName Tagname
* @apiSuccess {uint32} Tags.TagId Tag ID
*
* @apiSuccess {Object[]} SuggestedTag Array of tags for quick add suggestions
* @apiSuccess {string} SuggestedTag.TagName Tagname
* @apiSuccess {uint32} SuggestedTag.TagId Tag ID
*
* @apiSuccess {Object[]} Actors Array of Actors playing in this video
* @apiSuccess {uint32} Actors.ActorId Actor Id
* @apiSuccess {string} Actors.Name Actor Name
* @apiSuccess {string} Actors.Thumbnail Portrait Thumbnail
*/
AddHandler("loadVideo", VideoNode, func(info *HandlerInfo) []byte {
var args struct {
MovieId int
}
AddHandler("loadVideo", VideoNode, &lv, func() []byte {
if err := FillStruct(&args, info.Data); err != nil {
fmt.Println(err.Error())
return nil
}
query := fmt.Sprintf(`SELECT movie_name,movie_url,movie_id,thumbnail,poster,likes,quality,length
FROM videos WHERE movie_id=%d`, lv.MovieId)
FROM videos WHERE movie_id=%d`, args.MovieId)
var res types.FullVideoType
var poster []byte
@ -129,7 +234,7 @@ func loadVideosHandlers() {
err := database.QueryRow(query).Scan(&res.MovieName, &res.MovieUrl, &res.MovieId, &thumbnail, &poster, &res.Likes, &res.Quality, &res.Length)
if err != nil {
fmt.Printf("error getting full data list of videoid - %d", lv.MovieId)
fmt.Printf("error getting full data list of videoid - %d", args.MovieId)
fmt.Println(err.Error())
return nil
}
@ -149,7 +254,7 @@ func loadVideosHandlers() {
query = fmt.Sprintf(`SELECT t.tag_id, t.tag_name FROM video_tags
INNER JOIN tags t on video_tags.tag_id = t.tag_id
WHERE video_tags.video_id=%d
GROUP BY t.tag_id`, lv.MovieId)
GROUP BY t.tag_id`, args.MovieId)
res.Tags = readTagsFromResultset(database.Query(query))
@ -158,14 +263,14 @@ func loadVideosHandlers() {
SELECT video_tags.tag_id FROM video_tags
WHERE video_id=%d)
ORDER BY rand()
LIMIT 5`, lv.MovieId)
LIMIT 5`, args.MovieId)
res.SuggestedTag = readTagsFromResultset(database.Query(query))
// query the actors corresponding to video
query = fmt.Sprintf(`SELECT a.actor_id, name, thumbnail FROM actors_videos
JOIN actors a on actors_videos.actor_id = a.actor_id
WHERE actors_videos.video_id=%d`, lv.MovieId)
WHERE actors_videos.video_id=%d`, args.MovieId)
res.Actors = readActorsFromResultset(database.Query(query))
@ -174,7 +279,20 @@ func loadVideosHandlers() {
return str
})
AddHandler("getStartData", VideoNode, nil, func() []byte {
/**
* @api {post} /api/video [getStartData]
* @apiDescription Get general video informations at start
* @apiName getStartData
* @apiGroup video
*
* @apiSuccess {uint32} VideoNr Total nr of videos
* @apiSuccess {uint32} FullHdNr number of FullHD videos
* @apiSuccess {uint32} HDNr number of HD videos
* @apiSuccess {uint32} SDNr number of SD videos
* @apiSuccess {uint32} DifferentTags number of different Tags available
* @apiSuccess {uint32} Tagged number of different Tags assigned
*/
AddHandler("getStartData", VideoNode, func(info *HandlerInfo) []byte {
var result types.StartData
// query settings and infotile values
query := `
@ -215,24 +333,54 @@ func loadVideosHandlers() {
}
func addToVideoHandlers() {
var al struct {
/**
* @api {post} /api/video [addLike]
* @apiDescription Add a like to a video
* @apiName addLike
* @apiGroup video
*
* @apiParam {int} MovieId ID of video
*
* @apiSuccess {string} result 'success' if successfully or error message if not
*/
AddHandler("addLike", VideoNode, func(info *HandlerInfo) []byte {
var args struct {
MovieId int
}
AddHandler("addLike", VideoNode, &al, func() []byte {
query := fmt.Sprintf("update videos set likes = likes + 1 where movie_id = %d", al.MovieId)
if err := FillStruct(&args, info.Data); err != nil {
fmt.Println(err.Error())
return nil
}
query := fmt.Sprintf("update videos set likes = likes + 1 where movie_id = %d", args.MovieId)
return database.SuccessQuery(query)
})
var dv struct {
/**
* @api {post} /api/video [deleteVideo]
* @apiDescription Delete a specific video from database
* @apiName deleteVideo
* @apiGroup video
*
* @apiParam {int} MovieId ID of video
*
* @apiSuccess {string} result 'success' if successfully or error message if not
*/
AddHandler("deleteVideo", VideoNode, func(info *HandlerInfo) []byte {
var args struct {
MovieId int
}
AddHandler("deleteVideo", VideoNode, &dv, func() []byte {
if err := FillStruct(&args, info.Data); err != nil {
fmt.Println(err.Error())
return nil
}
// delete tag constraints
query := fmt.Sprintf("DELETE FROM video_tags WHERE video_id=%d", dv.MovieId)
query := fmt.Sprintf("DELETE FROM video_tags WHERE video_id=%d", args.MovieId)
err := database.Edit(query)
// delete actor constraints
query = fmt.Sprintf("DELETE FROM actors_videos WHERE video_id=%d", dv.MovieId)
query = fmt.Sprintf("DELETE FROM actors_videos WHERE video_id=%d", args.MovieId)
err = database.Edit(query)
// respond only if result not successful
@ -240,7 +388,7 @@ func addToVideoHandlers() {
return database.ManualSuccessResponse(err)
}
query = fmt.Sprintf("DELETE FROM videos WHERE movie_id=%d", dv.MovieId)
query = fmt.Sprintf("DELETE FROM videos WHERE movie_id=%d", args.MovieId)
return database.SuccessQuery(query)
})
}

7
apiGo/api/oauth/Oauth.go
View File

@ -1,6 +1,7 @@
package oauth
import (
"gopkg.in/oauth2.v3"
"gopkg.in/oauth2.v3/errors"
"gopkg.in/oauth2.v3/manage"
"gopkg.in/oauth2.v3/server"
@ -48,14 +49,14 @@ func InitOAuth() {
})
}
func ValidateToken(f func(rw http.ResponseWriter, req *http.Request, node int), node int) http.HandlerFunc {
func ValidateToken(f func(rw http.ResponseWriter, req *http.Request, node int, tokenInfo *oauth2.TokenInfo), node int) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
_, err := srv.ValidationBearerToken(r)
tokeninfo, err := srv.ValidationBearerToken(r)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
f(w, r, node)
f(w, r, node, &tokeninfo)
}
}

12
package.json
View File

@ -25,7 +25,8 @@
"start": "react-scripts start",
"build": "CI=false react-scripts build",
"test": "CI=true react-scripts test --reporters=jest-junit --verbose --silent --coverage --reporters=default",
"lint": "eslint --format gitlab src/"
"lint": "eslint --format gitlab src/",
"apidoc": "apidoc -i apiGo/ -o doc/"
},
"jest": {
"collectCoverageFrom": [
@ -76,6 +77,13 @@
"jest-junit": "^12.0.0",
"prettier": "^2.2.1",
"prettier-config": "^1.0.0",
"react-scripts": "4.0.3"
"react-scripts": "4.0.3",
"apidoc": "^0.28.1"
},
"apidoc":{
"name": "OpenMediaCenter",
"description": "API Documentation of OpenMediaCenter",
"title": "OpenMediaCenter Doc",
"sampleUrl": null
}
}

2
src/elements/VideoContainer/VideoContainer.tsx
View File

@ -20,7 +20,7 @@ const VideoContainer = (props: Props): JSX.Element => {
APINode.Video,
{
action: 'readThumbnail',
movieid: el.MovieId
Movieid: el.MovieId
},
(result) => callback(result)
);

2
src/pages/CategoryPage/CategoryView.tsx
View File

@ -105,7 +105,7 @@ export class CategoryView extends React.Component<CategoryViewProps, CategoryVie
* @param id tagid
*/
private fetchVideoData(id: number): void {
callAPI<VideoTypes.VideoUnloadedType[]>(APINode.Video, {action: 'getMovies', tag: id}, (result) => {
callAPI<VideoTypes.VideoUnloadedType[]>(APINode.Video, {action: 'getMovies', Tag: id}, (result) => {
this.videodata = result;
this.setState({loaded: true});
});

2
src/pages/HomePage/HomePage.tsx
View File

@ -59,7 +59,7 @@ export class HomePage extends React.Component<Props, state> {
* @param tag tag to fetch videos
*/
fetchVideoData(tag: number): void {
callAPI(APINode.Video, {action: 'getMovies', tag: tag}, (result: VideoTypes.VideoUnloadedType[]) => {
callAPI(APINode.Video, {action: 'getMovies', Tag: tag}, (result: VideoTypes.VideoUnloadedType[]) => {
this.setState({
data: []
});

2
src/pages/HomePage/SearchHandling.tsx
View File

@ -57,7 +57,7 @@ export class SearchHandling extends React.Component<Props, state> {
* @param keyword The keyword to search for
*/
searchVideos(keyword: string): void {
callAPI(APINode.Video, {action: 'getSearchKeyWord', keyword: keyword}, (result: VideoTypes.VideoUnloadedType[]) => {
callAPI(APINode.Video, {action: 'getSearchKeyWord', KeyWord: keyword}, (result: VideoTypes.VideoUnloadedType[]) => {
this.setState({
data: result
});

3
src/pages/RandomPage/RandomPage.tsx
View File

@ -85,8 +85,7 @@ class RandomPage extends React.Component<{}, state> {
* @param nr number of videos to load
*/
loadShuffledvideos(nr: number): void {
callAPI<GetRandomMoviesType>(APINode.Video, {action: 'getRandomMovies', number: nr}, (result) => {
console.log(result);
callAPI<GetRandomMoviesType>(APINode.Video, {action: 'getRandomMovies', Number: nr}, (result) => {
this.setState({videos: []}); // needed to trigger rerender of main videoview
this.setState({
videos: result.Videos,

627
yarn.lock
View File

File diff suppressed because it is too large Load Diff