extract thubnail picture size from raw bytes in backend

2021-05-12 23:29:47 +02:00
19 changed files with 196 additions and 1330 deletions
--- a/apiGo/api/Actors.go
+++ b/apiGo/api/Actors.go
@@ -12,83 +12,32 @@ func AddActorsHandlers() {
 }

 func getActorsFromDB() {
-	/**
-	 * @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 {
+	AddHandler("getAllActors", ActorNode, nil, func() []byte {
 		query := "SELECT actor_id, name, thumbnail FROM actors"
 		return jsonify(readActorsFromResultset(database.Query(query)))
 	})

-	/**
-	 * @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
-		}
-		if err := FillStruct(&args, info.Data); err != nil {
-			fmt.Println(err.Error())
-			return nil
-		}
-
+	var gaov struct {
+		MovieId int
+	}
+	AddHandler("getActorsOfVideo", ActorNode, &gaov, func() []byte {
 		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)))
 	})

-	/**
-	 * @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
-		}
-		if err := FillStruct(&args, info.Data); err != nil {
-			fmt.Println(err.Error())
-			return nil
-		}
-
+	var gai struct {
+		ActorId int
+	}
+	AddHandler("getActorInfo", ActorNode, &gai, func() []byte {
 		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() {
-	/**
-	 * @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
-		}
-		if err := FillStruct(&args, info.Data); err != nil {
-			fmt.Println(err.Error())
-			return nil
-		}
-
+	var ca struct {
+		ActorName string
+	}
+	AddHandler("createActor", ActorNode, &ca, func() []byte {
 		query := "INSERT IGNORE INTO actors (name) VALUES (?)"
-		return database.SuccessQuery(query, args.ActorName)
+		return database.SuccessQuery(query, ca.ActorName)
 	})

-	/**
-	 * @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
-		}
-		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)
+	var aatv 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)
 		return database.SuccessQuery(query)
 	})
 }
--- a/apiGo/api/ApiBase.go
+++ b/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
-	handler func(info *HandlerInfo) []byte
-	apiNode int
+	action    string
+	handler   func() []byte
+	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 {
-	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
-	}
+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

-	// check if info even exists
-	if info == nil {
-		info = &HandlerInfo{}
-	}
+			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)
+				}
+			}

-	// 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")
+			return handlers[i].handler()
 		}
-
-		info.Data = args
 	}
-
-	// call the handler
-	return handler.handler(info)
+	fmt.Printf("no handler found for Action: %d/%s\n", apiNode, action)
+	return nil
 }

-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
-	id := (*tokenInfo).GetClientID()
-
-	userinfo := &HandlerInfo{
-		ID:    id,
-		Token: (*tokenInfo).GetCode(),
-	}
-
-	rw.Write(handleAPICall(t.Action, body, node, userinfo))
+	rw.Write(handleAPICall(t.Action, body, node))
 }
--- a/apiGo/api/ApiBase_test.go
+++ b/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 args struct {
-			Test    string
-			TestInt int
-		}
-		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)
-		}
-
+	var myvar struct {
+		Test    string
+		TestInt int
+	}
+	AddHandler("test", ActorNode, &myvar, func() []byte {
 		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")
--- a/apiGo/api/Helpers.go
+++ b/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
-}
--- a/apiGo/api/Settings.go
+++ b/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() {
-	/**
-	 * @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 {
+	AddHandler("loadGeneralSettings", SettingsNode, nil, func() []byte {
 		result := database.GetSettings()
 		return jsonify(result)
 	})
-
-	/**
-	 * @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 {
+	AddHandler("loadInitialData", SettingsNode, nil, func() []byte {
 		sett := settings.LoadSettings()

 		type InitialDataTypeResponse struct {
@@ -85,32 +52,10 @@ func getSettingsFromDB() {
 }

 func saveSettingsToDB() {
-	/**
-	 * @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
-		}
-		if err := FillStruct(&args, info.Data); err != nil {
-			fmt.Println(err.Error())
-			return nil
-		}
-
+	var sgs struct {
+		Settings types.SettingsType
+	}
+	AddHandler("saveGeneralSettings", SettingsNode, &sgs, func() []byte {
 		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,
-			args.Settings.MediacenterName, args.Settings.TMDBGrabbing, args.Settings.DarkMode)
+			sgs.Settings.VideoPath, sgs.Settings.EpisodePath, sgs.Settings.Password,
+			sgs.Settings.MediacenterName, sgs.Settings.TMDBGrabbing, sgs.Settings.DarkMode)
 	})
 }

 // methods for handling reindexing and cleanup of db gravity
 func reIndexHandling() {
-	/**
-	 * @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 {
+	AddHandler("startReindex", SettingsNode, nil, func() []byte {
 		videoparser.StartReindex()
 		return database.ManualSuccessResponse(nil)
 	})

-	/**
-	 * @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 {
+	AddHandler("startTVShowReindex", SettingsNode, nil, func() []byte {
 		videoparser.StartTVShowReindex()
 		return database.ManualSuccessResponse(nil)
 	})

-	/**
-	 * @api {post} /api/settings [cleanupGravity]
-	 * @apiDescription Start Database cleanup job
-	 * @apiName cleanupGravity
-	 * @apiGroup Settings
-	 */
-	AddHandler("cleanupGravity", SettingsNode, func(info *HandlerInfo) []byte {
+	AddHandler("cleanupGravity", SettingsNode, nil, func() []byte {
 		videoparser.StartCleanup()
 		return nil
 	})
--- a/apiGo/api/TVShows.go
+++ b/apiGo/api/TVShows.go
@@ -6,46 +6,17 @@ import (
 )

 func AddTvshowHandlers() {
-	/**
-	 * @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 {
+	AddHandler("getTVShows", TVShowNode, nil, func() []byte {
 		query := "SELECT id, name FROM tvshow"
 		rows := database.Query(query)
 		return jsonify(readTVshowsFromResultset(rows))
 	})

-	/**
-	 * @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
-		}
-		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)
+	var ge 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)
 		rows := database.Query(query)

 		type Episode struct {
@@ -70,34 +41,15 @@ func AddTvshowHandlers() {
 		return jsonify(episodes)
 	})

-	/**
-	 * @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
-		}
-		if err := FillStruct(&args, info.Data); err != nil {
-			fmt.Println(err.Error())
-			return nil
-		}
-
+	var le struct {
+		ID uint32
+	}
+	AddHandler("loadEpisode", TVShowNode, &le, func() []byte {
 		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)
 	})

-	/**
-	 * @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
-		}
-		if err := FillStruct(&args, info.Data); err != nil {
-			fmt.Println(err.Error())
-			return nil
-		}
-
+	var rtn struct {
+		Id int
+	}
+	AddHandler("readThumbnail", TVShowNode, &rtn, func() []byte {
 		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
 		}

--- a/apiGo/api/Tags.go
+++ b/apiGo/api/Tags.go
@@ -13,30 +13,14 @@ func AddTagHandlers() {
 }

 func deleteFromDB() {
-	/**
-	 * @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
-		}
-		if err := FillStruct(&args, info.Data); err != nil {
-			fmt.Println(err.Error())
-			return nil
-		}
-
+	var dT struct {
+		TagId int
+		Force bool
+	}
+	AddHandler("deleteTag", TagNode, &dT, func() []byte {
 		// delete key constraints first
-		if args.Force {
-			query := fmt.Sprintf("DELETE FROM video_tags WHERE tag_id=%d", args.TagId)
+		if dT.Force {
+			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() {
-	/**
-	 * @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 {
+	AddHandler("getAllTags", TagNode, nil, func() []byte {
 		query := "SELECT tag_id,tag_name from tags"
 		return jsonify(readTagsFromResultset(database.Query(query)))
 	})
 }

 func addToDB() {
-	/**
-	 * @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
-		}
-		if err := FillStruct(&args, info.Data); err != nil {
-			fmt.Println(err.Error())
-			return nil
-		}
-
+	var ct struct {
+		TagName string
+	}
+	AddHandler("createTag", TagNode, &ct, func() []byte {
 		query := "INSERT IGNORE INTO tags (tag_name) VALUES (?)"
-		return database.SuccessQuery(query, args.TagName)
+		return database.SuccessQuery(query, ct.TagName)
 	})

-	/**
-	 * @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
-		}
-		if err := FillStruct(&args, info.Data); err != nil {
-			fmt.Println(err.Error())
-			return nil
-		}
-
+	var at struct {
+		MovieId int
+		TagId   int
+	}
+	AddHandler("addTag", TagNode, &at, func() []byte {
 		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)
 	})
 }
--- a/apiGo/api/Video.go
+++ b/apiGo/api/Video.go
@@ -16,35 +16,18 @@ func AddVideoHandlers() {
 }

 func getVideoHandlers() {
-	/**
-	 * @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
-		}
-		if err := FillStruct(&args, info.Data); err != nil {
-			fmt.Println(err.Error())
-			return nil
-		}
-
+	var mrq struct {
+		Tag int
+	}
+	AddHandler("getMovies", VideoNode, &mrq, func() []byte {
 		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
 	})

-	/**
-	 * @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
-		}
-		if err := FillStruct(&args, info.Data); err != nil {
-			fmt.Println(err.Error())
-			return nil
-		}
-
+	var rtn struct {
+		Movieid int
+	}
+	AddHandler("readThumbnail", VideoNode, &rtn, func() []byte {
 		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
 	})

-	/**
-	 * @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
-		}
-		if err := FillStruct(&args, info.Data); err != nil {
-			fmt.Println(err.Error())
-			return nil
-		}
-
+	var grm struct {
+		Number int
+	}
+	AddHandler("getRandomMovies", VideoNode, &grm, func() []byte {
 		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
 	})

-	/**
-	 * @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
-		}
-		if err := FillStruct(&args, info.Data); err != nil {
-			fmt.Println(err.Error())
-			return nil
-		}
-
+	var gsk struct {
+		KeyWord string
+	}
+	AddHandler("getSearchKeyWord", VideoNode, &gsk, func() []byte {
 		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() {
-	/**
-	 * @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
-		}
-		if err := FillStruct(&args, info.Data); err != nil {
-			fmt.Println(err.Error())
-			return nil
-		}
-
+	var lv struct {
+		MovieId int
+	}
+	AddHandler("loadVideo", VideoNode, &lv, func() []byte {
 		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
 	})

-	/**
-	 * @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 {
+	AddHandler("getStartData", VideoNode, nil, func() []byte {
 		var result types.StartData
 		// query settings and infotile values
 		query := `
@@ -333,54 +215,24 @@ func loadVideosHandlers() {
 }

 func addToVideoHandlers() {
-	/**
-	 * @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
-		}
-		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)
+	var al struct {
+		MovieId int
+	}
+	AddHandler("addLike", VideoNode, &al, func() []byte {
+		query := fmt.Sprintf("update videos set likes = likes + 1 where movie_id = %d", al.MovieId)
 		return database.SuccessQuery(query)
 	})

-	/**
-	 * @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
-		}
-		if err := FillStruct(&args, info.Data); err != nil {
-			fmt.Println(err.Error())
-			return nil
-		}
-
+	var dv struct {
+		MovieId int
+	}
+	AddHandler("deleteVideo", VideoNode, &dv, func() []byte {
 		// 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)
 	})
 }
--- a/apiGo/api/oauth/Oauth.go
+++ b/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)
 	}
 }
--- a/apiGo/videoparser/Helpers.go
+++ b/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)
--- a/package.json
+++ b/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/",
-    "apidoc": "apidoc -i apiGo/ -o doc/"
+    "lint": "eslint --format gitlab src/"
  },
  "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",
-    "apidoc": "^0.28.1"
-  },
-  "apidoc":{
-    "name": "OpenMediaCenter",
-    "description": "API Documentation of OpenMediaCenter",
-    "title": "OpenMediaCenter Doc",
-    "sampleUrl": null
+    "react-scripts": "4.0.3"
  }
 }
--- a/src/elements/VideoContainer/VideoContainer.tsx
+++ b/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)
                        );
--- a/src/pages/CategoryPage/CategoryView.tsx
+++ b/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});
        });
--- a/src/pages/HomePage/HomePage.tsx
+++ b/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: []
            });
--- a/src/pages/HomePage/SearchHandling.tsx
+++ b/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
            });
--- a/src/pages/Player/Player.tsx
+++ b/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();
    }
--- a/src/pages/RandomPage/RandomPage.tsx
+++ b/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,
--- a/src/utils/KeyComponent.ts
+++ b/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;
--- a/yarn.lock
+++ b/yarn.lock