extract thubnail picture size from raw bytes in backend

apiGo/api/Actors.go

@@ -12,83 +12,32 @@ 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]
+		MovieId int
-	 * @apiDescription Get all actors playing in one video
+	}
-	 * @apiName getActorsOfVideo
+	AddHandler("getActorsOfVideo", ActorNode, &gaov, func() []byte {
-	 * @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
-		}
-		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`, args.MovieId)
+									WHERE actors_videos.video_id=%d`, gaov.MovieId)
 
 		return jsonify(readActorsFromResultset(database.Query(query)))
 	})
 
-	/**
+	var gai struct {
-	 * @api {post} /api/actor [getActorInfo]
+		ActorId int
-	 * @apiDescription Get all infos for an actor
+	}
-	 * @apiName getActorInfo
+	AddHandler("getActorInfo", ActorNode, &gai, func() []byte {
-	 * @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
-		}
-		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`, args.ActorId)
+										WHERE actors_videos.actor_id=%d`, gai.ActorId)
 		videos := readVideosFromResultset(database.Query(query))
 
-		query = fmt.Sprintf("SELECT actor_id, name, thumbnail FROM actors WHERE actor_id=%d", args.ActorId)
+		query = fmt.Sprintf("SELECT actor_id, name, thumbnail FROM actors WHERE actor_id=%d", gai.ActorId)
 		actor := readActorsFromResultset(database.Query(query))[0]
 
 		var result = struct {
@@ -104,51 +53,20 @@ func getActorsFromDB() {
 }
 
 func saveActorsToDB() {
-	/**
+	var ca struct {
-	 * @api {post} /api/video [createActor]
+		ActorName string
-	 * @apiDescription Create a new Actor
+	}
-	 * @apiName createActor
+	AddHandler("createActor", ActorNode, &ca, func() []byte {
-	 * @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
-		}
-		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, args.ActorName)
+		return database.SuccessQuery(query, ca.ActorName)
 	})
 
-	/**
+	var aatv struct {
-	 * @api {post} /api/video [addActorToVideo]
+		ActorId int
-	 * @apiDescription Add Actor to Video
+		MovieId int
-	 * @apiName addActorToVideo
+	}
-	 * @apiGroup Actor
+	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)
-	 * @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
-		}
-		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)
 	})
 }

apiGo/api/ApiBase.go

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

apiGo/api/ApiBase_test.go

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

apiGo/api/Helpers.go

@@ -3,10 +3,8 @@ package api
 import (
 	"database/sql"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"openmediacenter/apiGo/api/types"
-	"reflect"
 )
 
 // MovieId - MovieName : pay attention to the order!
@@ -87,45 +85,3 @@ 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
-}

apiGo/api/Settings.go

@@ -2,7 +2,6 @@ package api
 
 import (
 	"encoding/json"
-	"fmt"
 	"openmediacenter/apiGo/api/types"
 	"openmediacenter/apiGo/database"
 	"openmediacenter/apiGo/database/settings"
@@ -18,43 +17,11 @@ 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 {
@@ -85,32 +52,10 @@ func getSettingsFromDB() {
 }
 
 func saveSettingsToDB() {
-	/**
+	var sgs struct {
-	 * @api {post} /api/settings [saveGeneralSettings]
+		Settings types.SettingsType
-	 * @apiDescription Save the global settings provided
+	}
-	 * @apiName saveGeneralSettings
+	AddHandler("saveGeneralSettings", SettingsNode, &sgs, func() []byte {
-	 * @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
-		}
-		if err := FillStruct(&args, info.Data); err != nil {
-			fmt.Println(err.Error())
-			return nil
-		}
-
 		query := `
 					UPDATE settings SET 
                         video_path=?,
@@ -121,46 +66,24 @@ func saveSettingsToDB() {
                         DarkMode=?
                     WHERE 1`
 		return database.SuccessQuery(query,
-			args.Settings.VideoPath, args.Settings.EpisodePath, args.Settings.Password,
+			sgs.Settings.VideoPath, sgs.Settings.EpisodePath, sgs.Settings.Password,
-			args.Settings.MediacenterName, args.Settings.TMDBGrabbing, args.Settings.DarkMode)
+			sgs.Settings.MediacenterName, sgs.Settings.TMDBGrabbing, sgs.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
 	})

apiGo/api/TVShows.go

@@ -6,46 +6,17 @@ 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]
+		ShowID uint32
-	 * @apiDescription get all Episodes of a TVShow
+	}
-	 * @apiName getEpisodes
+	AddHandler("getEpisodes", TVShowNode, &ge, func() []byte {
-	 * @apiGroup TVshow
+		query := fmt.Sprintf("SELECT id, name, season, episode FROM tvshow_episodes WHERE tvshow_id=%d", ge.ShowID)
-	 *
-	 * @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
-		}
-		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 {
@@ -70,34 +41,15 @@ func AddTvshowHandlers() {
 		return jsonify(episodes)
 	})
 
-	/**
+	var le struct {
-	 * @api {post} /api/tvshow [loadEpisode]
+		ID uint32
-	 * @apiDescription load all info of episode
+	}
-	 * @apiName loadEpisode
+	AddHandler("loadEpisode", TVShowNode, &le, func() []byte {
-	 * @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
-		}
-		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`, args.ID)
+WHERE tvshow_episodes.id=%d`, le.ID)
 		row := database.QueryRow(query)
 
 		var ret struct {
@@ -121,32 +73,17 @@ WHERE tvshow_episodes.id=%d`, args.ID)
 		return jsonify(ret)
 	})
 
-	/**
+	var rtn struct {
-	 * @api {post} /api/tvshow [readThumbnail]
+		Id int
-	 * @apiDescription Load Thubnail of specific episode
+	}
-	 * @apiName readThumbnail
+	AddHandler("readThumbnail", TVShowNode, &rtn, func() []byte {
-	 * @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
-		}
-		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", args.Id)
+		query := fmt.Sprintf("SELECT thumbnail FROM tvshow WHERE id=%d", rtn.Id)
 
 		err := database.QueryRow(query).Scan(&pic)
 		if err != nil {
-			fmt.Printf("the thumbnail of movie id %d couldn't be found", args.Id)
+			fmt.Printf("the thumbnail of movie id %d couldn't be found", rtn.Id)
 			return nil
 		}
 

apiGo/api/Tags.go

@@ -13,30 +13,14 @@ func AddTagHandlers() {
 }
 
 func deleteFromDB() {
-	/**
+	var dT struct {
-	 * @api {post} /api/tags [deleteTag]
+		TagId int
-	 * @apiDescription Start Database video reindex Job
+		Force bool
-	 * @apiName deleteTag
+	}
-	 * @apiGroup Tags
+	AddHandler("deleteTag", TagNode, &dT, func() []byte {
-	 *
-	 * @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
-		}
-		if err := FillStruct(&args, info.Data); err != nil {
-			fmt.Println(err.Error())
-			return nil
-		}
-
 		// delete key constraints first
-		if args.Force {
+		if dT.Force {
-			query := fmt.Sprintf("DELETE FROM video_tags WHERE tag_id=%d", args.TagId)
+			query := fmt.Sprintf("DELETE FROM video_tags WHERE tag_id=%d", dT.TagId)
 			err := database.Edit(query)
 
 			// respond only if result not successful
@@ -45,7 +29,7 @@ func deleteFromDB() {
 			}
 		}
 
-		query := fmt.Sprintf("DELETE FROM tags WHERE tag_id=%d", args.TagId)
+		query := fmt.Sprintf("DELETE FROM tags WHERE tag_id=%d", dT.TagId)
 		err := database.Edit(query)
 
 		if err == nil {
@@ -55,7 +39,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 database.ManualSuccessResponse(fmt.Errorf("not empty tag"))
+				return []byte(`{"result":"not empty tag"}`)
 			} else {
 				return database.ManualSuccessResponse(err)
 			}
@@ -64,68 +48,27 @@ 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]
+		TagName string
-	 * @apiDescription create a new tag
+	}
-	 * @apiName createTag
+	AddHandler("createTag", TagNode, &ct, func() []byte {
-	 * @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
-		}
-		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, args.TagName)
+		return database.SuccessQuery(query, ct.TagName)
 	})
 
-	/**
+	var at struct {
-	 * @api {post} /api/tags [addTag]
+		MovieId int
-	 * @apiDescription Add new tag to video
+		TagId   int
-	 * @apiName addTag
+	}
-	 * @apiGroup Tags
+	AddHandler("addTag", TagNode, &at, func() []byte {
-	 *
-	 * @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
-		}
-		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, args.TagId, args.MovieId)
+		return database.SuccessQuery(query, at.TagId, at.MovieId)
 	})
 }

apiGo/api/Video.go

@@ -16,35 +16,18 @@ func AddVideoHandlers() {
 }
 
 func getVideoHandlers() {
-	/**
+	var mrq struct {
-	 * @api {post} /api/video [getMovies]
+		Tag int
-	 * @apiDescription Request available Videos
+	}
-	 * @apiName GetMovies
+	AddHandler("getMovies", VideoNode, &mrq, func() []byte {
-	 * @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
-		}
-		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 args.Tag != 1 {
+		if mrq.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`, args.Tag)
+					ORDER BY likes DESC, create_date, movie_name`, mrq.Tag)
 		} else {
 			query = "SELECT movie_id,movie_name FROM videos ORDER BY create_date DESC, movie_name"
 		}
@@ -55,69 +38,33 @@ func getVideoHandlers() {
 		return str
 	})
 
-	/**
+	var rtn struct {
-	 * @api {post} /api/video [readThumbnail]
+		Movieid int
-	 * @apiDescription Load Thubnail of specific Video
+	}
-	 * @apiName readThumbnail
+	AddHandler("readThumbnail", VideoNode, &rtn, func() []byte {
-	 * @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
-		}
-		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", args.Movieid)
+		query := fmt.Sprintf("SELECT thumbnail FROM videos WHERE movie_id=%d", rtn.Movieid)
 
 		err := database.QueryRow(query).Scan(&pic)
 		if err != nil {
-			fmt.Printf("the thumbnail of movie id %d couldn't be found", args.Movieid)
+			fmt.Printf("the thumbnail of movie id %d couldn't be found", rtn.Movieid)
 			return nil
 		}
 
 		return pic
 	})
 
-	/**
+	var grm struct {
-	 * @api {post} /api/video [getRandomMovies]
+		Number int
-	 * @apiDescription Load random videos
+	}
-	 * @apiName getRandomMovies
+	AddHandler("getRandomMovies", VideoNode, &grm, func() []byte {
-	 * @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
-		}
-		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", args.Number)
+		query := fmt.Sprintf("SELECT movie_id,movie_name FROM videos ORDER BY RAND() LIMIT %d", grm.Number)
 		result.Videos = readVideosFromResultset(database.Query(query))
 
 		var ids string
@@ -152,30 +99,13 @@ func getVideoHandlers() {
 		return str
 	})
 
-	/**
+	var gsk struct {
-	 * @api {post} /api/video [getSearchKeyWord]
+		KeyWord string
-	 * @apiDescription Get videos for search keyword
+	}
-	 * @apiName getSearchKeyWord
+	AddHandler("getSearchKeyWord", VideoNode, &gsk, func() []byte {
-	 * @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
-		}
-		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`, args.KeyWord)
+					ORDER BY likes DESC, create_date DESC, movie_name`, gsk.KeyWord)
 
 		result := readVideosFromResultset(database.Query(query))
 		// jsonify results
@@ -186,47 +116,12 @@ func getVideoHandlers() {
 
 // function to handle stuff for loading specific videos and startdata
 func loadVideosHandlers() {
-	/**
+	var lv struct {
-	 * @api {post} /api/video [loadVideo]
+		MovieId int
-	 * @apiDescription Load all data for a specific video
+	}
-	 * @apiName loadVideo
+	AddHandler("loadVideo", VideoNode, &lv, func() []byte {
-	 * @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
-		}
-		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`, args.MovieId)
+										FROM videos WHERE movie_id=%d`, lv.MovieId)
 
 		var res types.FullVideoType
 		var poster []byte
@@ -234,7 +129,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", args.MovieId)
+			fmt.Printf("error getting full data list of videoid - %d", lv.MovieId)
 			fmt.Println(err.Error())
 			return nil
 		}
@@ -254,7 +149,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`, args.MovieId)
+					GROUP BY t.tag_id`, lv.MovieId)
 
 		res.Tags = readTagsFromResultset(database.Query(query))
 
@@ -263,14 +158,14 @@ func loadVideosHandlers() {
 						SELECT video_tags.tag_id FROM video_tags
 					WHERE video_id=%d)
 					ORDER BY rand()
-					LIMIT 5`, args.MovieId)
+					LIMIT 5`, lv.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`, args.MovieId)
+					WHERE actors_videos.video_id=%d`, lv.MovieId)
 
 		res.Actors = readActorsFromResultset(database.Query(query))
 
@@ -279,20 +174,7 @@ 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 := `
@@ -333,54 +215,24 @@ func loadVideosHandlers() {
 }
 
 func addToVideoHandlers() {
-	/**
+	var al struct {
-	 * @api {post} /api/video [addLike]
+		MovieId int
-	 * @apiDescription Add a like to a video
+	}
-	 * @apiName addLike
+	AddHandler("addLike", VideoNode, &al, func() []byte {
-	 * @apiGroup video
+		query := fmt.Sprintf("update videos set likes = likes + 1 where movie_id = %d", al.MovieId)
-	 *
-	 * @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
-		}
-		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]
+		MovieId int
-	 * @apiDescription Delete a specific video from database
+	}
-	 * @apiName deleteVideo
+	AddHandler("deleteVideo", VideoNode, &dv, func() []byte {
-	 * @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
-		}
-		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", args.MovieId)
+		query := fmt.Sprintf("DELETE FROM video_tags WHERE video_id=%d", dv.MovieId)
 		err := database.Edit(query)
 
 		// delete actor constraints
-		query = fmt.Sprintf("DELETE FROM actors_videos WHERE video_id=%d", args.MovieId)
+		query = fmt.Sprintf("DELETE FROM actors_videos WHERE video_id=%d", dv.MovieId)
 		err = database.Edit(query)
 
 		// respond only if result not successful
@@ -388,7 +240,7 @@ func addToVideoHandlers() {
 			return database.ManualSuccessResponse(err)
 		}
 
-		query = fmt.Sprintf("DELETE FROM videos WHERE movie_id=%d", args.MovieId)
+		query = fmt.Sprintf("DELETE FROM videos WHERE movie_id=%d", dv.MovieId)
 		return database.SuccessQuery(query)
 	})
 }

apiGo/api/oauth/Oauth.go

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

apiGo/videoparser/Helpers.go

@@ -1,9 +1,12 @@
 package videoparser
 
 import (
+	"bytes"
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
+	"image/jpeg"
+	"log"
 	"os/exec"
 	"strconv"
 )
@@ -76,6 +79,16 @@ func parseFFmpegPic(path string) (*string, error) {
 	if strEncPic == "" {
 		return nil, nil
 	}
+
+	// extract dimensions of picture
+	reader := bytes.NewReader(stdout)
+	im, err := jpeg.DecodeConfig(reader)
+	if err != nil {
+		log.Fatal(err)
+	}
+	fmt.Printf("%d %d\n", im.Width, im.Height)
+	// todo use this information somewhere...
+
 	backpic64 := fmt.Sprintf("data:image/jpeg;base64,%s", strEncPic)
 
 	return &backpic64, nil
@@ -106,6 +119,11 @@ func getVideoAttributes(path string) *VideoAttributes {
 		return nil
 	}
 
+	// nil slice check of track array
+	if len(t.Media.Track) == 0 {
+		return nil
+	}
+
 	duration, err := strconv.ParseFloat(t.Media.Track[0].Duration, 32)
 	filesize, err := strconv.Atoi(t.Media.Track[0].FileSize)
 	width, err := strconv.Atoi(t.Media.Track[1].Width)

package.json

@@ -25,8 +25,7 @@
     "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": [
@@ -77,13 +76,6 @@
     "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
   }
 }

src/elements/VideoContainer/VideoContainer.tsx

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

src/pages/CategoryPage/CategoryView.tsx

@@ -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});
         });

src/pages/HomePage/HomePage.tsx

@@ -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: []
             });

src/pages/HomePage/SearchHandling.tsx

@@ -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
             });

src/pages/Player/Player.tsx

@@ -21,7 +21,6 @@ import PlyrJS from 'plyr';
 import {Button} from '../../elements/GPElements/Button';
 import {VideoTypes} from '../../types/ApiTypes';
 import GlobalInfos from '../../utils/GlobalInfos';
-import KeyComponent from '../../utils/KeyComponent';
 
 interface Props extends RouteComponentProps<{id: string}> {}
 
@@ -43,7 +42,7 @@ interface mystate {
  * Player page loads when a video is selected to play and handles the video view
  * and actions such as tag adding and liking
  */
-export class Player extends KeyComponent<Props, mystate> {
+export class Player extends React.Component<Props, mystate> {
     constructor(props: Props) {
         super(props);
 
@@ -63,19 +62,7 @@ export class Player extends KeyComponent<Props, mystate> {
         this.quickAddTag = this.quickAddTag.bind(this);
     }
 
-    keyHandler(key: string): void {
-        switch (key) {
-            case 't':
-                this.setState({popupvisible: true});
-                break;
-            case 'a':
-                this.setState({actorpopupvisible: true});
-                break;
-        }
-    }
-
     componentDidMount(): void {
-        super.componentDidMount();
         // initial fetch of current movie data
         this.fetchMovieData();
     }

src/pages/RandomPage/RandomPage.tsx

@@ -85,7 +85,8 @@ 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) => {
+        callAPI<GetRandomMoviesType>(APINode.Video, {action: 'getRandomMovies', number: nr}, (result) => {
+            console.log(result);
             this.setState({videos: []}); // needed to trigger rerender of main videoview
             this.setState({
                 videos: result.Videos,

src/utils/KeyComponent.ts

@@ -1,25 +0,0 @@
-import * as React from 'react';
-
-abstract class KeyComponent<P = {}, S = {}> extends React.Component<P, S> {
-    constructor(props: P) {
-        super(props);
-
-        this.handler = this.handler.bind(this);
-    }
-
-    componentDidMount(): void {
-        document.addEventListener('keyup', this.handler);
-    }
-
-    componentWillUnmount(): void {
-        document.removeEventListener('keyup', this.handler);
-    }
-
-    private handler(e: KeyboardEvent): void {
-        this.keyHandler(e.key);
-    }
-
-    abstract keyHandler(key: string): void;
-}
-
-export default KeyComponent;