new preview style

api/src/handlers/Tags.php

@@ -1,84 +0,0 @@
-<?php
-require_once 'RequestBase.php';
-
-/**
- * Class Tags
- * backend to handle Tag database interactions
- */
-class Tags extends RequestBase {
-    function initHandlers() {
-        $this->addToDB();
-        $this->getFromDB();
-        $this->delete();
-    }
-
-    private function addToDB() {
-        /**
-         * creates a new tag
-         * query requirements:
-         * * tagname -- name of the new tag
-         */
-        $this->addActionHandler("createTag", function () {
-            // skip tag create if already existing
-            $query = "INSERT IGNORE INTO tags (tag_name) VALUES ('" . $_POST['tagname'] . "')";
-
-            if ($this->conn->query($query) === TRUE) {
-                $this->commitMessage('{"result":"success"}');
-            } else {
-                $this->commitMessage('{"result":"' . $this->conn->error . '"}');
-            }
-        });
-
-        /**
-         * adds a new tag to an existing video
-         *
-         * query requirements:
-         * * movieid  -- the id of the video to add the tag to
-         * * id -- the tag id which tag to add
-         */
-        $this->addActionHandler("addTag", function () {
-            $movieid = $_POST['movieid'];
-            $tagid = $_POST['id'];
-
-            // skip tag add if already assigned
-            $query = "INSERT IGNORE INTO video_tags(tag_id, video_id) VALUES ('$tagid','$movieid')";
-
-            if ($this->conn->query($query) === TRUE) {
-                $this->commitMessage('{"result":"success"}');
-            } else {
-                $this->commitMessage('{"result":"' . $this->conn->error . '"}');
-            }
-        });
-    }
-
-    private function getFromDB() {
-        /**
-         * returns all available tags from database
-         */
-        $this->addActionHandler("getAllTags", function () {
-            $query = "SELECT tag_name,tag_id from tags";
-            $result = $this->conn->query($query);
-
-            $rows = array();
-            while ($r = mysqli_fetch_assoc($result)) {
-                array_push($rows, $r);
-            }
-            $this->commitMessage(json_encode($rows));
-        });
-    }
-
-    private function delete() {
-        /**
-         * delete a Tag from a video
-         */
-        $this->addActionHandler("deleteVideoTag", function () {
-            $movieid = $_POST['video_id'];
-            $tagid = $_POST['tag_id'];
-
-            // skip tag add if already assigned
-            $query = "DELETE FROM video_tags WHERE tag_id=$tagid AND video_id=$movieid";
-
-            $this->commitMessage($this->conn->query($query) ? '{"result":"success"}' : '{"result":"' . $this->conn->error . '"}');
-        });
-    }
-}

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"
 )
@@ -16,76 +15,81 @@ const (
 	TagNode      = iota
 	SettingsNode = iota
 	ActorNode    = iota
-	TVShowNode   = iota
+	InitNode     = 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() {
-	http.Handle(APIPREFIX+"/video", oauth.ValidateToken(handlefunc, VideoNode))
+	http.Handle(APIPREFIX+"/video", oauth.ValidateToken(videoHandler))
-	http.Handle(APIPREFIX+"/tags", oauth.ValidateToken(handlefunc, TagNode))
+	http.Handle(APIPREFIX+"/tags", oauth.ValidateToken(tagHandler))
-	http.Handle(APIPREFIX+"/settings", oauth.ValidateToken(handlefunc, SettingsNode))
+	http.Handle(APIPREFIX+"/settings", oauth.ValidateToken(settingsHandler))
-	http.Handle(APIPREFIX+"/actor", oauth.ValidateToken(handlefunc, ActorNode))
+	http.Handle(APIPREFIX+"/actor", oauth.ValidateToken(actorHandler))
-	http.Handle(APIPREFIX+"/tvshow", oauth.ValidateToken(handlefunc, TVShowNode))
+
+	// initialization api calls to check if password is neccessaray
+	http.Handle(APIPREFIX+"/init", http.HandlerFunc(initHandler))
 
 	// initialize oauth service and add corresponding auth routes
 	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 actorHandler(rw http.ResponseWriter, req *http.Request) {
+	handlefunc(rw, req, ActorNode)
+}
+
+func videoHandler(rw http.ResponseWriter, req *http.Request) {
+	handlefunc(rw, req, VideoNode)
+}
+
+func tagHandler(rw http.ResponseWriter, req *http.Request) {
+	handlefunc(rw, req, TagNode)
+}
+
+func settingsHandler(rw http.ResponseWriter, req *http.Request) {
+	handlefunc(rw, req, SettingsNode)
+}
+
+func initHandler(rw http.ResponseWriter, req *http.Request) {
+	handlefunc(rw, req, InitNode)
+}
+
+func handlefunc(rw http.ResponseWriter, req *http.Request, node int) {
 	// only allow post requests
 	if req.Method != "POST" {
 		return
@@ -101,13 +105,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

@@ -5,7 +5,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"openmediacenter/apiGo/api/types"
-	"reflect"
 )
 
 // MovieId - MovieName : pay attention to the order!
@@ -62,22 +61,6 @@ func readActorsFromResultset(rows *sql.Rows) []types.Actor {
 	return result
 }
 
-// ID - Name : pay attention to the order!
-func readTVshowsFromResultset(rows *sql.Rows) []types.TVShow {
-	result := []types.TVShow{}
-	for rows.Next() {
-		var vid types.TVShow
-		err := rows.Scan(&vid.Id, &vid.Name)
-		if err != nil {
-			panic(err.Error()) // proper error handling instead of panic in your app
-		}
-		result = append(result, vid)
-	}
-	rows.Close()
-
-	return result
-}
-
 func jsonify(v interface{}) []byte {
 	// jsonify results
 	str, err := json.Marshal(v)
@@ -86,45 +69,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 fmt.Errorf("provided value %s type didn't match obj field type and isn't convertible", name)
-		}
-	} 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/Init.go

@@ -0,0 +1,39 @@
+package api
+
+import (
+	"encoding/json"
+	"openmediacenter/apiGo/database/settings"
+	"regexp"
+	"strings"
+)
+
+func AddInitHandlers() {
+	passwordNeeded()
+}
+
+func passwordNeeded() {
+	AddHandler("loadInitialData", InitNode, nil, func() []byte {
+		sett := settings.LoadSettings()
+
+		type InitialDataTypeResponse struct {
+			DarkMode        bool
+			Pasword         bool
+			MediacenterName string
+			VideoPath       string
+		}
+
+		regexMatchUrl := regexp.MustCompile("^http(|s):\\/\\/([0-9]){1,3}\\.([0-9]){1,3}\\.([0-9]){1,3}\\.([0-9]){1,3}:[0-9]{1,5}")
+		videoUrl := regexMatchUrl.FindString(sett.VideoPath)
+		serverVideoPath := strings.TrimPrefix(sett.VideoPath, videoUrl)
+
+		res := InitialDataTypeResponse{
+			DarkMode:        sett.DarkMode,
+			Pasword:         sett.Pasword != "-1",
+			MediacenterName: sett.Mediacenter_name,
+			VideoPath:       serverVideoPath,
+		}
+
+		str, _ := json.Marshal(res)
+		return str
+	})
+}

apiGo/api/Settings.go

@@ -1,14 +1,9 @@
 package api
 
 import (
-	"encoding/json"
-	"fmt"
 	"openmediacenter/apiGo/api/types"
 	"openmediacenter/apiGo/database"
-	"openmediacenter/apiGo/database/settings"
 	"openmediacenter/apiGo/videoparser"
-	"regexp"
-	"strings"
 )
 
 func AddSettingsHandlers() {
@@ -18,106 +13,17 @@ func AddSettingsHandlers() {
 }
 
 func getSettingsFromDB() {
-	/**
+	AddHandler("loadGeneralSettings", SettingsNode, nil, func() []byte {
-	 * @api {post} /api/settings [loadGeneralSettings]
+		result := database.GetSettings()
-	 * @apiDescription Get the settings object
+		return jsonify(result)
-	 * @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 {Object} Sizes Sizes object
-	 * @apiSuccess {uint32} Sizes.VideoNr total number of videos
-	 * @apiSuccess {float32} Sizes.DBSize total size of database
-	 * @apiSuccess {uint32} Sizes.DifferentTags number of different tags available
-	 * @apiSuccess {uint32} Sizes.TagsAdded number of different tags added to videos
-	 */
-	AddHandler("loadGeneralSettings", SettingsNode, func(info *HandlerInfo) []byte {
-		result, _, sizes := database.GetSettings()
-
-		var ret = struct {
-			Settings *types.SettingsType
-			Sizes    *types.SettingsSizeType
-		}{
-			Settings: &result,
-			Sizes:    &sizes,
-		}
-		return jsonify(ret)
-	})
-
-	/**
-	 * @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?
-	 * @apiSuccess {bool} TVShowEnabled is are TVShows enabled
-	 */
-	AddHandler("loadInitialData", SettingsNode, func(info *HandlerInfo) []byte {
-		sett := settings.LoadSettings()
-
-		type InitialDataTypeResponse struct {
-			DarkMode        bool
-			Pasword         bool
-			MediacenterName string
-			VideoPath       string
-			TVShowPath      string
-			TVShowEnabled   bool
-		}
-
-		regexMatchUrl := regexp.MustCompile("^http(|s)://([0-9]){1,3}\\.([0-9]){1,3}\\.([0-9]){1,3}\\.([0-9]){1,3}:[0-9]{1,5}")
-		videoUrl := regexMatchUrl.FindString(sett.VideoPath)
-		tvshowurl := regexMatchUrl.FindString(sett.TVShowPath)
-		serverVideoPath := strings.TrimPrefix(sett.VideoPath, videoUrl)
-		serverTVShowPath := strings.TrimPrefix(sett.TVShowPath, tvshowurl)
-
-		res := InitialDataTypeResponse{
-			DarkMode:        sett.DarkMode,
-			Pasword:         sett.Pasword != "-1",
-			MediacenterName: sett.MediacenterName,
-			VideoPath:       serverVideoPath,
-			TVShowPath:      serverTVShowPath,
-			TVShowEnabled:   settings.TVShowsEnabled(),
-		}
-
-		str, _ := json.Marshal(res)
-		return str
 	})
 }
 
 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 {string} VideoPath webserver path to the videos
-	 * @apiParam {string} EpisodePath webserver path to the tvshows
-	 * @apiParam {string} MediacenterName overall name of the mediacenter
-	 * @apiParam {string} Password new server password (-1 if no password set)
-	 * @apiParam {bool} TMDBGrabbing TMDB grabbing support to grab tag info and thumbnails
-	 * @apiParam {bool} DarkMode Darkmode enabled?
-	 *
-	 * @apiSuccess {string} result 'success' if successfully or error message if not
-	 */
-	AddHandler("saveGeneralSettings", SettingsNode, func(info *HandlerInfo) []byte {
-		var args types.SettingsType
-		if err := FillStruct(&args, info.Data); err != nil {
-			fmt.Println(err.Error())
-			return nil
-		}
-
 		query := `
 					UPDATE settings SET 
                         video_path=?,
@@ -128,47 +34,24 @@ func saveSettingsToDB() {
                         DarkMode=?
                     WHERE 1`
 		return database.SuccessQuery(query,
-			args.VideoPath, args.EpisodePath, args.Password,
+			sgs.Settings.VideoPath, sgs.Settings.EpisodePath, sgs.Settings.Password,
-			args.MediacenterName, args.TMDBGrabbing, args.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("cleanupGravity", 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)
-	})
-
-	/**
-	 * @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
 	})
+
+	AddHandler("getStatusMessage", SettingsNode, nil, func() []byte {
+		return jsonify(videoparser.GetStatusMessage())
+	})
 }

apiGo/api/TVShows.go

@@ -1,161 +0,0 @@
-package api
-
-import (
-	"fmt"
-	"openmediacenter/apiGo/database"
-	"openmediacenter/apiGo/database/settings"
-)
-
-func AddTvshowHandlers() {
-	// do not add handlers if tvshows not enabled
-	if !settings.TVShowsEnabled() {
-		return
-	}
-
-	/**
-	 * @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))
-	})
-
-	/**
-	 * @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)
-		rows := database.Query(query)
-
-		type Episode struct {
-			ID      uint32
-			Name    string
-			Season  uint8
-			Episode uint8
-		}
-
-		episodes := []Episode{}
-		for rows.Next() {
-			var ep Episode
-			err := rows.Scan(&ep.ID, &ep.Name, &ep.Season, &ep.Episode)
-			if err != nil {
-				fmt.Println(err.Error())
-				continue
-			}
-
-			episodes = append(episodes, ep)
-		}
-
-		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
-		}
-
-		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)
-		row := database.QueryRow(query)
-
-		var ret struct {
-			Name     string
-			Season   uint8
-			Episode  uint8
-			TVShowID uint32
-			Path     string
-		}
-		var filename string
-		var foldername string
-
-		err := row.Scan(&ret.Name, &ret.Season, &ret.TVShowID, &ret.Episode, &filename, &foldername)
-		if err != nil {
-			fmt.Println(err.Error())
-			return nil
-		}
-
-		ret.Path = foldername + "/" + filename
-
-		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 pic []byte
-
-		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", args.Id)
-			return nil
-		}
-
-		return pic
-	})
-}

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 {
@@ -53,9 +37,9 @@ func deleteFromDB() {
 			return database.ManualSuccessResponse(err)
 		} else {
 			// check with regex if its the key constraint error
-			r := regexp.MustCompile("^.*a foreign key constraint fails.*$")
+			r, _ := regexp.Compile("^.*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,163 +16,55 @@ 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=1] id of VideoTag to get videos (1=all)
-	 *
-	 * @apiSuccess {Object[]} Videos List of Videos
-	 * @apiSuccess {number} Videos.MovieId Id of Video
-	 * @apiSuccess {String} Videos.MovieName  Name of video
-	 * @apiSuccess {String} TagName Name of the Tag returned
-	 */
-	AddHandler("getMovies", VideoNode, func(info *HandlerInfo) []byte {
-		var args struct {
-			Tag  uint32
-			Sort uint8
-		}
-		if err := FillStruct(&args, info.Data); err != nil {
-			fmt.Println(err.Error())
-			return nil
-		}
-
-		const (
-			date   = iota
-			likes  = iota
-			random = iota
-			names  = iota
-			length = iota
-		)
-
-		// if wrong number passed no sorting is performed
-		var SortClause = ""
-		switch args.Sort {
-		case date:
-			SortClause = "ORDER BY create_date DESC, movie_name"
-			break
-		case likes:
-			SortClause = "ORDER BY likes DESC"
-			break
-		case random:
-			SortClause = "ORDER BY RAND()"
-			break
-		case names:
-			SortClause = "ORDER BY movie_name"
-			break
-		case length:
-			SortClause = "ORDER BY length DESC"
-			break
-		}
-
 		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,t.tag_name FROM videos
+			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 %s`, args.Tag, SortClause)
+					WHERE t.tag_id = '%d'
+					ORDER BY likes DESC, create_date, movie_name`, mrq.Tag)
 		} else {
-			query = fmt.Sprintf("SELECT movie_id,movie_name, (SELECT 'All' as tag_name) FROM videos %s", SortClause)
+			query = "SELECT movie_id,movie_name FROM videos ORDER BY create_date DESC, movie_name"
 		}
 
-		var result struct {
+		result := readVideosFromResultset(database.Query(query))
-			Videos  []types.VideoUnloadedType
-			TagName string
-		}
-
-		rows := database.Query(query)
-		vids := []types.VideoUnloadedType{}
-		var name string
-		for rows.Next() {
-			var vid types.VideoUnloadedType
-			err := rows.Scan(&vid.MovieId, &vid.MovieName, &name)
-			if err != nil {
-				return nil
-			}
-			vids = append(vids, vid)
-		}
-		if rows.Close() != nil {
-			return nil
-		}
-
-		// if the tag id doesn't exist the query won't return a name
-		if name == "" {
-			return nil
-		}
-
-		result.Videos = vids
-		result.TagName = name
 		// jsonify results
 		str, _ := json.Marshal(result)
 		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
@@ -207,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
@@ -241,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
@@ -289,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
 		}
@@ -309,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))
 
@@ -318,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))
 
@@ -334,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 := `
@@ -388,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
@@ -443,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 http.HandlerFunc) 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.ServeHTTP(w, r)
 	}
 }

apiGo/api/types/Types.go

@@ -7,12 +7,12 @@ type VideoUnloadedType struct {
 
 type FullVideoType struct {
 	MovieName    string
-	MovieId      uint32
+	MovieId      int
 	MovieUrl     string
 	Poster       string
-	Likes        uint64
+	Likes        int
-	Quality      uint16
+	Quality      int
-	Length       uint16
+	Length       int
 	Tags         []Tag
 	SuggestedTag []Tag
 	Actors       []Actor
@@ -20,22 +20,22 @@ type FullVideoType struct {
 
 type Tag struct {
 	TagName string
-	TagId   uint32
+	TagId   int
 }
 
 type Actor struct {
-	ActorId   uint32
+	ActorId   int
 	Name      string
 	Thumbnail string
 }
 
 type StartData struct {
-	VideoNr       uint32
+	VideoNr       int
-	FullHdNr      uint32
+	FullHdNr      int
-	HDNr          uint32
+	HDNr          int
-	SDNr          uint32
+	SDNr          int
-	DifferentTags uint32
+	DifferentTags int
-	Tagged        uint32
+	Tagged        int
 }
 
 type SettingsType struct {
@@ -46,16 +46,11 @@ type SettingsType struct {
 	PasswordEnabled bool
 	TMDBGrabbing    bool
 	DarkMode        bool
-}
 
-type SettingsSizeType struct {
+	VideoNr       int
-	VideoNr       uint32
 	DBSize        float32
-	DifferentTags uint32
+	DifferentTags int
-	TagsAdded     uint32
+	TagsAdded     int
-}
 
-type TVShow struct {
+	PathPrefix string
-	Id   uint32
-	Name string
 }

apiGo/database/Database.go

@@ -90,7 +90,9 @@ func Close() {
 	db.Close()
 }
 
-func GetSettings() (result types.SettingsType, PathPrefix string, sizes types.SettingsSizeType) {
+func GetSettings() types.SettingsType {
+	var result types.SettingsType
+
 	// query settings and infotile values
 	query := fmt.Sprintf(`
                 SELECT (
@@ -118,7 +120,7 @@ func GetSettings() (result types.SettingsType, PathPrefix string, sizes types.Se
 	var DarkMode int
 	var TMDBGrabbing int
 
-	err := QueryRow(query).Scan(&sizes.VideoNr, &sizes.DBSize, &sizes.DifferentTags, &sizes.TagsAdded,
+	err := QueryRow(query).Scan(&result.VideoNr, &result.DBSize, &result.DifferentTags, &result.TagsAdded,
 		&result.VideoPath, &result.EpisodePath, &result.Password, &result.MediacenterName, &TMDBGrabbing, &DarkMode)
 
 	if err != nil {
@@ -128,6 +130,7 @@ func GetSettings() (result types.SettingsType, PathPrefix string, sizes types.Se
 	result.TMDBGrabbing = TMDBGrabbing != 0
 	result.PasswordEnabled = result.Password != "-1"
 	result.DarkMode = DarkMode != 0
-	PathPrefix = SettingsVideoPrefix
+	result.PathPrefix = SettingsVideoPrefix
-	return
+
+	return result
 }

apiGo/database/settings/DBSettings.go

@@ -15,24 +15,35 @@ func GetPassword() *string {
 }
 
 type SettingsType struct {
-	DarkMode        bool
+	DarkMode         bool
-	Pasword         string
+	Pasword          string
-	MediacenterName string
+	Mediacenter_name string
-	VideoPath       string
+	VideoPath        string
-	TVShowPath      string
 }
 
 func LoadSettings() *SettingsType {
-	query := "SELECT DarkMode, password, mediacenter_name, video_path, episode_path from settings"
+	query := "SELECT DarkMode, password, mediacenter_name, video_path from settings"
 
-	result := SettingsType{}
+	type RawSettingsType struct {
-	var darkmode uint8
+		DarkMode         int
+		Pasword          string
+		Mediacenter_name string
+		VideoPath        string
+	}
 
-	err := database.QueryRow(query).Scan(&darkmode, &result.Pasword, &result.MediacenterName, &result.VideoPath, &result.TVShowPath)
+	result := RawSettingsType{}
+
+	err := database.QueryRow(query).Scan(&result.DarkMode, &result.Pasword, &result.Mediacenter_name, &result.VideoPath)
 	if err != nil {
 		fmt.Println("error while parsing db data: " + err.Error())
 	}
 
-	result.DarkMode = darkmode != 0
+	res := SettingsType{
-	return &result
+		DarkMode:         result.DarkMode != 0,
+		Pasword:          result.Pasword,
+		Mediacenter_name: result.Mediacenter_name,
+		VideoPath:        result.VideoPath,
+	}
+
+	return &res
 }

apiGo/database/settings/Settings.go

@@ -1,11 +0,0 @@
-package settings
-
-var tvShowEnabled bool
-
-func TVShowsEnabled() bool {
-	return tvShowEnabled
-}
-
-func SetTVShowEnabled(enabled bool) {
-	tvShowEnabled = enabled
-}

apiGo/go.mod

@@ -5,5 +5,4 @@ go 1.16
 require (
 	github.com/go-sql-driver/mysql v1.5.0
 	gopkg.in/oauth2.v3 v3.12.0
-	nhooyr.io/websocket v1.8.7
 )

apiGo/go.sum

@@ -1,58 +1,54 @@
 cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+github.com/ajg/form v1.5.1 h1:t9c7v8JUKu/XxOGBU0yjNpaMloxGEJhUkqFRq0ibGeU=
 github.com/ajg/form v1.5.1/go.mod h1:uL1WgH+h2mgNtvBq0339dVnzXdBETtL2LeUXaIv25UY=
+github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/dgrijalva/jwt-go v3.2.0+incompatible h1:7qlOGliEKZXTDg6OTjfoBKDXWrumCAMpl/TFQ4/5kLM=
 github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
 github.com/fasthttp-contrib/websocket v0.0.0-20160511215533-1f3b11f56072/go.mod h1:duJ4Jxv5lDcvg4QuQr0oowTf7dz4/CR8NtyCooz9HL8=
+github.com/fatih/structs v1.1.0 h1:Q7juDM0QtcnhCpeyLGQKyg4TOIghuNXrkL32pHAUMxo=
 github.com/fatih/structs v1.1.0/go.mod h1:9NiDSp5zOcgEDl+j00MP/WkGVPOlPRLejGD8Ga6PJ7M=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/gavv/httpexpect v2.0.0+incompatible h1:1X9kcRshkSKEjNJJxX9Y9mQ5BRfbxU5kORdjhlA1yX8=
 github.com/gavv/httpexpect v2.0.0+incompatible/go.mod h1:x+9tiU1YnrOvnB725RkpoLv1M62hOWzwo5OXotisrKc=
-github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
-github.com/gin-gonic/gin v1.6.3/go.mod h1:75u5sXoLsGZoRN5Sgbi1eraJ4GU3++wFwWzhwvtwp4M=
-github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
-github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8=
-github.com/go-playground/universal-translator v0.17.0/go.mod h1:UkSxE5sNxxRwHyU+Scu5vgOQjsIJAF8j9muTVoKLVtA=
-github.com/go-playground/validator/v10 v10.2.0/go.mod h1:uOYAAleCW8F/7oMFd6aG0GOhaH6EGOAJShg8Id5JGkI=
 github.com/go-session/session v3.1.2+incompatible/go.mod h1:8B3iivBQjrz/JtC68Np2T1yBBLxTan3mn/3OM0CyRt0=
 github.com/go-sql-driver/mysql v1.5.0 h1:ozyZYNQW3x3HtqT1jira07DN2PArx2v7/mN66gGcHOs=
 github.com/go-sql-driver/mysql v1.5.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
-github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee/go.mod h1:L0fX3K22YWvt/FAX9NnzrNzcI4wNYi9Yku4O0LKYflo=
-github.com/gobwas/pool v0.2.0/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
-github.com/gobwas/ws v1.0.2/go.mod h1:szmBTxLgaFppYjEmNtny/v3w89xOydFnnZMcgRRu/EM=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
+github.com/google/go-querystring v1.0.0 h1:Xkwi/a1rcvNg1PPYe5vI8GbeBY/jrVuDX5ASuANWTrk=
-github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk=
-github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-querystring v1.0.0/go.mod h1:odCYkC5MyYFN7vkCjXpyrEuKhc/BUO6wN/zVPAxq5ck=
-github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1 h1:EGx4pi6eqNxGaHF6qqu48+N2wcFQ5qg5FXgOdqsJ5d8=
 github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
+github.com/gorilla/websocket v1.4.1 h1:q7AeDBpnBk8AogcD4DSag/Ukw/KV+YhzLj2bP5HvKCM=
 github.com/gorilla/websocket v1.4.1/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
+github.com/imkira/go-interpol v1.1.0 h1:KIiKr0VSG2CUW1hl1jpiyuzuJeKUUpC8iM1AIE7N1Vk=
 github.com/imkira/go-interpol v1.1.0/go.mod h1:z0h2/2T3XF8kyEPpRgJ3kmNv+C43p+I/CoI+jC3w2iA=
-github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo=
 github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
 github.com/k0kubun/colorstring v0.0.0-20150214042306-9440f1994b88/go.mod h1:3w7q1U84EfirKl04SVQ/s7nPm1ZPhiXd34z40TNz36k=
+github.com/klauspost/compress v1.8.2 h1:Bx0qjetmNjdFXASH02NSAREKpiaDwkO1DRZ3dV2KCcs=
 github.com/klauspost/compress v1.8.2/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A=
-github.com/klauspost/compress v1.10.3 h1:OP96hzwJVBIHYU52pVTI6CczrxPvrGfgqF9N5eTO0Q8=
+github.com/klauspost/cpuid v1.2.1 h1:vJi+O/nMdFt0vqm8NZBI6wzALWdA2X+egi0ogNyrC/w=
-github.com/klauspost/compress v1.10.3/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
 github.com/klauspost/cpuid v1.2.1/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek=
-github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII=
 github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
 github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
-github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
+github.com/moul/http2curl v1.0.0 h1:dRMWoAtb+ePxMlLkrCbAqh4TlPHXvoGUSQ323/9Zahs=
-github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
-github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/moul/http2curl v1.0.0/go.mod h1:8UbvGypXm98wA/IqH45anm5Y2Z6ep6O31QGOAZ3H0fQ=
 github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 github.com/onsi/ginkgo v1.10.2/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 github.com/onsi/gomega v1.7.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/sergi/go-diff v1.0.0 h1:Kpca3qRNrduNnOQeazBd0ysaKrUJiIuISHxogkT9RPQ=
 github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
+github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d h1:zE9ykElWQ6/NYmHa3jpm/yHnI4xSofP+UP6SpjHcSeM=
 github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
+github.com/smartystreets/goconvey v1.6.4 h1:fv0U8FUIMPNf1L9lnHLvLhgicrIVChEkdzIKYqbNC9s=
 github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/tidwall/btree v0.0.0-20170113224114-9876f1454cf0 h1:QnyrPZZvPmR0AtJCxxfCtI1qN+fYpKTKJ/5opWmZ34k=
 github.com/tidwall/btree v0.0.0-20170113224114-9876f1454cf0/go.mod h1:huei1BkDWJ3/sLXmO+bsCNELL+Bp2Kks9OLyQFkzvA8=
@@ -70,16 +66,22 @@ github.com/tidwall/rtree v0.0.0-20180113144539-6cd427091e0e h1:+NL1GDIUOKxVfbp2K
 github.com/tidwall/rtree v0.0.0-20180113144539-6cd427091e0e/go.mod h1:/h+UnNGt0IhNNJLkGikcdcJqm66zGD/uJGMRxK/9+Ao=
 github.com/tidwall/tinyqueue v0.0.0-20180302190814-1e39f5511563 h1:Otn9S136ELckZ3KKDyCkxapfufrqDqwmGjcHfAyXRrE=
 github.com/tidwall/tinyqueue v0.0.0-20180302190814-1e39f5511563/go.mod h1:mLqSmt7Dv/CNneF2wfcChfN1rvapyQr01LGKnKex0DQ=
-github.com/ugorji/go v1.1.7/go.mod h1:kZn38zHttfInRq0xu/PH0az30d+z6vm202qpg1oXVMw=
+github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
-github.com/ugorji/go/codec v1.1.7/go.mod h1:Ax+UKWsSmolVDwsd+7N3ZtXu+yMGCf907BLYF3GoBXY=
 github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
+github.com/valyala/fasthttp v1.6.0 h1:uWF8lgKmeaIewWVPwi4GRq2P6+R46IgYZdxWtM+GtEY=
 github.com/valyala/fasthttp v1.6.0/go.mod h1:FstJa9V+Pj9vQ7OJie2qMHdwemEDaDiSdBnvPM1Su9w=
 github.com/valyala/tcplisten v0.0.0-20161114210144-ceec8f93295a/go.mod h1:v3UYOV9WzVtRmSR+PDvWpU/qWl4Wa5LApYYX4ZtKbio=
+github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f h1:J9EGpcZtP0E/raorCMxlFGSTBrsSlaDGf3jU/qvAE2c=
 github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU=
+github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 h1:EzJWgHovont7NscjpAxXsDA8S8BMYve8Y5+7cuRE7R0=
 github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415/go.mod h1:GwrjFmJcFw6At/Gs6z4yjiIwzuJ1/+UwLxMQDVQXShQ=
+github.com/xeipuuv/gojsonschema v1.2.0 h1:LhYJRs+L4fBtjZUfuSZIKGeVu0QRy8e5Xi7D17UxZ74=
 github.com/xeipuuv/gojsonschema v1.2.0/go.mod h1:anYRn/JVcOK2ZgGU+IjEV4nwlhoK5sQluxsYJ78Id3Y=
+github.com/yalp/jsonpath v0.0.0-20180802001716-5cc68e5049a0 h1:6fRhSjgLCkTD3JnJxvaJ4Sj+TYblw757bqYgZaOq5ZY=
 github.com/yalp/jsonpath v0.0.0-20180802001716-5cc68e5049a0/go.mod h1:/LWChgwKmvncFJFHJ7Gvn9wZArjbV5/FppcK2fKk/tI=
+github.com/yudai/gojsondiff v1.0.0 h1:27cbfqXLVEJ1o8I6v3y9lg8Ydm53EKqHXAOMxEGlCOA=
 github.com/yudai/gojsondiff v1.0.0/go.mod h1:AY32+k2cwILAkW1fbgxQ5mUmMiZFgLIV+FBNExI05xg=
+github.com/yudai/golcs v0.0.0-20170316035057-ecda9a501e82 h1:BHyfKlQyqbsFN5p3IfnEUduWvb9is428/nNb5L3U01M=
 github.com/yudai/golcs v0.0.0-20170316035057-ecda9a501e82/go.mod h1:lgjkn3NuSvDfVJdfcVVdX+jpBxNmX4rDAzaS45IcYoM=
 github.com/yudai/pp v2.0.1+incompatible/go.mod h1:PuxR/8QJ7cyCkFp/aUDS+JY727OFEZkTdatxwunjIkc=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
@@ -87,6 +89,7 @@ golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73r
 golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190827160401-ba9fcec4b297 h1:k7pJ2yAPLPgbskkFdhRCsA77k2fySZ1zf2zCjvQCiIM=
 golang.org/x/net v0.0.0-20190827160401-ba9fcec4b297/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -94,13 +97,8 @@ golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJ
 golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
-golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
@@ -108,7 +106,5 @@ gopkg.in/oauth2.v3 v3.12.0 h1:yOffAPoolH/i2JxwmC+pgtnY3362iPahsDpLXfDFvNg=
 gopkg.in/oauth2.v3 v3.12.0/go.mod h1:XEYgKqWX095YiPT+Aw5y3tCn+7/FMnlTFKrupgSiJ3I=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
 gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-nhooyr.io/websocket v1.8.7 h1:usjR2uOr/zjjkVMy0lW+PPohFok7PCow5sDjLgX4P4g=
-nhooyr.io/websocket v1.8.7/go.mod h1:B70DZP8IakI65RVQ51MsWP/8jndNma26DVA/nFSCgW0=

apiGo/main.go

@@ -7,9 +7,7 @@ import (
 	"net/http"
 	"openmediacenter/apiGo/api"
 	"openmediacenter/apiGo/database"
-	settings2 "openmediacenter/apiGo/database/settings"
 	"openmediacenter/apiGo/static"
-	"openmediacenter/apiGo/videoparser"
 )
 
 func main() {
@@ -32,9 +30,7 @@ func main() {
 	api.AddSettingsHandlers()
 	api.AddTagHandlers()
 	api.AddActorsHandlers()
-	api.AddTvshowHandlers()
+	api.AddInitHandlers()
-
-	videoparser.SetupSettingsWebsocket()
 
 	// add the static files
 	static.ServeStaticFiles()
@@ -56,12 +52,8 @@ func handleCommandLineArguments() (*database.DatabaseConfig, bool, *string) {
 
 	pathPrefix := flag.String("ReindexPrefix", "/var/www/openmediacenter", "Prefix path for videos to reindex")
 
-	disableTVShowSupport := flag.Bool("DisableTVSupport", false, "Disable the TVShow support and pages")
-
 	flag.Parse()
 
-	settings2.SetTVShowEnabled(!*disableTVShowSupport)
-
 	return &database.DatabaseConfig{
 		DBHost:     *dbhostPtr,
 		DBPort:     *dbPortPtr,

apiGo/videoparser/Helpers.go

@@ -1,120 +0,0 @@
-package videoparser
-
-import (
-	"encoding/base64"
-	"encoding/json"
-	"fmt"
-	"os/exec"
-	"strconv"
-)
-
-func AppendMessage(message string) {
-	msger := TextMessage{
-		MessageBase: MessageBase{Action: "message"},
-		Message:     message,
-	}
-	marshal, err := json.Marshal(msger)
-	if err != nil {
-		return
-	}
-
-	IndexSender.Publish(marshal)
-}
-
-func SendEvent(message string) {
-	msger := ReindexEvent{
-		MessageBase: MessageBase{Action: "reindexAction"},
-		Event:       message,
-	}
-	marshal, err := json.Marshal(msger)
-	if err != nil {
-		return
-	}
-
-	IndexSender.Publish(marshal)
-}
-
-// ext dependency support check
-func checkExtDependencySupport() *ExtDependencySupport {
-	var extDepsAvailable ExtDependencySupport
-
-	extDepsAvailable.FFMpeg = commandExists("ffmpeg")
-	extDepsAvailable.MediaInfo = commandExists("mediainfo")
-
-	return &extDepsAvailable
-}
-
-// check if a specific system command is available
-func commandExists(cmd string) bool {
-	_, err := exec.LookPath(cmd)
-	return err == nil
-}
-
-// parse the thumbail picture from video file
-func parseFFmpegPic(path string) (*string, error) {
-	app := "ffmpeg"
-
-	cmd := exec.Command(app,
-		"-hide_banner",
-		"-loglevel", "panic",
-		"-ss", "00:04:00",
-		"-i", path,
-		"-vframes", "1",
-		"-q:v", "2",
-		"-f", "singlejpeg",
-		"pipe:1")
-
-	stdout, err := cmd.Output()
-
-	if err != nil {
-		fmt.Println(err.Error())
-		fmt.Println(string(err.(*exec.ExitError).Stderr))
-		return nil, err
-	}
-
-	strEncPic := base64.StdEncoding.EncodeToString(stdout)
-	if strEncPic == "" {
-		return nil, nil
-	}
-	backpic64 := fmt.Sprintf("data:image/jpeg;base64,%s", strEncPic)
-
-	return &backpic64, nil
-}
-
-func getVideoAttributes(path string) *VideoAttributes {
-	app := "mediainfo"
-
-	arg0 := path
-	arg1 := "--Output=JSON"
-
-	cmd := exec.Command(app, arg1, "-f", arg0)
-	stdout, err := cmd.Output()
-
-	var t struct {
-		Media struct {
-			Track []struct {
-				Duration string
-				FileSize string
-				Width    string
-			}
-		}
-	}
-	err = json.Unmarshal(stdout, &t)
-
-	if err != nil {
-		fmt.Println(err.Error())
-		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)
-
-	ret := VideoAttributes{
-		Duration: float32(duration),
-		FileSize: uint(filesize),
-		Width:    uint(width),
-	}
-
-	return &ret
-}

apiGo/videoparser/ReIndex.go

@@ -2,10 +2,13 @@ package videoparser
 
 import (
 	"database/sql"
+	"encoding/base64"
+	"encoding/json"
 	"fmt"
 	"openmediacenter/apiGo/api/types"
 	"openmediacenter/apiGo/database"
 	"openmediacenter/apiGo/videoparser/tmdb"
+	"os/exec"
 	"regexp"
 	"strconv"
 	"strings"
@@ -48,8 +51,9 @@ func ReIndexVideos(path []string, sett types.SettingsType) {
 		processVideo(s)
 	}
 
-	AppendMessage("reindex finished successfully!")
+	AppendMessageBuffer("reindex finished successfully!")
-	SendEvent("stop")
+
+	contentAvailable = false
 	fmt.Println("Reindexing finished!")
 }
 
@@ -96,7 +100,7 @@ func processVideo(fileNameOrig string) {
 	fmt.Printf("Processing %s video-", fileNameOrig)
 
 	// match the file extension
-	r := regexp.MustCompile(`\.[a-zA-Z0-9]+$`)
+	r, _ := regexp.Compile(`\.[a-zA-Z0-9]+$`)
 	fileName := r.ReplaceAllString(fileNameOrig, "")
 
 	// match the year and cut year from name
@@ -121,7 +125,7 @@ func addVideo(videoName string, fileName string, year int) {
 	}
 
 	if mExtDepsAvailable.FFMpeg {
-		ppic, err = parseFFmpegPic(mSettings.VideoPath + fileName)
+		ppic, err = parseFFmpegPic(fileName)
 		if err != nil {
 			fmt.Printf("FFmpeg error occured: %s\n", err.Error())
 		} else {
@@ -130,7 +134,7 @@ func addVideo(videoName string, fileName string, year int) {
 	}
 
 	if mExtDepsAvailable.MediaInfo {
-		atr := getVideoAttributes(mSettings.VideoPath + fileName)
+		atr := getVideoAttributes(fileName)
 		if atr != nil {
 			vidAtr = atr
 		}
@@ -164,11 +168,11 @@ func addVideo(videoName string, fileName string, year int) {
 		insertTMDBTags(tmdbData.GenreIds, insertId)
 	}
 
-	AppendMessage(fmt.Sprintf("%s - added!", videoName))
+	AppendMessageBuffer(fmt.Sprintf("%s - added!", videoName))
 }
 
 func matchYear(fileName string) (int, string) {
-	r := regexp.MustCompile(`\([0-9]{4}?\)`)
+	r, _ := regexp.Compile(`\([0-9]{4}?\)`)
 	years := r.FindAllString(fileName, -1)
 	if len(years) == 0 {
 		return -1, fileName
@@ -185,6 +189,95 @@ func matchYear(fileName string) (int, string) {
 	return year, r.ReplaceAllString(fileName, "")
 }
 
+// parse the thumbail picture from video file
+func parseFFmpegPic(fileName string) (*string, error) {
+	app := "ffmpeg"
+
+	cmd := exec.Command(app,
+		"-hide_banner",
+		"-loglevel", "panic",
+		"-ss", "00:04:00",
+		"-i", mSettings.VideoPath+fileName,
+		"-vframes", "1",
+		"-q:v", "2",
+		"-f", "singlejpeg",
+		"pipe:1")
+
+	stdout, err := cmd.Output()
+
+	if err != nil {
+		fmt.Println(err.Error())
+		fmt.Println(string(err.(*exec.ExitError).Stderr))
+		return nil, err
+	}
+
+	strEncPic := base64.StdEncoding.EncodeToString(stdout)
+	if strEncPic == "" {
+		return nil, nil
+	}
+	backpic64 := fmt.Sprintf("data:image/jpeg;base64,%s", strEncPic)
+
+	return &backpic64, nil
+}
+
+func getVideoAttributes(fileName string) *VideoAttributes {
+	app := "mediainfo"
+
+	arg0 := mSettings.VideoPath + fileName
+	arg1 := "--Output=JSON"
+
+	cmd := exec.Command(app, arg1, "-f", arg0)
+	stdout, err := cmd.Output()
+
+	var t struct {
+		Media struct {
+			Track []struct {
+				Duration string
+				FileSize string
+				Width    string
+			}
+		}
+	}
+	err = json.Unmarshal(stdout, &t)
+
+	if err != nil {
+		fmt.Println(err.Error())
+		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)
+
+	ret := VideoAttributes{
+		Duration: float32(duration),
+		FileSize: uint(filesize),
+		Width:    uint(width),
+	}
+
+	return &ret
+}
+
+func AppendMessageBuffer(message string) {
+	messageBuffer = append(messageBuffer, message)
+}
+
+// ext dependency support check
+func checkExtDependencySupport() *ExtDependencySupport {
+	var extDepsAvailable ExtDependencySupport
+
+	extDepsAvailable.FFMpeg = commandExists("ffmpeg")
+	extDepsAvailable.MediaInfo = commandExists("mediainfo")
+
+	return &extDepsAvailable
+}
+
+// check if a specific system command is available
+func commandExists(cmd string) bool {
+	_, err := exec.LookPath(cmd)
+	return err == nil
+}
+
 // insert the default size tags to corresponding video
 func insertSizeTag(width uint, videoId uint) {
 	var tagType uint

apiGo/videoparser/ReIndexTVShows.go

@@ -1,138 +0,0 @@
-package videoparser
-
-import (
-	"fmt"
-	"openmediacenter/apiGo/database"
-	"openmediacenter/apiGo/videoparser/tmdb"
-	"regexp"
-	"strconv"
-	"strings"
-)
-
-func startTVShowReindex(files []Show) {
-	allTVshows := getAllTVShows()
-
-	for _, file := range files {
-		// insert new TVShow entry if not existing.
-		insertShowIfNotExisting(file, allTVshows)
-		AppendMessage("Processing show: " + file.Name)
-
-		insertEpisodesIfNotExisting(file)
-	}
-
-	AppendMessage("reindex finished successfully!")
-	SendEvent("stop")
-}
-
-func insertEpisodesIfNotExisting(show Show) {
-	query := "SELECT tvshow_episodes.name, season, episode FROM tvshow_episodes JOIN tvshow t on t.id = tvshow_episodes.tvshow_id WHERE t.name=?"
-	rows := database.Query(query, show.Name)
-
-	var dbepisodes []string
-	for rows.Next() {
-		var epname string
-		var season int
-		var episode int
-		err := rows.Scan(&epname, &season, &episode)
-		if err != nil {
-			fmt.Println(err.Error())
-		}
-
-		dbepisodes = append(dbepisodes, fmt.Sprintf("%s S%02dE%02d.mp4", epname, season, episode))
-	}
-
-	// get those episodes that are missing in db
-	diff := difference(show.files, dbepisodes)
-
-	for _, s := range diff {
-		AppendMessage("Adding Episode: " + s)
-		insertEpisode(s, show.Name)
-	}
-}
-
-func insertEpisode(path string, ShowName string) {
-	seasonRegex := regexp.MustCompile("S[0-9][0-9]")
-	episodeRegex := regexp.MustCompile("E[0-9][0-9]")
-	matchENDPattern := regexp.MustCompile(" S[0-9][0-9]E[0-9][0-9].+$")
-
-	seasonStr := seasonRegex.FindString(path)
-	episodeStr := episodeRegex.FindString(path)
-	extString := matchENDPattern.FindString(path)
-	// handle invalid matches
-	if len(seasonStr) != 3 || len(episodeStr) != 3 || len(extString) < 8 {
-		fmt.Printf("Error inserting episode: %s  -- %s/%s/%s\n", path, seasonStr, episodeStr, extString)
-		return
-	}
-
-	name := strings.TrimSuffix(path, extString)
-
-	season, err := strconv.ParseInt(seasonStr[1:], 10, 8)
-	episode, err := strconv.ParseInt(episodeStr[1:], 10, 8)
-	if err != nil {
-		fmt.Println(err.Error())
-	}
-
-	query := `
-INSERT INTO tvshow_episodes (name, season, poster, tvshow_id, episode, filename)
-VALUES (?, ?, ?, (SELECT tvshow.id FROM tvshow WHERE tvshow.name=?), ?, ?)`
-	err = database.Edit(query, name, season, "", ShowName, episode, path)
-	if err != nil {
-		fmt.Println(err.Error())
-	}
-}
-
-// difference returns the elements in `a` that aren't in `b`.
-func difference(a, b []string) []string {
-	mb := make(map[string]struct{}, len(b))
-	for _, x := range b {
-		mb[x] = struct{}{}
-	}
-	var diff []string
-	for _, x := range a {
-		if _, found := mb[x]; !found {
-			diff = append(diff, x)
-		}
-	}
-	return diff
-}
-
-func insertShowIfNotExisting(show Show, allShows *[]string) {
-	// if show already exists return
-	fmt.Println(*allShows)
-	for _, s := range *allShows {
-		if s == show.Name {
-			return
-		}
-	}
-
-	// insert empty thubnail if tmdb fails
-	thubnail := ""
-
-	// load tmdb infos
-	tmdbInfo := tmdb.SearchTVShow(show.Name)
-	if tmdbInfo != nil {
-		thubnail = tmdbInfo.Thumbnail
-	}
-
-	// currently the foldernamme == name which mustn't necessarily be
-	query := "INSERT INTO tvshow (name, thumbnail, foldername) VALUES (?, ?, ?)"
-	err := database.Edit(query, show.Name, thubnail, show.Name)
-	if err != nil {
-		fmt.Println(err.Error())
-	}
-}
-
-func getAllTVShows() *[]string {
-	query := "SELECT name FROM tvshow"
-	rows := database.Query(query)
-
-	var res []string
-	for rows.Next() {
-		var show string
-		rows.Scan(&show)
-
-		res = append(res, show)
-	}
-
-	return &res
-}

apiGo/videoparser/ReIndexTVShows_test.go

@@ -1,13 +0,0 @@
-package videoparser
-
-import "testing"
-
-func TestDifference(t *testing.T) {
-	arr1 := []string{"test1", "test2", "test3"}
-	arr2 := []string{"test1", "test3"}
-
-	res := difference(arr1, arr2)
-	if len(res) != 1 || res[0] != "test2" {
-		t.Errorf("wrong difference result.")
-	}
-}

apiGo/videoparser/VideoParser.go

@@ -2,32 +2,33 @@ package videoparser
 
 import (
 	"fmt"
-	"io/ioutil"
 	"openmediacenter/apiGo/database"
 	"os"
 	"path/filepath"
 	"strings"
 )
 
+var messageBuffer []string
+var contentAvailable = false
+
 type StatusMessage struct {
 	Messages         []string
 	ContentAvailable bool
 }
 
 func StartReindex() bool {
-	fmt.Println("starting reindex..")
+	messageBuffer = []string{}
-	SendEvent("start")
+	contentAvailable = true
-	AppendMessage("starting reindex..")
 
-	mSettings, PathPrefix, _ := database.GetSettings()
+	fmt.Println("starting reindex..")
+
+	mSettings := database.GetSettings()
 	// add the path prefix to videopath
-	mSettings.VideoPath = PathPrefix + mSettings.VideoPath
+	mSettings.VideoPath = mSettings.PathPrefix + mSettings.VideoPath
 
 	// check if path even exists
 	if _, err := os.Stat(mSettings.VideoPath); os.IsNotExist(err) {
 		fmt.Println("Reindex path doesn't exist!")
-		AppendMessage(fmt.Sprintf("Reindex path doesn't exist! :%s", mSettings.VideoPath))
-		SendEvent("stop")
 		return false
 	}
 
@@ -48,77 +49,20 @@ func StartReindex() bool {
 		fmt.Println(err.Error())
 	}
 	// start reindex process
-	AppendMessage("Starting Reindexing!")
+	AppendMessageBuffer("Starting Reindexing!")
 	go ReIndexVideos(files, mSettings)
 	return true
 }
 
-type Show struct {
+func GetStatusMessage() *StatusMessage {
-	Name  string
+	msg := StatusMessage{
-	files []string
+		Messages:         messageBuffer,
-}
+		ContentAvailable: contentAvailable,
-
-// StartTVShowReindex reindex dir walks for TVShow reindex
-func StartTVShowReindex() {
-	fmt.Println("starting tvshow reindex..")
-	SendEvent("start")
-	AppendMessage("starting tvshow reindex...")
-
-	mSettings, PathPrefix, _ := database.GetSettings()
-	// add the path prefix to videopath
-	mSettings.EpisodePath = PathPrefix + mSettings.EpisodePath
-
-	// add slash suffix if not existing
-	if !strings.HasSuffix(mSettings.EpisodePath, "/") {
-		mSettings.EpisodePath += "/"
 	}
 
-	// check if path even exists
+	messageBuffer = []string{}
-	if _, err := os.Stat(mSettings.EpisodePath); os.IsNotExist(err) {
-		msg := fmt.Sprintf("Reindex path doesn't exist! :%s", mSettings.EpisodePath)
-		fmt.Println(msg)
-		AppendMessage(msg)
-		SendEvent("stop")
-		return
-	}
 
-	var files []Show
+	return &msg
-
-	filess, err := ioutil.ReadDir(mSettings.EpisodePath)
-	if err != nil {
-		fmt.Println(err.Error())
-	}
-
-	for _, file := range filess {
-		if file.IsDir() {
-			elem := Show{
-				Name:  file.Name(),
-				files: nil,
-			}
-
-			fmt.Println(file.Name())
-
-			episodefiles, err := ioutil.ReadDir(mSettings.EpisodePath + file.Name())
-			if err != nil {
-				fmt.Println(err.Error())
-			}
-
-			for _, epfile := range episodefiles {
-				if strings.HasSuffix(epfile.Name(), ".mp4") {
-					elem.files = append(elem.files, epfile.Name())
-				}
-			}
-			files = append(files, elem)
-		}
-	}
-
-	if err != nil {
-		fmt.Println(err.Error())
-	}
-
-	// start reindex process
-	AppendMessage("Starting Reindexing!")
-	go startTVShowReindex(files)
 }
 
 func StartCleanup() {

apiGo/videoparser/WebSocketConnector.go

@@ -1,135 +0,0 @@
-package videoparser
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"net/http"
-	"nhooyr.io/websocket"
-	"sync"
-	"time"
-)
-
-// subscriber represents a subscriber.
-// Messages are sent on the msgs channel and if the client
-// cannot keep up with the messages, closeSlow is called.
-type subscriber struct {
-	msgs      chan []byte
-	closeSlow func()
-}
-
-type ChatSender struct {
-	subscribersMu sync.Mutex
-	subscribers   map[*subscriber]struct{}
-}
-
-func newChatSender() *ChatSender {
-	return &ChatSender{
-		subscribers: make(map[*subscriber]struct{}),
-	}
-}
-
-func (t *ChatSender) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	c, err := websocket.Accept(w, r, &websocket.AcceptOptions{
-		OriginPatterns: []string{"*"},
-	})
-	if err != nil {
-		fmt.Println(err.Error())
-		return
-	}
-	defer c.Close(websocket.StatusInternalError, "")
-
-	err = t.subscribe(r.Context(), c)
-	if errors.Is(err, context.Canceled) {
-		return
-	}
-	if websocket.CloseStatus(err) == websocket.StatusNormalClosure ||
-		websocket.CloseStatus(err) == websocket.StatusGoingAway {
-		return
-	}
-	if err != nil {
-		fmt.Println(err.Error())
-		return
-	}
-}
-
-func (t *ChatSender) subscribe(ctx context.Context, c *websocket.Conn) error {
-	ctx = c.CloseRead(ctx)
-
-	s := &subscriber{
-		msgs: make(chan []byte, 16),
-		closeSlow: func() {
-			c.Close(websocket.StatusPolicyViolation, "connection too slow to keep up with messages")
-		},
-	}
-	t.addSubscriber(s)
-	defer t.deleteSubscriber(s)
-
-	for {
-		select {
-		case msg := <-s.msgs:
-			err := writeTimeout(ctx, time.Second*5, c, msg)
-			if err != nil {
-				return err
-			}
-		case <-ctx.Done():
-			return ctx.Err()
-		}
-	}
-}
-
-type MessageBase struct {
-	Action string
-}
-
-type TextMessage struct {
-	MessageBase
-
-	Message string
-}
-
-type ReindexEvent struct {
-	MessageBase
-
-	Event string
-}
-
-func (t *ChatSender) Publish(msg []byte) {
-	t.subscribersMu.Lock()
-	defer t.subscribersMu.Unlock()
-
-	for s := range t.subscribers {
-		select {
-		case s.msgs <- msg:
-		default:
-			go s.closeSlow()
-		}
-	}
-}
-
-var IndexSender = newChatSender()
-
-func SetupSettingsWebsocket() {
-	http.Handle("/subscribe", IndexSender)
-}
-
-// addSubscriber registers a subscriber.
-func (t *ChatSender) addSubscriber(s *subscriber) {
-	t.subscribersMu.Lock()
-	t.subscribers[s] = struct{}{}
-	t.subscribersMu.Unlock()
-}
-
-// deleteSubscriber deletes the given subscriber.
-func (t *ChatSender) deleteSubscriber(s *subscriber) {
-	t.subscribersMu.Lock()
-	delete(t.subscribers, s)
-	t.subscribersMu.Unlock()
-}
-
-func writeTimeout(ctx context.Context, timeout time.Duration, c *websocket.Conn, msg []byte) error {
-	ctx, cancel := context.WithTimeout(ctx, timeout)
-	defer cancel()
-
-	return c.Write(ctx, websocket.MessageText, msg)
-}

apiGo/videoparser/tmdb/TMDBApi.go

@@ -21,43 +21,21 @@ type VideoTMDB struct {
 	GenreIds  []int
 }
 
-type TVShowTMDB struct {
-	Thumbnail string
-	Overview  string
-	GenreIds  []int
-}
-
 type tmdbVidResult struct {
-	PosterPath       *string `json:"poster_path"`
+	Poster_path       string
-	Adult            bool    `json:"adult"`
+	Adult             bool
-	Overview         string  `json:"overview"`
+	Overview          string
-	ReleaseDate      string  `json:"release_date"`
+	Release_date      string
-	GenreIds         []int   `json:"genre_ids"`
+	Genre_ids         []int
-	Id               int     `json:"id"`
+	Id                int
-	OriginalTitle    string  `json:"original_title"`
+	Original_title    string
-	OriginalLanguage string  `json:"original_language"`
+	Original_language string
-	Title            string  `json:"title"`
+	Title             string
-	BackdropPath     *string `json:"backdrop_path"`
+	Backdrop_path     string
-	Popularity       int     `json:"popularity"`
+	Popularity        int
-	VoteCount        int     `json:"vote_count"`
+	Vote_count        int
-	Video            bool    `json:"video"`
+	Video             bool
-	VoteAverage      int     `json:"vote_average"`
+	Vote_average      int
-}
-
-type tmdbTvResult struct {
-	PosterPath       *string  `json:"poster_path"`
-	Popularity       int      `json:"popularity"`
-	Id               int      `json:"id"`
-	BackdropPath     *string  `json:"backdrop_path"`
-	VoteAverage      int      `json:"vote_average"`
-	Overview         string   `json:"overview"`
-	FirstAirDate     string   `json:"first_air_date"`
-	OriginCountry    []string `json:"origin_country"`
-	GenreIds         []int    `json:"genre_ids"`
-	OriginalLanguage string   `json:"original_language"`
-	VoteCount        int      `json:"vote_count"`
-	Name             string   `json:"name"`
-	OriginalName     string   `json:"original_name"`
 }
 
 type TMDBGenre struct {
@@ -96,7 +74,7 @@ func SearchVideo(MovieName string, year int) *VideoTMDB {
 	if year != -1 {
 		for _, result := range t.Results {
 			r, _ := regexp.Compile(fmt.Sprintf(`^%d-[0-9]{2}?-[0-9]{2}?$`, year))
-			if r.MatchString(result.ReleaseDate) {
+			if r.MatchString(result.Release_date) {
 				tmdbVid = result
 				// continue parsing
 				goto cont
@@ -111,69 +89,22 @@ func SearchVideo(MovieName string, year int) *VideoTMDB {
 	// continue label
 cont:
 
-	var thumbnail = ""
+	thumbnail := fetchPoster(tmdbVid)
-	if tmdbVid.PosterPath != nil {
-		pic := fetchPoster(*tmdbVid.PosterPath)
-		if pic != nil {
-			thumbnail = *pic
-		}
-	}
 
 	result := VideoTMDB{
-		Thumbnail: thumbnail,
+		Thumbnail: *thumbnail,
 		Overview:  tmdbVid.Overview,
 		Title:     tmdbVid.Title,
-		GenreIds:  tmdbVid.GenreIds,
+		GenreIds:  tmdbVid.Genre_ids,
 	}
 
 	return &result
 }
 
-func SearchTVShow(Name string) *TVShowTMDB {
+func fetchPoster(vid tmdbVidResult) *string {
-	fmt.Printf("Searching TMDB for: TVShow: %s\n", Name)
+	url := fmt.Sprintf("%s%s", pictureBase, vid.Poster_path)
-	queryURL := fmt.Sprintf("%ssearch/tv?api_key=%s&query=%s", baseUrl, apiKey, url.QueryEscape(Name))
-	resp, err := http.Get(queryURL)
-	if err != nil {
-		fmt.Println(err.Error())
-		return nil
-	}
 
-	body, err := ioutil.ReadAll(resp.Body)
+	resp, err := http.Get(url)
-	if err != nil {
-		fmt.Println(err.Error())
-		return nil
-	}
-
-	var t struct {
-		Results []tmdbTvResult `json:"results"`
-	}
-	err = json.Unmarshal(body, &t)
-
-	fmt.Println(len(t.Results))
-
-	if len(t.Results) == 0 {
-		return nil
-	}
-
-	res := TVShowTMDB{
-		Thumbnail: "",
-		Overview:  t.Results[0].Overview,
-		GenreIds:  t.Results[0].GenreIds,
-	}
-
-	if t.Results[0].PosterPath != nil {
-		pic := fetchPoster(*t.Results[0].PosterPath)
-		if pic != nil {
-			res.Thumbnail = *pic
-		}
-	}
-
-	return &res
-}
-
-func fetchPoster(posterPath string) *string {
-	posterURL := fmt.Sprintf("%s%s", pictureBase, posterPath)
-	resp, err := http.Get(posterURL)
 	if err != nil {
 		fmt.Println(err.Error())
 		return nil
@@ -192,8 +123,8 @@ func fetchPoster(posterPath string) *string {
 var tmdbGenres *[]TMDBGenre
 
 func fetchGenres() *[]TMDBGenre {
-	posterURL := fmt.Sprintf("%sgenre/movie/list?api_key=%s", baseUrl, apiKey)
+	url := fmt.Sprintf("%sgenre/movie/list?api_key=%s", baseUrl, apiKey)
-	resp, err := http.Get(posterURL)
+	resp, err := http.Get(url)
 	if err != nil {
 		fmt.Println(err.Error())
 		return nil

database.sql

@@ -9,12 +9,12 @@ create table if not exists actors
 
 create table if not exists settings
 (
-    video_path       varchar(255)                          null,
+    video_path       varchar(255)      null,
-    episode_path     varchar(255)                          null,
+    episode_path     varchar(255)      null,
-    password         varchar(32) default '-1'              null,
+    password         varchar(32)       null,
-    mediacenter_name varchar(32) default 'OpenMediaCenter' null,
+    mediacenter_name varchar(32)       null,
-    TMDB_grabbing    tinyint                               null,
+    TMDB_grabbing    tinyint           null,
-    DarkMode         tinyint     default 0                 null
+    DarkMode         tinyint default 0 null
 );
 
 create table if not exists tags
@@ -24,41 +24,18 @@ create table if not exists tags
     tag_name varchar(50) null
 );
 
-create table if not exists tvshow
-(
-    name       varchar(100) null,
-    thumbnail  mediumblob   null,
-    id         int auto_increment
-        primary key,
-    foldername varchar(100) null
-);
-
-create table if not exists tvshow_episodes
-(
-    id        int auto_increment
-        primary key,
-    name      varchar(100) null,
-    season    int          null,
-    poster    mediumblob   null,
-    tvshow_id int          null,
-    episode   int          null,
-    filename  varchar(100) null,
-    constraint tvshow_episodes_tvshow_id_fk
-        foreign key (tvshow_id) references tvshow (id)
-);
-
 create table if not exists videos
 (
     movie_id    int auto_increment
         primary key,
-    movie_name  varchar(200)                         null,
+    movie_name  varchar(200)                       null,
-    movie_url   varchar(250)                         null,
+    movie_url   varchar(250)                       null,
-    thumbnail   mediumblob                           null,
+    thumbnail   mediumblob                         null,
-    poster      mediumblob                           null,
+    likes       int      default 0                 null,
-    likes       int      default 0                   null,
+    create_date datetime default CURRENT_TIMESTAMP null,
-    quality     int                                  null,
+    quality     int                                null,
-    length      int                                  null comment 'in seconds',
+    length      int                                null comment 'in seconds',
-    create_date datetime default current_timestamp() null
+    poster      mediumblob                         null
 );
 
 create table if not exists actors_videos

deb/OpenMediaCenter/etc/nginx/sites-available/OpenMediaCenter.conf

@@ -16,11 +16,4 @@ server {
     location ~* ^/(api/|token) {
         proxy_pass http://127.0.0.1:8081;
     }
-    location /subscribe {
-        proxy_pass http://127.0.0.1:8081;
-        proxy_http_version 1.1;
-        proxy_set_header Upgrade $http_upgrade;
-        proxy_set_header Connection "Upgrade";
-        proxy_set_header Host $host;
-    }
 }

package.json

@@ -12,21 +12,20 @@
     "@fortawesome/free-regular-svg-icons": "^5.15.1",
     "@fortawesome/free-solid-svg-icons": "^5.15.1",
     "@fortawesome/react-fontawesome": "^0.1.13",
-    "bootstrap": "^5.0.2",
+    "bootstrap": "^4.5.3",
     "plyr-react": "^3.0.7",
     "react": "^17.0.1",
     "react-bootstrap": "^1.4.0",
     "react-dom": "^17.0.1",
     "react-router": "^5.2.0",
     "react-router-dom": "^5.2.0",
-    "typescript": "^4.3.5"
+    "typescript": "^4.1.3"
   },
   "scripts": {
     "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": [
@@ -53,37 +52,30 @@
     ]
   },
   "devDependencies": {
-    "@testing-library/jest-dom": "^5.14.1",
+    "@testing-library/jest-dom": "^5.11.6",
-    "@testing-library/react": "^12.0.0",
+    "@testing-library/react": "^11.2.2",
-    "@testing-library/user-event": "^13.2.1",
+    "@testing-library/user-event": "^12.6.0",
-    "@types/jest": "^26.0.24",
+    "@types/jest": "^26.0.19",
-    "@types/node": "^16.4.7",
+    "@types/node": "^14.14.31",
-    "@types/react": "^17.0.15",
+    "@types/react": "^17.0.2",
-    "@types/react-dom": "^17.0.9",
+    "@types/react-dom": "^17.0.1",
-    "@types/react-router": "5.1.16",
+    "@types/react-router": "5.1.12",
-    "@types/react-router-dom": "^5.1.8",
+    "@types/react-router-dom": "^5.1.6",
-    "@typescript-eslint/eslint-plugin": "^4.28.5",
+    "@typescript-eslint/eslint-plugin": "^4.17.0",
-    "@typescript-eslint/parser": "^4.28.5",
+    "@typescript-eslint/parser": "^4.17.0",
-    "apidoc": "^0.28.1",
     "enzyme": "^3.11.0",
     "enzyme-adapter-react-16": "^1.15.5",
-    "eslint": "^7.31.0",
+    "eslint": "^7.22.0",
     "eslint-config-prettier": "^8.1.0",
     "eslint-formatter-gitlab": "^2.2.0",
     "eslint-plugin-eslint-comments": "^3.2.0",
-    "eslint-plugin-jest": "^24.4.0",
+    "eslint-plugin-jest": "^24.3.1",
     "eslint-plugin-prettier": "^3.3.1",
     "eslint-plugin-react": "^7.22.0",
     "eslint-plugin-react-hooks": "^4.2.0",
     "jest-junit": "^12.0.0",
-    "prettier": "^2.3.2",
+    "prettier": "^2.2.1",
     "prettier-config": "^1.0.0",
     "react-scripts": "4.0.3"
-  },
-  "apidoc": {
-    "name": "OpenMediaCenter",
-    "description": "API Documentation of OpenMediaCenter",
-    "title": "OpenMediaCenter Doc",
-    "sampleUrl": null
   }
 }

public/index.html

@@ -2,14 +2,14 @@
 <html lang="en">
   <head>
     <meta charset="utf-8" />
-    <link rel="icon" href="%PUBLIC_URL%/logo_circle.png" />
+    <link rel="icon" href="%PUBLIC_URL%/favicon.ico" />
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <meta name="theme-color" content="#000000" />
     <meta
       name="description"
       content="A Application to run a Mediacenter in your local network"
     />
-    <link rel="apple-touch-icon" href="%PUBLIC_URL%/logo_circle.png" />
+    <link rel="apple-touch-icon" href="%PUBLIC_URL%/logo192.png" />
     <!--
       manifest.json provides metadata used when your web app is installed on a
       user's mobile device or desktop. See https://developers.google.com/web/fundamentals/web-app-manifest/

public/manifest.json

@@ -3,9 +3,19 @@
   "name": "Create React App Sample",
   "icons": [
     {
-      "src": "logo_circle.png",
+      "src": "favicon.ico",
+      "sizes": "64x64 32x32 24x24 16x16",
+      "type": "image/x-icon"
+    },
+    {
+      "src": "logo192.png",
       "type": "image/png",
       "sizes": "192x192"
+    },
+    {
+      "src": "logo512.png",
+      "type": "image/png",
+      "sizes": "512x512"
     }
   ],
   "start_url": ".",

src/App.module.css

@@ -12,7 +12,6 @@
     margin-left: 20px;
     opacity: 0.6;
     text-transform: capitalize;
-    text-decoration: none;
 }
 
 .navitem:hover {

src/App.test.js

@@ -19,11 +19,6 @@ describe('<App/>', function () {
         const wrapper = shallow(<App/>);
         wrapper.setState({password: false});
         expect(wrapper.find('.navitem')).toHaveLength(4);
-
-        GlobalInfos.setTVShowsEnabled(true);
-
-        wrapper.instance().forceUpdate();
-        expect(wrapper.find('.navitem')).toHaveLength(5);
     });
 
     it('test initial fetch from api', done => {

src/App.tsx

@@ -9,7 +9,7 @@ import style from './App.module.css';
 
 import SettingsPage from './pages/SettingsPage/SettingsPage';
 import CategoryPage from './pages/CategoryPage/CategoryPage';
-import {APINode, callAPI} from './utils/Api';
+import {APINode, apiTokenValid, callApiUnsafe, refreshAPIToken} from './utils/Api';
 
 import {BrowserRouter as Router, NavLink, Route, Switch} from 'react-router-dom';
 import Player from './pages/Player/Player';
@@ -17,10 +17,6 @@ import ActorOverviewPage from './pages/ActorOverviewPage/ActorOverviewPage';
 import ActorPage from './pages/ActorPage/ActorPage';
 import {SettingsTypes} from './types/ApiTypes';
 import AuthenticationPage from './pages/AuthenticationPage/AuthenticationPage';
-import TVShowPage from './pages/TVShowPage/TVShowPage';
-import TVPlayer from './pages/TVShowPage/TVPlayer';
-import {CookieTokenStore} from './utils/TokenStore/CookieTokenStore';
-import {token} from './utils/TokenHandler';
 
 interface state {
     password: boolean | null; // null if uninitialized - true if pwd needed false if not needed
@@ -34,14 +30,12 @@ class App extends React.Component<{}, state> {
     constructor(props: {}) {
         super(props);
 
-        token.init(new CookieTokenStore());
-
         let pwdneeded: boolean | null = null;
 
-        if (token.apiTokenValid()) {
+        if (apiTokenValid()) {
             pwdneeded = false;
         } else {
-            token.refreshAPIToken((err) => {
+            refreshAPIToken((err) => {
                 if (err === 'invalid_client') {
                     this.setState({password: true});
                 } else if (err === '') {
@@ -65,7 +59,7 @@ class App extends React.Component<{}, state> {
         // set the hook to load passwordfield on global func call
         GlobalInfos.loadPasswordPage = (callback?: () => void): void => {
             // try refreshing the token
-            token.refreshAPIToken((err) => {
+            refreshAPIToken((err) => {
                 if (err !== '') {
                     this.setState({password: true});
                 } else {
@@ -80,13 +74,11 @@ class App extends React.Component<{}, state> {
 
     initialAPICall(): void {
         // this is the first api call so if it fails we know there is no connection to backend
-        callAPI(APINode.Settings, {action: 'loadInitialData'}, (result: SettingsTypes.initialApiCallData) => {
+        callApiUnsafe(APINode.Init, {action: 'loadInitialData'}, (result: SettingsTypes.initialApiCallData) => {
             // set theme
             GlobalInfos.enableDarkTheme(result.DarkMode);
 
-            GlobalInfos.setVideoPaths(result.VideoPath, result.TVShowPath);
+            GlobalInfos.setVideoPath(result.VideoPath);
-
-            GlobalInfos.setTVShowsEnabled(result.TVShowEnabled);
 
             this.setState({
                 mediacentername: result.MediacenterName
@@ -101,25 +93,48 @@ class App extends React.Component<{}, state> {
     }
 
     render(): JSX.Element {
+        const themeStyle = GlobalInfos.getThemeStyle();
         // add the main theme to the page body
-        document.body.className = GlobalInfos.getThemeStyle().backgroundcolor;
+        document.body.className = themeStyle.backgroundcolor;
 
         if (this.state.password === true) {
             // render authentication page if auth is neccessary
-            return (
+            return <AuthenticationPage onSuccessLogin={(): void => this.setState({password: false})} />;
-                <AuthenticationPage
-                    onSuccessLogin={(): void => {
-                        this.setState({password: false});
-                        // reinit general infos
-                        this.initialAPICall();
-                    }}
-                />
-            );
         } else if (this.state.password === false) {
             return (
                 <Router>
                     <div className={style.app}>
-                        {this.navBar()}
+                        <div
+                            className={[style.navcontainer, themeStyle.backgroundcolor, themeStyle.textcolor, themeStyle.hrcolor].join(
+                                ' '
+                            )}>
+                            <div className={style.navbrand}>{this.state.mediacentername}</div>
+                            <NavLink
+                                className={[style.navitem, themeStyle.navitem].join(' ')}
+                                to={'/'}
+                                activeStyle={{opacity: '0.85'}}>
+                                Home
+                            </NavLink>
+                            <NavLink
+                                className={[style.navitem, themeStyle.navitem].join(' ')}
+                                to={'/random'}
+                                activeStyle={{opacity: '0.85'}}>
+                                Random Video
+                            </NavLink>
+
+                            <NavLink
+                                className={[style.navitem, themeStyle.navitem].join(' ')}
+                                to={'/categories'}
+                                activeStyle={{opacity: '0.85'}}>
+                                Categories
+                            </NavLink>
+                            <NavLink
+                                className={[style.navitem, themeStyle.navitem].join(' ')}
+                                to={'/settings'}
+                                activeStyle={{opacity: '0.85'}}>
+                                Settings
+                            </NavLink>
+                        </div>
                         {this.routing()}
                     </div>
                 </Router>
@@ -129,42 +144,6 @@ class App extends React.Component<{}, state> {
         }
     }
 
-    /**
-     * render the top navigation bar
-     */
-    navBar(): JSX.Element {
-        const themeStyle = GlobalInfos.getThemeStyle();
-
-        return (
-            <div className={[style.navcontainer, themeStyle.backgroundcolor, themeStyle.textcolor, themeStyle.hrcolor].join(' ')}>
-                <div className={style.navbrand}>{this.state.mediacentername}</div>
-                <NavLink className={[style.navitem, themeStyle.navitem].join(' ')} to={'/'} activeStyle={{opacity: '0.85'}}>
-                    Home
-                </NavLink>
-                <NavLink className={[style.navitem, themeStyle.navitem].join(' ')} to={'/random'} activeStyle={{opacity: '0.85'}}>
-                    Random Video
-                </NavLink>
-
-                <NavLink className={[style.navitem, themeStyle.navitem].join(' ')} to={'/categories'} activeStyle={{opacity: '0.85'}}>
-                    Categories
-                </NavLink>
-
-                {GlobalInfos.isTVShowEnabled() ? (
-                    <NavLink className={[style.navitem, themeStyle.navitem].join(' ')} to={'/tvshows'} activeStyle={{opacity: '0.85'}}>
-                        TV Shows
-                    </NavLink>
-                ) : null}
-
-                <NavLink className={[style.navitem, themeStyle.navitem].join(' ')} to={'/settings'} activeStyle={{opacity: '0.85'}}>
-                    Settings
-                </NavLink>
-            </div>
-        );
-    }
-
-    /**
-     * render the react router elements
-     */
     routing(): JSX.Element {
         return (
             <Switch>
@@ -186,19 +165,6 @@ class App extends React.Component<{}, state> {
                 <Route path='/actors/:id'>
                     <ActorPage />
                 </Route>
-
-                {GlobalInfos.isTVShowEnabled() ? (
-                    <Route path='/tvshows'>
-                        <TVShowPage />
-                    </Route>
-                ) : null}
-
-                {GlobalInfos.isTVShowEnabled() ? (
-                    <Route exact path='/tvplayer/:id'>
-                        <TVPlayer />
-                    </Route>
-                ) : null}
-
                 <Route path='/'>
                     <HomePage />
                 </Route>

src/elements/ActorTile/ActorTile.tsx

@@ -25,11 +25,7 @@ class ActorTile extends React.Component<Props> {
         }
     }
 
-    /**
+    renderActorTile(customclickhandler: (actor: ActorType) => void): JSX.Element {
-     * render the Actor Tile with its pic
-     * @param customclickhandler a custom click handler to be called onclick instead of Link
-     */
-    private renderActorTile(customclickhandler: (actor: ActorType) => void): JSX.Element {
         return (
             <div className={style.actortile} onClick={(): void => customclickhandler(this.props.actor)}>
                 <div className={style.actortile_thumbnail}>

src/elements/DynamicContentContainer/DynamicContentContainer.test.js

@@ -1,49 +0,0 @@
-import {shallow} from 'enzyme';
-import React from 'react';
-import DynamicContentContainer from './DynamicContentContainer';
-
-describe('<DynamicContentContainer/>', function () {
-    it('renders without crashing ', function () {
-        const wrapper = shallow(<DynamicContentContainer data={[]} renderElement={(el) => (<></>)}/>);
-        wrapper.unmount();
-    });
-
-    it('inserts tiles correctly if enough available', () => {
-        const wrapper = shallow(<DynamicContentContainer data={[
-            {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}
-        ]} renderElement={(el) => (<a/>)}/>);
-        expect(wrapper.find('a')).toHaveLength(16);
-    });
-
-    it('inserts tiles correctly if not enough available', () => {
-        const wrapper = shallow(<DynamicContentContainer data={[
-            {}, {}, {}, {}
-        ]} renderElement={(el) => (<a/>)}/>);
-        expect(wrapper.find('a')).toHaveLength(4);
-    });
-
-    it('no items available', () => {
-        const wrapper = shallow(<DynamicContentContainer data={[]} renderElement={(el) => (<a/>)}/>);
-        expect(wrapper.find('a')).toHaveLength(0);
-        expect(wrapper.find('.maincontent').text()).toBe('no items to show!');
-    });
-
-    it('test clean', function () {
-        const wrapper = shallow(<DynamicContentContainer data={[{}, {}, {}]} renderElement={(el) => (<a/>)}/>);
-        expect(wrapper.find('a')).toHaveLength(3);
-        wrapper.instance().clean();
-        expect(wrapper.find('a')).toHaveLength(0);
-    });
-
-    it('test update', function () {
-        const wrapper = shallow(<DynamicContentContainer data={[{}, {}, {}]} renderElement={(el) => (<a/>)}/>);
-
-        const func = jest.fn();
-        wrapper.instance().clean = func;
-
-        // perform component update
-        wrapper.setProps({data: [{}, {}]});
-
-        expect(func).toHaveBeenCalledTimes(1);
-    });
-});

src/elements/DynamicContentContainer/DynamicContentContainer.tsx

@@ -1,113 +0,0 @@
-import React from 'react';
-import style from './DynamicContentContainer.module.css';
-
-interface Props<T> {
-    renderElement: (elem: T) => JSX.Element;
-    data: T[];
-    initialLoadNr?: number;
-}
-
-interface state<T> {
-    loadeditems: T[];
-}
-
-/**
- * A videocontainer storing lots of Preview elements
- * includes scroll handling and loading of preview infos
- */
-class DynamicContentContainer<T> extends React.Component<Props<T>, state<T>> {
-    // stores current index of loaded elements
-    loadindex: number = 0;
-
-    readonly InitialLoadNR = this.props.initialLoadNr
-        ? this.props.initialLoadNr === -1
-            ? this.props.data.length
-            : this.props.initialLoadNr
-        : 16;
-
-    constructor(props: Props<T>) {
-        super(props);
-
-        this.state = {
-            loadeditems: []
-        };
-    }
-
-    componentDidMount(): void {
-        document.addEventListener('scroll', this.trackScrolling);
-
-        this.loadPreviewBlock(this.InitialLoadNR);
-    }
-
-    componentDidUpdate(prevProps: Props<T>): void {
-        // when source props change force update!
-        if (
-            // diff the two arrays
-            this.props.data
-                .filter((x) => !prevProps.data.includes(x))
-                .concat(prevProps.data.filter((x) => !this.props.data.includes(x))).length !== 0
-        ) {
-            this.clean((): void => {
-                this.loadPreviewBlock(this.InitialLoadNR);
-            });
-        }
-    }
-
-    /**
-     * clear all elements rendered...
-     */
-    clean(callback: () => void): void {
-        this.loadindex = 0;
-        this.setState({loadeditems: []}, callback);
-    }
-
-    render(): JSX.Element {
-        return (
-            <div className={style.maincontent}>
-                {this.state.loadeditems.map((elem) => {
-                    return this.props.renderElement(elem);
-                })}
-                {/*todo css for no items to show*/}
-                {this.state.loadeditems.length === 0 ? 'no items to show!' : null}
-                {this.props.children}
-            </div>
-        );
-    }
-
-    componentWillUnmount(): void {
-        // unbind scroll listener when unmounting component
-        document.removeEventListener('scroll', this.trackScrolling);
-    }
-
-    /**
-     * load previews to the container
-     * @param nr number of previews to load
-     */
-    loadPreviewBlock(nr: number): void {
-        let ret = [];
-        for (let i = 0; i < nr; i++) {
-            // only add if not end
-            if (this.props.data.length > this.loadindex + i) {
-                ret.push(this.props.data[this.loadindex + i]);
-            }
-        }
-
-        this.setState({
-            loadeditems: [...this.state.loadeditems, ...ret]
-        });
-
-        this.loadindex += nr;
-    }
-
-    /**
-     * scroll event handler -> load new previews if on bottom
-     */
-    trackScrolling = (): void => {
-        // comparison if current scroll position is on bottom --> 200 is bottom offset to trigger load
-        if (window.innerHeight + document.documentElement.scrollTop + 200 >= document.documentElement.offsetHeight) {
-            this.loadPreviewBlock(8);
-        }
-    };
-}
-
-export default DynamicContentContainer;

src/elements/Popups/PopupBase.tsx

@@ -70,7 +70,7 @@ class PopupBase extends React.Component<Props> {
     }
 
     /**
-     * handle click on outside of element
+     * Alert if clicked on outside of element
      */
     handleClickOutside(event: MouseEvent): void {
         if (this.wrapperRef && this.wrapperRef.current && !this.wrapperRef.current.contains(event.target as Node)) {

src/elements/Preview/Preview.module.css

@@ -1,32 +1,19 @@
-.previewtitle {
+.previewText {
-    font-size: smaller;
+    font-size: 15px;
     font-weight: bold;
-    height: 20px;
+    height: 42px;
-    max-width: 266px;
+    width: 100%;
     text-align: center;
-}
-
-.videopreview:hover .quickactions {
-    background-color: rgba(0, 0, 0, 0.8);
-    border-radius: 50%;
-
-    color: lightgrey;
-    display: block;
-
-    height: 35px;
-    opacity: 0.7;
-    padding-top: 5px;
-
     position: absolute;
+    bottom: 0;
+    background-color: rgba(60, 61, 72, 0.7);
+    color: white;
+    border-bottom-left-radius: 20px;
+    border-bottom-right-radius: 20px;
 
-    right: 5px;
+    border-top-width: 1px;
-    text-align: center;
+    border-top-color: #3c3d48;
-    top: 5px;
+    border-top-style: solid;
-    width: 35px;
-}
-
-.quickactions {
-    display: none;
 }
 
 .previewpic {
@@ -35,6 +22,8 @@
     min-width: 266px;
     overflow: hidden;
     text-align: center;
+
+    border-radius: 20px;
 }
 
 .loadAnimation {

src/elements/Preview/Preview.tsx

@@ -3,21 +3,17 @@ import style from './Preview.module.css';
 import {Spinner} from 'react-bootstrap';
 import {Link} from 'react-router-dom';
 import GlobalInfos from '../../utils/GlobalInfos';
+import {APINode, callAPIPlain} from '../../utils/Api';
 import {FontAwesomeIcon} from '@fortawesome/react-fontawesome';
 import {faPhotoVideo} from '@fortawesome/free-solid-svg-icons';
-import {faEllipsisV} from '@fortawesome/free-solid-svg-icons';
-import QuickActionPop, {ContextItem} from '../QuickActionPop/QuickActionPop';
 
 interface PreviewProps {
     name: string;
-    picLoader: (callback: (pic: string) => void) => void;
+    movieId: number;
-    linkPath?: string;
-    onClick?: () => void;
 }
 
 interface PreviewState {
-    picLoaded: boolean | null;
+    previewpicture: string | null;
-    optionsvisible: boolean;
 }
 
 /**
@@ -25,92 +21,54 @@ interface PreviewState {
  * floating side by side
  */
 class Preview extends React.Component<PreviewProps, PreviewState> {
-    // store the picture to display
-    pic?: string;
-
     constructor(props: PreviewProps) {
         super(props);
 
         this.state = {
-            picLoaded: null,
+            previewpicture: null
-            optionsvisible: false
         };
     }
 
     componentDidMount(): void {
-        this.props.picLoader((result) => {
+        callAPIPlain(APINode.Video, {action: 'readThumbnail', movieid: this.props.movieId}, (result) => {
-            this.pic = result;
             this.setState({
-                picLoaded: result !== ''
+                previewpicture: result
             });
         });
     }
 
     render(): JSX.Element {
-        if (this.props.linkPath !== undefined) {
-            return <Link to={this.props.linkPath}>{this.content()}</Link>;
-        } else {
-            return this.content();
-        }
-    }
-
-    content(): JSX.Element {
         const themeStyle = GlobalInfos.getThemeStyle();
         return (
-            <div
+            <Link to={'/player/' + this.props.movieId}>
-                className={style.videopreview + ' ' + themeStyle.secbackground + ' ' + themeStyle.preview}
+                <div className={style.videopreview + ' ' + themeStyle.secbackground + ' ' + themeStyle.preview}>
-                onClick={this.props.onClick}>
+                    <div className={style.previewpic}>{this.renderPic()}</div>
-                <div
+                    <div className={style.previewText + ' ' + themeStyle.lighttextcolor}>{this.props.name}</div>
-                    className={style.quickactions}
-                    onClick={(e): void => {
-                        this.setState({optionsvisible: true});
-                        e.stopPropagation();
-                        e.preventDefault();
-                    }}>
-                    <FontAwesomeIcon
-                        style={{
-                            verticalAlign: 'middle',
-                            fontSize: '25px'
-                        }}
-                        icon={faEllipsisV}
-                        size='1x'
-                    />
                 </div>
-                {this.popupvisible()}
+            </Link>
-                <div className={style.previewtitle + ' ' + themeStyle.lighttextcolor}>{this.props.name}</div>
-                <div className={style.previewpic}>
-                    {this.state.picLoaded === false ? (
-                        <FontAwesomeIcon
-                            style={{
-                                color: 'white',
-                                marginTop: '55px'
-                            }}
-                            icon={faPhotoVideo}
-                            size='5x'
-                        />
-                    ) : this.state.picLoaded === null ? (
-                        <span className={style.loadAnimation}>
-                            <Spinner animation='border' />
-                        </span>
-                    ) : (
-                        <img className={style.previewimage} src={this.pic} alt='Pic loading.' />
-                    )}
-                </div>
-                <div className={style.previewbottom} />
-            </div>
         );
     }
 
-    popupvisible(): JSX.Element {
+    private renderPic(): JSX.Element {
-        if (this.state.optionsvisible) {
+        if (this.state.previewpicture === '') {
             return (
-                <QuickActionPop position={{x: 350, y: 45}} onHide={(): void => this.setState({optionsvisible: false})}>
+                <FontAwesomeIcon
-                    <ContextItem title='Delete' onClick={(): void => {}} />
+                    style={{
-                    <ContextItem title='Delete' onClick={(): void => {}} />
+                        color: 'white',
-                </QuickActionPop>
+                        marginTop: '55px'
+                    }}
+                    icon={faPhotoVideo}
+                    size='5x'
+                />
+            );
+        } else if (this.state.previewpicture === null) {
+            return (
+                <span className={style.loadAnimation}>
+                    <Spinner animation='border' />
+                </span>
             );
         } else {
-            return <></>;
+            return <img className={style.previewimage} src={this.state.previewpicture} alt='Pic loading.' />;
         }
     }
 }

src/elements/Preview/Previw.test.js

@@ -5,29 +5,37 @@ import Preview, {TagPreview} from './Preview';
 
 describe('<Preview/>', function () {
     it('renders without crashing ', function () {
-        const wrapper = shallow(<Preview movieId={1} name='test' picLoader={callback => callback('')}/>);
+        const wrapper = shallow(<Preview movieId={1}/>);
         wrapper.unmount();
     });
 
-    it('picture rendered correctly', () => {
+    it('picture rendered correctly', done => {
-        const func = jest.fn();
+        const mockSuccessResponse = 'testsrc';
-        const wrapper = shallow(<Preview movieId={1} name='test' picLoader={callback => {
+        const mockJsonPromise = Promise.resolve(mockSuccessResponse);
-            func();
+        const mockFetchPromise = Promise.resolve({
-            callback('42');
+            text: () => mockJsonPromise
-        }}/>);
+        });
+        global.fetch = jest.fn().mockImplementation(() => mockFetchPromise);
 
-        // expect picloader tobe called once
+        const wrapper = shallow(<Preview name='test' movieId={1}/>);
-        expect(func).toHaveBeenCalledTimes(1)
+
+        // now called 1 times
+        expect(global.fetch).toHaveBeenCalledTimes(1);
+
+        process.nextTick(() => {
+            // received picture should be rendered into wrapper
+            expect(wrapper.find('.previewimage').props().src).not.toBeNull();
+            // check if preview title renders correctly
+            expect(wrapper.find('.previewtitle').text()).toBe('test');
+
+            global.fetch.mockClear();
+            done();
+        });
 
-        // received picture should be rendered into wrapper
-        expect(wrapper.find('.previewimage').props().src).toBe('42');
-        // check if preview title renders correctly
-        expect(wrapper.find('.previewtitle').text()).toBe('test');
     });
 
     it('spinner loads correctly', function () {
-        // if callback is never called --> infinite spinner
+        const wrapper = shallow(<Preview movieId={1}/>);
-        const wrapper = shallow(<Preview movieId={1} name='test' picLoader={callback => {}}/>);
 
         // expect load animation to be visible
         expect(wrapper.find('.loadAnimation')).toHaveLength(1);

src/elements/QuickActionPop/QuickActionPop.tsx

@@ -1,65 +0,0 @@
-import React, {RefObject} from 'react';
-import style from './QuickActionPopup.module.css';
-
-interface props {
-    position: {
-        x: number;
-        y: number;
-    };
-    onHide: () => void;
-}
-
-class QuickActionPop extends React.Component<props> {
-    private readonly wrapperRef: RefObject<HTMLDivElement>;
-
-    constructor(props: props) {
-        super(props);
-
-        this.wrapperRef = React.createRef();
-
-        this.handleClickOutside = this.handleClickOutside.bind(this);
-    }
-
-    componentDidMount(): void {
-        document.addEventListener('mousedown', this.handleClickOutside);
-    }
-
-    componentWillUnmount(): void {
-        document.removeEventListener('mousedown', this.handleClickOutside);
-    }
-
-    render(): JSX.Element {
-        return (
-            <div ref={this.wrapperRef} className={style.quickaction} style={{top: this.props.position.y, left: this.props.position.x}}>
-                {this.props.children}
-            </div>
-        );
-    }
-
-    /**
-     * trigger hide if we click outside the div
-     */
-    handleClickOutside(event: MouseEvent): void {
-        if (this.wrapperRef && this.wrapperRef.current && !this.wrapperRef.current.contains(event.target as Node)) {
-            this.props.onHide();
-        }
-    }
-}
-
-interface Itemprops {
-    title: string;
-    onClick: () => void;
-}
-
-export const ContextItem = (props: Itemprops): JSX.Element => (
-    <div
-        onClick={(e): void => {
-            e.preventDefault();
-            props.onClick();
-        }}
-        className={style.ContextItem}>
-        {props.title}
-    </div>
-);
-
-export default QuickActionPop;

src/elements/QuickActionPop/QuickActionPopup.module.css

@@ -1,17 +0,0 @@
-.quickaction {
-    background-color: white;
-    height: 120px;
-    position: absolute;
-    width: 90px;
-    z-index: 2;
-}
-
-.ContextItem {
-    height: 40px;
-    padding-top: 10px;
-    text-align: center;
-}
-
-.ContextItem:hover {
-    background-color: lightgray;
-}

src/elements/Tag/Tag.tsx

@@ -1,4 +1,4 @@
-import React, {SyntheticEvent, PointerEvent} from 'react';
+import React from 'react';
 
 import styles from './Tag.module.css';
 import {Link} from 'react-router-dom';
@@ -7,27 +7,12 @@ import {TagType} from '../../types/VideoTypes';
 interface props {
     onclick?: (_: string) => void;
     tagInfo: TagType;
-    onContextMenu?: (pos: {x: number; y: number}) => void;
-}
-
-interface state {
-    contextVisible: boolean;
 }
 
 /**
  * A Component representing a single Category tag
  */
-class Tag extends React.Component<props, state> {
+class Tag extends React.Component<props> {
-    constructor(props: Readonly<props> | props) {
-        super(props);
-
-        this.state = {
-            contextVisible: false
-        };
-
-        this.contextmenu = this.contextmenu.bind(this);
-    }
-
     render(): JSX.Element {
         if (this.props.onclick) {
             return this.renderButton();
@@ -38,11 +23,7 @@ class Tag extends React.Component<props, state> {
 
     renderButton(): JSX.Element {
         return (
-            <button
+            <button className={styles.tagbtn} onClick={(): void => this.TagClick()} data-testid='Test-Tag'>
-                className={styles.tagbtn}
-                onClick={(): void => this.TagClick()}
-                data-testid='Test-Tag'
-                onContextMenu={this.contextmenu}>
                 {this.props.tagInfo.TagName}
             </button>
         );
@@ -58,22 +39,6 @@ class Tag extends React.Component<props, state> {
             return;
         }
     }
-
-    /**
-     * handle a custom contextmenu for this item
-     * @param e
-     * @private
-     */
-    private contextmenu(e: SyntheticEvent): void {
-        if (!this.props.onContextMenu) {
-            return;
-        }
-
-        const event = e as unknown as PointerEvent;
-        event.preventDefault();
-        this.props.onContextMenu({x: event.clientX, y: event.clientY});
-        // this.setState({contextVisible: true});
-    }
 }
 
 export default Tag;

src/elements/VideoContainer/VideoContainer.module.css

@@ -1,5 +1,4 @@
 .maincontent {
     float: left;
     width: 70%;
-    flex: 1;
+}
-}

src/elements/VideoContainer/VideoContainer.test.js

@@ -7,4 +7,24 @@ describe('<VideoContainer/>', function () {
         const wrapper = shallow(<VideoContainer data={[]}/>);
         wrapper.unmount();
     });
+
+    it('inserts tiles correctly if enough available', () => {
+        const wrapper = shallow(<VideoContainer data={[
+            {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}
+        ]}/>);
+        expect(wrapper.find('Preview')).toHaveLength(16);
+    });
+
+    it('inserts tiles correctly if not enough available', () => {
+        const wrapper = shallow(<VideoContainer data={[
+            {}, {}, {}, {}
+        ]}/>);
+        expect(wrapper.find('Preview')).toHaveLength(4);
+    });
+
+    it('no items available', () => {
+        const wrapper = shallow(<VideoContainer data={[]}/>);
+        expect(wrapper.find('Preview')).toHaveLength(0);
+        expect(wrapper.find('.maincontent').text()).toBe('no items to show!');
+    });
 });

src/elements/VideoContainer/VideoContainer.tsx

@@ -1,38 +1,89 @@
 import React from 'react';
 import Preview from '../Preview/Preview';
+import style from './VideoContainer.module.css';
 import {VideoTypes} from '../../types/ApiTypes';
-import DynamicContentContainer from '../DynamicContentContainer/DynamicContentContainer';
-import {APINode, callAPIPlain} from '../../utils/Api';
 
 interface Props {
     data: VideoTypes.VideoUnloadedType[];
-    children?: JSX.Element;
 }
 
-const VideoContainer = (props: Props): JSX.Element => {
+interface state {
-    return (
+    loadeditems: VideoTypes.VideoUnloadedType[];
-        <DynamicContentContainer
+    selectionnr: number;
-            renderElement={(el): JSX.Element => (
+}
-                <Preview
+
-                    key={el.MovieId}
+/**
-                    picLoader={(callback: (pic: string) => void): void => {
+ * A videocontainer storing lots of Preview elements
-                        callAPIPlain(
+ * includes scroll handling and loading of preview infos
-                            APINode.Video,
+ */
-                            {
+class VideoContainer extends React.Component<Props, state> {
-                                action: 'readThumbnail',
+    // stores current index of loaded elements
-                                Movieid: el.MovieId
+    loadindex: number = 0;
-                            },
+
-                            (result) => callback(result)
+    constructor(props: Props) {
-                        );
+        super(props);
-                    }}
+
-                    name={el.MovieName}
+        this.state = {
-                    linkPath={'/player/' + el.MovieId}
+            loadeditems: [],
-                />
+            selectionnr: 0
-            )}
+        };
-            data={props.data}>
+    }
-            {props.children}
+
-        </DynamicContentContainer>
+    componentDidMount(): void {
-    );
+        document.addEventListener('scroll', this.trackScrolling);
-};
+
+        this.loadPreviewBlock(16);
+    }
+
+    render(): JSX.Element {
+        return (
+            <div className={style.maincontent}>
+                {this.state.loadeditems.map((elem) => (
+                    <Preview key={elem.MovieId} name={elem.MovieName} movieId={elem.MovieId} />
+                ))}
+                {/*todo css for no items to show*/}
+                {this.state.loadeditems.length === 0 ? 'no items to show!' : null}
+                {this.props.children}
+            </div>
+        );
+    }
+
+    componentWillUnmount(): void {
+        this.setState({});
+        // unbind scroll listener when unmounting component
+        document.removeEventListener('scroll', this.trackScrolling);
+    }
+
+    /**
+     * load previews to the container
+     * @param nr number of previews to load
+     */
+    loadPreviewBlock(nr: number): void {
+        console.log('loadpreviewblock called ...');
+        let ret = [];
+        for (let i = 0; i < nr; i++) {
+            // only add if not end
+            if (this.props.data.length > this.loadindex + i) {
+                ret.push(this.props.data[this.loadindex + i]);
+            }
+        }
+
+        this.setState({
+            loadeditems: [...this.state.loadeditems, ...ret]
+        });
+
+        this.loadindex += nr;
+    }
+
+    /**
+     * scroll event handler -> load new previews if on bottom
+     */
+    trackScrolling = (): void => {
+        // comparison if current scroll position is on bottom --> 200 is bottom offset to trigger load
+        if (window.innerHeight + document.documentElement.scrollTop + 200 >= document.documentElement.offsetHeight) {
+            this.loadPreviewBlock(8);
+        }
+    };
+}
 
 export default VideoContainer;

src/pages/ActorOverviewPage/ActorOverviewPage.test.js

@@ -8,6 +8,20 @@ describe('<ActorOverviewPage/>', function () {
         wrapper.unmount();
     });
 
+    it('test inerstion of actor tiles', function () {
+        const wrapper = shallow(<ActorOverviewPage/>);
+
+        wrapper.setState({
+            actors: [{
+                thumbnail: '',
+                name: 'testname',
+                actor_id: 42
+            }]
+        });
+
+        expect(wrapper.find('ActorTile')).toHaveLength(1);
+    });
+
     it('test newtagpopup visibility', function () {
         const wrapper = shallow(<ActorOverviewPage/>);
 

src/pages/ActorOverviewPage/ActorOverviewPage.tsx

@@ -4,10 +4,9 @@ import {ActorType} from '../../types/VideoTypes';
 import ActorTile from '../../elements/ActorTile/ActorTile';
 import PageTitle from '../../elements/PageTitle/PageTitle';
 import SideBar from '../../elements/SideBar/SideBar';
-// import style from './ActorOverviewPage.module.css';
+import style from './ActorOverviewPage.module.css';
 import {Button} from '../../elements/GPElements/Button';
 import NewActorPopup from '../../elements/Popups/NewActorPopup/NewActorPopup';
-import DynamicContentContainer from '../../elements/DynamicContentContainer/DynamicContentContainer';
 
 interface Props {}
 
@@ -37,12 +36,11 @@ class ActorOverviewPage extends React.Component<Props, state> {
                 <SideBar>
                     <Button title='Add Actor' onClick={(): void => this.setState({NActorPopupVisible: true})} />
                 </SideBar>
-                <DynamicContentContainer
+                <div className={style.container}>
-                    renderElement={(el): JSX.Element => <ActorTile key={el.ActorId} actor={el} />}
+                    {this.state.actors.map((el) => (
-                    data={this.state.actors}
+                        <ActorTile key={el.ActorId} actor={el} />
-                    initialLoadNr={36}
+                    ))}
-                />
+                </div>
-
                 {this.state.NActorPopupVisible ? (
                     <NewActorPopup
                         onHide={(): void => {

src/pages/ActorPage/ActorPage.tsx

@@ -48,7 +48,7 @@ export class ActorPage extends React.Component<Props, state> {
                     </div>
                     <SideBarTitle>Attention: This is an early preview!</SideBarTitle>
                 </SideBar>
-                <VideoContainer data={this.state.data} />
+                {this.state.data.length !== 0 ? <VideoContainer data={this.state.data} /> : <div>No Data found!</div>}
             </>
         );
     }
@@ -72,10 +72,6 @@ export class ActorPage extends React.Component<Props, state> {
                     data: result.Videos ? result.Videos : [],
                     actor: result.Info
                 });
-            },
-            (_) => {
-                // if there is an load error redirect to home page
-                this.props.history.push('/');
             }
         );
     }

src/pages/AuthenticationPage/AuthenticationPage.test.js

@@ -1,7 +1,6 @@
 import React from 'react';
 import AuthenticationPage from './AuthenticationPage';
 import {shallow} from 'enzyme';
-import {token} from "../../utils/TokenHandler";
 
 describe('<AuthenticationPage/>', function () {
     it('renders without crashing ', function () {
@@ -26,7 +25,8 @@ describe('<AuthenticationPage/>', function () {
     it('test fail authenticate', function () {
         const events = mockKeyPress();
 
-        token.refreshAPIToken = jest.fn().mockImplementation((callback, force, pwd) => {
+        const helpers = require('../../utils/Api');
+        helpers.refreshAPIToken = jest.fn().mockImplementation((callback, force, pwd) => {
             callback('there was an error')
         });
 
@@ -41,7 +41,8 @@ describe('<AuthenticationPage/>', function () {
         const events = mockKeyPress();
         const func = jest.fn()
 
-        token.refreshAPIToken = jest.fn().mockImplementation((callback, force, pwd) => {
+        const helpers = require('../../utils/Api');
+        helpers.refreshAPIToken = jest.fn().mockImplementation((callback, force, pwd) => {
             callback('')
         });
 

src/pages/AuthenticationPage/AuthenticationPage.tsx

@@ -2,7 +2,7 @@ import React from 'react';
 import {Button} from '../../elements/GPElements/Button';
 import style from './AuthenticationPage.module.css';
 import {addKeyHandler, removeKeyHandler} from '../../utils/ShortkeyHandler';
-import {token} from '../../utils/TokenHandler';
+import {refreshAPIToken} from '../../utils/Api';
 import {faTimes} from '@fortawesome/free-solid-svg-icons';
 import {FontAwesomeIcon} from '@fortawesome/react-fontawesome';
 
@@ -76,7 +76,7 @@ class AuthenticationPage extends React.Component<Props, state> {
      * request a new token and check if pwd was valid
      */
     authenticate(): void {
-        token.refreshAPIToken(
+        refreshAPIToken(
             (error) => {
                 if (error !== '') {
                     this.setState({wrongPWDInfo: true});

src/pages/CategoryPage/CategoryView.test.js

@@ -4,9 +4,7 @@ import {CategoryView} from './CategoryView';
 
 describe('<CategoryView/>', function () {
     function instance() {
-        const inst = shallow(<CategoryView match={{params: {id: 10}}} history={{push: jest.fn()}}/>);
+        return shallow(<CategoryView match={{params: {id: 10}}} history={{push: jest.fn()}}/>);
-        inst.setState({loaded: true});
-        return inst;
     }
 
     it('renders without crashing ', function () {

src/pages/CategoryPage/CategoryView.tsx

@@ -10,14 +10,12 @@ import Tag from '../../elements/Tag/Tag';
 import {DefaultTags, GeneralSuccess} from '../../types/GeneralTypes';
 import {Button} from '../../elements/GPElements/Button';
 import SubmitPopup from '../../elements/Popups/SubmitPopup/SubmitPopup';
-import {Spinner} from 'react-bootstrap';
 
 interface CategoryViewProps extends RouteComponentProps<{id: string}> {}
 
 interface CategoryViewState {
     loaded: boolean;
     submitForceDelete: boolean;
-    TagName: string;
 }
 
 /**
@@ -31,8 +29,7 @@ export class CategoryView extends React.Component<CategoryViewProps, CategoryVie
 
         this.state = {
             loaded: false,
-            submitForceDelete: false,
+            submitForceDelete: false
-            TagName: ''
         };
     }
 
@@ -53,13 +50,9 @@ export class CategoryView extends React.Component<CategoryViewProps, CategoryVie
     }
 
     render(): JSX.Element {
-        if (!this.state.loaded) {
-            return <Spinner animation='border' />;
-        }
-
         return (
             <>
-                <PageTitle title={this.state.TagName} subtitle={this.videodata.length + ' Videos'} />
+                <PageTitle title='Categories' subtitle={this.videodata.length + ' Videos'} />
 
                 <SideBar>
                     <SideBarTitle>Default Tags:</SideBarTitle>
@@ -112,18 +105,10 @@ export class CategoryView extends React.Component<CategoryViewProps, CategoryVie
      * @param id tagid
      */
     private fetchVideoData(id: number): void {
-        callAPI(
+        callAPI<VideoTypes.VideoUnloadedType[]>(APINode.Video, {action: 'getMovies', tag: id}, (result) => {
-            APINode.Video,
+            this.videodata = result;
-            {action: 'getMovies', Tag: id},
+            this.setState({loaded: true});
-            (result: {Videos: VideoTypes.VideoUnloadedType[]; TagName: string}) => {
+        });
-                this.videodata = result.Videos;
-                this.setState({loaded: true, TagName: result.TagName});
-            },
-            (_) => {
-                // if there is an load error redirect to home page
-                this.props.history.push('/');
-            }
-        );
     }
 
     /**

src/pages/CategoryPage/TagView.test.js

@@ -8,6 +8,13 @@ describe('<TagView/>', function () {
         wrapper.unmount();
     });
 
+    it('test Tag insertion', function () {
+        const wrapper = shallow(<TagView/>);
+        wrapper.setState({loadedtags: [{tag_name: 'test', tag_id: 42}]});
+
+        expect(wrapper.find('TagPreview')).toHaveLength(1);
+    });
+
     it('test new tag popup', function () {
         const wrapper = shallow(<TagView/>);
 

src/pages/CategoryPage/TagView.tsx

@@ -1,5 +1,6 @@
 import {TagType} from '../../types/VideoTypes';
 import React from 'react';
+import videocontainerstyle from '../../elements/VideoContainer/VideoContainer.module.css';
 import {Link} from 'react-router-dom';
 import {TagPreview} from '../../elements/Preview/Preview';
 import {APINode, callAPI} from '../../utils/Api';
@@ -8,7 +9,6 @@ import SideBar, {SideBarTitle} from '../../elements/SideBar/SideBar';
 import Tag from '../../elements/Tag/Tag';
 import {DefaultTags} from '../../types/GeneralTypes';
 import NewTagPopup from '../../elements/Popups/NewTagPopup/NewTagPopup';
-import DynamicContentContainer from '../../elements/DynamicContentContainer/DynamicContentContainer';
 
 interface TagViewState {
     loadedtags: TagType[];
@@ -53,15 +53,15 @@ class TagView extends React.Component<Props, TagViewState> {
                         Add a new Tag!
                     </button>
                 </SideBar>
-                <DynamicContentContainer
+                <div className={videocontainerstyle.maincontent}>
-                    data={this.state.loadedtags}
+                    {this.state.loadedtags
-                    renderElement={(m): JSX.Element => (
+                        ? this.state.loadedtags.map((m) => (
-                        <Link to={'/categories/' + m.TagId} key={m.TagId}>
+                              <Link to={'/categories/' + m.TagId} key={m.TagId}>
-                            <TagPreview name={m.TagName} />
+                                  <TagPreview name={m.TagName} />
-                        </Link>
+                              </Link>
-                    )}
+                          ))
-                    initialLoadNr={20}
+                        : 'loading'}
-                />
+                </div>
                 {this.handlePopups()}
             </>
         );

src/pages/HomePage/HomePage.module.css

@@ -7,61 +7,3 @@
     float: right;
     margin-top: 25px;
 }
-
-.sortbyLabel {
-    color: grey;
-    margin-right: 5px;
-    margin-left: 25px;
-}
-
-/* Style The Dropdown Button */
-.dropbtn {
-    display: flex;
-    justify-content: center;
-    align-items: center;
-    flex-direction: row;
-    height: 100%;
-    cursor: pointer;
-    color: white;
-    text-align: center;
-}
-
-/* The container <div> - needed to position the dropdown content */
-.dropdown {
-    position: relative;
-    display: inline-block;
-}
-
-/* Dropdown Content (Hidden by Default) */
-.dropdownContent {
-    display: none;
-    position: absolute;
-    background-color: #f9f9f9;
-    min-width: 160px;
-    box-shadow: 0px 8px 16px 0px rgba(0,0,0,0.2);
-    z-index: 1;
-}
-
-/* Links inside the dropdown */
-.dropdownContent span {
-    color: black;
-    padding: 12px 16px;
-    text-decoration: none;
-    display: block;
-    cursor: pointer;
-}
-
-/* Change color of dropdown links on hover */
-.dropdownContent span:hover {
-    background-color: #f1f1f1;
-}
-
-/* Show the dropdown menu on hover */
-.dropdown:hover .dropdownContent {
-    display: block;
-}
-
-/* Change the background color of the dropdown button when the dropdown content is shown */
-.dropdown:hover .dropbtn {
-    background-color: #3574fe;
-}

src/pages/HomePage/HomePage.test.js

@@ -1,10 +1,8 @@
 import {shallow} from 'enzyme';
 import React from 'react';
-import {HomePage, SortBy} from './HomePage';
+import {HomePage} from './HomePage';
 import VideoContainer from '../../elements/VideoContainer/VideoContainer';
 import {SearchHandling} from './SearchHandling';
-import exp from "constants";
-import {DefaultTags} from "../../types/GeneralTypes";
 
 describe('<HomePage/>', function () {
     it('renders without crashing ', function () {
@@ -12,6 +10,21 @@ describe('<HomePage/>', function () {
         wrapper.unmount();
     });
 
+    it('test data insertion', function () {
+        const wrapper = shallow(<HomePage/>);
+
+        expect(wrapper.find('VideoContainer')).toHaveLength(0);
+
+        wrapper.setState({
+            data: [
+                {}, {}
+            ]
+        });
+
+        // there shoud be loaded the Videocontainer element into dom after fetching videos correctly
+        expect(wrapper.find('VideoContainer')).toHaveLength(1);
+    });
+
     it('test title and nr insertions', function () {
         const wrapper = shallow(<HomePage/>);
 
@@ -25,6 +38,23 @@ describe('<HomePage/>', function () {
         expect(wrapper.find('PageTitle').props().subtitle).toBe('testsubtitle - 42');
     });
 
+    it('test search field', done => {
+        global.fetch = global.prepareFetchApi([{}, {}]);
+
+        const wrapper = shallow(<HomePage/>);
+
+        wrapper.find('[data-testid="searchtextfield"]').simulate('change', {target: {value: 'testvalue'}});
+        wrapper.find('[data-testid="searchbtnsubmit"]').simulate('click');
+
+        process.nextTick(() => {
+            // state to be set correctly with response
+            expect(wrapper.state().selectionnr).toBe(2);
+
+            global.fetch.mockClear();
+            done();
+        });
+    });
+
     it('test form submit', () => {
         const func = jest.fn();
         const wrapper = shallow(<HomePage/>);
@@ -57,7 +87,7 @@ describe('<HomePage/>', function () {
     });
 
     it('test tag click', done => {
-        global.fetch = prepareFetchApi({Videos: ['test1', 'test2'], TagName: 'all'});
+        global.fetch = prepareFetchApi(['test1', 'test2']);
 
         const wrapper = shallow(<HomePage/>);
 
@@ -85,20 +115,6 @@ describe('<HomePage/>', function () {
 
         testBtn(tags.first());
     });
-
-    it('test sortby type change', function () {
-        const wrapper = shallow(<HomePage/>);
-
-        // expect those default values
-        expect(wrapper.state().sortby).toBe('Date Added');
-        expect(wrapper.instance().sortState).toBe(SortBy.date);
-        expect(wrapper.instance().tagState).toBe(DefaultTags.all);
-
-        wrapper.instance().onDropDownItemClick(SortBy.name, 'namesort');
-
-        expect(wrapper.state().sortby).toBe('namesort');
-        expect(wrapper.instance().sortState).toBe(SortBy.name);
-    });
 });
 
 describe('<SearchHandling/>', () => {

src/pages/HomePage/HomePage.tsx

@@ -11,17 +11,6 @@ import {RouteComponentProps} from 'react-router';
 import SearchHandling from './SearchHandling';
 import {VideoTypes} from '../../types/ApiTypes';
 import {DefaultTags} from '../../types/GeneralTypes';
-import {FontAwesomeIcon} from '@fortawesome/react-fontawesome';
-import {faSortDown} from '@fortawesome/free-solid-svg-icons';
-
-// eslint-disable-next-line no-shadow
-export enum SortBy {
-    date,
-    likes,
-    random,
-    name,
-    length
-}
 
 interface Props extends RouteComponentProps {}
 
@@ -30,7 +19,6 @@ interface state {
     subtitle: string;
     data: VideoTypes.VideoUnloadedType[];
     selectionnr: number;
-    sortby: string;
 }
 
 /**
@@ -54,17 +42,13 @@ export class HomePage extends React.Component<Props, state> {
             },
             subtitle: 'All Videos',
             data: [],
-            selectionnr: 0,
+            selectionnr: 0
-            sortby: 'Date Added'
         };
     }
 
-    sortState = SortBy.date;
-    tagState = DefaultTags.all;
-
     componentDidMount(): void {
         // initial get of all videos
-        this.fetchVideoData();
+        this.fetchVideoData(DefaultTags.all.TagId);
         this.fetchStartData();
     }
 
@@ -74,17 +58,16 @@ export class HomePage extends React.Component<Props, state> {
      *
      * @param tag tag to fetch videos
      */
-    fetchVideoData(): void {
+    fetchVideoData(tag: number): void {
-        callAPI(
+        callAPI(APINode.Video, {action: 'getMovies', tag: tag}, (result: VideoTypes.VideoUnloadedType[]) => {
-            APINode.Video,
+            this.setState({
-            {action: 'getMovies', Tag: this.tagState.TagId, Sort: this.sortState},
+                data: []
-            (result: {Videos: VideoTypes.VideoUnloadedType[]; TagName: string}) => {
+            });
-                this.setState({
+            this.setState({
-                    data: result.Videos,
+                data: result,
-                    selectionnr: result.Videos.length
+                selectionnr: result.length
-                });
+            });
-            }
+        });
-        );
     }
 
     /**
@@ -148,71 +131,39 @@ export class HomePage extends React.Component<Props, state> {
                             <Tag
                                 tagInfo={{TagName: 'All', TagId: DefaultTags.all.TagId}}
                                 onclick={(): void => {
-                                    this.tagState = DefaultTags.all;
+                                    this.fetchVideoData(DefaultTags.all.TagId);
-                                    this.fetchVideoData();
                                     this.setState({subtitle: 'All Videos'});
                                 }}
                             />
                             <Tag
                                 tagInfo={{TagName: 'Full Hd', TagId: DefaultTags.fullhd.TagId}}
                                 onclick={(): void => {
-                                    this.tagState = DefaultTags.fullhd;
+                                    this.fetchVideoData(DefaultTags.fullhd.TagId);
-                                    this.fetchVideoData();
                                     this.setState({subtitle: 'Full Hd Videos'});
                                 }}
                             />
                             <Tag
                                 tagInfo={{TagName: 'Low Quality', TagId: DefaultTags.lowq.TagId}}
                                 onclick={(): void => {
-                                    this.tagState = DefaultTags.lowq;
+                                    this.fetchVideoData(DefaultTags.lowq.TagId);
-                                    this.fetchVideoData();
                                     this.setState({subtitle: 'Low Quality Videos'});
                                 }}
                             />
                             <Tag
                                 tagInfo={{TagName: 'HD', TagId: DefaultTags.hd.TagId}}
                                 onclick={(): void => {
-                                    this.tagState = DefaultTags.hd;
+                                    this.fetchVideoData(DefaultTags.hd.TagId);
-                                    this.fetchVideoData();
                                     this.setState({subtitle: 'HD Videos'});
                                 }}
                             />
                         </SideBar>
-                        <div>
+                        {this.state.data.length !== 0 ? <VideoContainer data={this.state.data} /> : <div>No Data found!</div>}
-                            <span className={style.sortbyLabel}>Sort By: </span>
-                            <div className={style.dropdown}>
-                                <span className={style.dropbtn}>
-                                    <span>{this.state.sortby}</span>
-                                    <FontAwesomeIcon style={{marginLeft: 3, paddingBottom: 3}} icon={faSortDown} size='1x' />
-                                </span>
-                                <div className={style.dropdownContent}>
-                                    <span onClick={(): void => this.onDropDownItemClick(SortBy.date, 'Date Added')}>Date Added</span>
-                                    <span onClick={(): void => this.onDropDownItemClick(SortBy.likes, 'Most likes')}>Most likes</span>
-                                    <span onClick={(): void => this.onDropDownItemClick(SortBy.random, 'Random')}>Random</span>
-                                    <span onClick={(): void => this.onDropDownItemClick(SortBy.name, 'Name')}>Name</span>
-                                    <span onClick={(): void => this.onDropDownItemClick(SortBy.length, 'Length')}>Length</span>
-                                </div>
-                            </div>
-                        </div>
-
-                        <VideoContainer data={this.state.data} />
                         <div className={style.rightinfo} />
                     </Route>
                 </Switch>
             </>
         );
     }
-
-    /**
-     * click handler for sortby dropdown item click
-     * @param type type of sort action
-     * @param name new header title
-     */
-    onDropDownItemClick(type: SortBy, name: string): void {
-        this.sortState = type;
-        this.setState({sortby: name});
-        this.fetchVideoData();
-    }
 }
 
 export default withRouter(HomePage);

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

@@ -15,15 +15,14 @@ import ActorTile from '../../elements/ActorTile/ActorTile';
 import {withRouter} from 'react-router-dom';
 import {APINode, callAPI} from '../../utils/Api';
 import {RouteComponentProps} from 'react-router';
-import {DefaultPlyrOptions, GeneralSuccess} from '../../types/GeneralTypes';
+import {GeneralSuccess} from '../../types/GeneralTypes';
 import {ActorType, TagType} from '../../types/VideoTypes';
 import PlyrJS from 'plyr';
 import {Button} from '../../elements/GPElements/Button';
 import {VideoTypes} from '../../types/ApiTypes';
-import QuickActionPop, {ContextItem} from '../../elements/QuickActionPop/QuickActionPop';
 import GlobalInfos from '../../utils/GlobalInfos';
 
-interface Props extends RouteComponentProps<{id: string}> {}
+interface myprops extends RouteComponentProps<{id: string}> {}
 
 interface mystate {
     sources?: PlyrJS.SourceInfo;
@@ -37,23 +36,36 @@ interface mystate {
     popupvisible: boolean;
     actorpopupvisible: boolean;
     actors: ActorType[];
-    tagContextMenu: boolean;
 }
 
 /**
  * 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 React.Component<Props, mystate> {
+export class Player extends React.Component<myprops, mystate> {
-    private contextpos = {x: 0, y: 0, tagid: -1};
+    options: PlyrJS.Options = {
+        controls: [
+            'play-large', // The large play button in the center
+            'play', // Play/pause playback
+            'progress', // The progress bar and scrubber for playback and buffering
+            'current-time', // The current time of playback
+            'duration', // The full duration of the media
+            'mute', // Toggle mute
+            'volume', // Volume control
+            'captions', // Toggle captions
+            'settings', // Settings menu
+            'airplay', // Airplay (currently Safari only)
+            'download', // Show a download button with a link to either the current source or a custom URL you specify in your options
+            'fullscreen' // Toggle fullscreen
+        ]
+    };
 
-    constructor(props: Props) {
+    constructor(props: myprops) {
         super(props);
 
         this.state = {
             movieId: -1,
             movieName: '',
-            tagContextMenu: false,
             likes: 0,
             quality: 0,
             length: 0,
@@ -65,7 +77,6 @@ export class Player extends React.Component<Props, mystate> {
         };
 
         this.quickAddTag = this.quickAddTag.bind(this);
-        this.deleteTag = this.deleteTag.bind(this);
     }
 
     componentDidMount(): void {
@@ -83,7 +94,7 @@ export class Player extends React.Component<Props, mystate> {
                 <div className={style.videowrapper}>
                     {/* video component is added here */}
                     {this.state.sources ? (
-                        <Plyr style={plyrstyle} source={this.state.sources} options={DefaultPlyrOptions} />
+                        <Plyr style={plyrstyle} source={this.state.sources} options={this.options} />
                     ) : (
                         <div>not loaded yet</div>
                     )}
@@ -139,14 +150,7 @@ export class Player extends React.Component<Props, mystate> {
                 <Line />
                 <SideBarTitle>Tags:</SideBarTitle>
                 {this.state.tags.map((m: TagType) => (
-                    <Tag
+                    <Tag key={m.TagId} tagInfo={m} />
-                        key={m.TagId}
-                        tagInfo={m}
-                        onContextMenu={(pos): void => {
-                            this.setState({tagContextMenu: true});
-                            this.contextpos = {...pos, tagid: m.TagId};
-                        }}
-                    />
                 ))}
                 <Line />
                 <SideBarTitle>Tag Quickadd:</SideBarTitle>
@@ -209,7 +213,6 @@ export class Player extends React.Component<Props, mystate> {
                         movieId={this.state.movieId}
                     />
                 ) : null}
-                {this.renderContextMenu()}
             </>
         );
     }
@@ -276,15 +279,17 @@ export class Player extends React.Component<Props, mystate> {
             APINode.Video,
             {action: 'loadVideo', MovieId: parseInt(this.props.match.params.id, 10)},
             (result: VideoTypes.loadVideoType) => {
+                console.log(result);
+                console.log(process.env.REACT_APP_CUST_BACK_DOMAIN);
                 this.setState({
                     sources: {
                         type: 'video',
                         sources: [
                             {
                                 src:
-                                    (process.env.REACT_APP_CUST_BACK_DOMAIN ? process.env.REACT_APP_CUST_BACK_DOMAIN : '') +
+                                    (process.env.REACT_APP_CUST_BACK_DOMAIN
-                                    GlobalInfos.getVideoPath() +
+                                        ? process.env.REACT_APP_CUST_BACK_DOMAIN
-                                    result.MovieUrl,
+                                        : GlobalInfos.getVideoPath()) + result.MovieUrl,
                                 type: 'video/mp4',
                                 size: 1080
                             }
@@ -300,10 +305,6 @@ export class Player extends React.Component<Props, mystate> {
                     suggesttag: result.SuggestedTag,
                     actors: result.Actors
                 });
-            },
-            (_) => {
-                // if there is an load error redirect to home page
-                this.props.history.push('/');
             }
         );
     }
@@ -369,51 +370,6 @@ export class Player extends React.Component<Props, mystate> {
             }
         );
     }
-
-    /**
-     * render the Tag context menu
-     */
-    private renderContextMenu(): JSX.Element {
-        if (this.state.tagContextMenu) {
-            return (
-                <QuickActionPop onHide={(): void => this.setState({tagContextMenu: false})} position={this.contextpos}>
-                    <ContextItem title='Delete' onClick={(): void => this.deleteTag(this.contextpos.tagid)} />
-                </QuickActionPop>
-            );
-        } else {
-            return <></>;
-        }
-    }
-
-    /**
-     * delete a tag from the current video
-     */
-    private deleteTag(tag_id: number): void {
-        callAPI<GeneralSuccess>(
-            APINode.Tags,
-            {action: 'deleteVideoTag', video_id: this.props.match.params.id, tag_id: tag_id},
-            (res) => {
-                if (res.result !== 'success') {
-                    console.log('deletion errored!');
-
-                    this.setState({tagContextMenu: false});
-                } else {
-                    // check if tag has already been added
-                    const tagIndex = this.state.tags
-                        .map(function (e: TagType) {
-                            return e.TagId;
-                        })
-                        .indexOf(tag_id);
-
-                    // delete tag from array
-                    const newTagArray = this.state.tags;
-                    newTagArray.splice(tagIndex, 1);
-
-                    this.setState({tags: newTagArray, tagContextMenu: false});
-                }
-            }
-        );
-    }
 }
 
 export default withRouter(Player);

src/pages/RandomPage/RandomPage.tsx

@@ -23,8 +23,6 @@ interface GetRandomMoviesType {
  * Randompage shuffles random viedeopreviews and provides a shuffle btn
  */
 class RandomPage extends React.Component<{}, state> {
-    readonly LoadNR = 3;
-
     constructor(props: {}) {
         super(props);
 
@@ -39,7 +37,7 @@ class RandomPage extends React.Component<{}, state> {
     componentDidMount(): void {
         addKeyHandler(this.keypress);
 
-        this.loadShuffledvideos(this.LoadNR);
+        this.loadShuffledvideos(4);
     }
 
     componentWillUnmount(): void {
@@ -77,7 +75,7 @@ class RandomPage extends React.Component<{}, state> {
      * click handler for shuffle btn
      */
     shuffleclick(): void {
-        this.loadShuffledvideos(this.LoadNR);
+        this.loadShuffledvideos(4);
     }
 
     /**
@@ -85,7 +83,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/pages/SettingsPage/GeneralSettings.tsx

@@ -11,8 +11,7 @@ import {SettingsTypes} from '../../types/ApiTypes';
 import {GeneralSuccess} from '../../types/GeneralTypes';
 
 interface state {
-    generalSettings: SettingsTypes.SettingsType;
+    generalSettings: SettingsTypes.loadGeneralSettingsType;
-    sizes: SettingsTypes.SizesType;
 }
 
 interface Props {}
@@ -28,18 +27,16 @@ class GeneralSettings extends React.Component<Props, state> {
         this.state = {
             generalSettings: {
                 DarkMode: true,
+                DBSize: 0,
+                DifferentTags: 0,
                 EpisodePath: '',
                 MediacenterName: '',
                 Password: '',
                 PasswordEnabled: false,
-                TMDBGrabbing: false,
-                VideoPath: ''
-            },
-            sizes: {
-                DBSize: 0,
-                DifferentTags: 0,
                 TagsAdded: 0,
-                VideoNr: 0
+                TMDBGrabbing: false,
+                VideoNr: 0,
+                VideoPath: ''
             }
         };
     }
@@ -55,25 +52,25 @@ class GeneralSettings extends React.Component<Props, state> {
                 <div className={style.infoheader}>
                     <InfoHeaderItem
                         backColor='lightblue'
-                        text={this.state.sizes.VideoNr}
+                        text={this.state.generalSettings.VideoNr}
                         subtext='Videos in Gravity'
                         icon={faArchive}
                     />
                     <InfoHeaderItem
                         backColor='yellow'
-                        text={this.state.sizes.DBSize + ' MB'}
+                        text={this.state.generalSettings.DBSize + ' MB'}
                         subtext='Database size'
                         icon={faRulerVertical}
                     />
                     <InfoHeaderItem
                         backColor='green'
-                        text={this.state.sizes.DifferentTags}
+                        text={this.state.generalSettings.DifferentTags}
                         subtext='different Tags'
                         icon={faAddressCard}
                     />
                     <InfoHeaderItem
                         backColor='orange'
-                        text={this.state.sizes.TagsAdded}
+                        text={this.state.generalSettings.TagsAdded}
                         subtext='tags added'
                         icon={faBalanceScaleLeft}
                     />
@@ -213,16 +210,8 @@ class GeneralSettings extends React.Component<Props, state> {
      * inital load of already specified settings from backend
      */
     loadSettings(): void {
-        interface SettingsResponseType {
+        callAPI(APINode.Settings, {action: 'loadGeneralSettings'}, (result: SettingsTypes.loadGeneralSettingsType) => {
-            Settings: SettingsTypes.SettingsType;
+            this.setState({generalSettings: result});
-            Sizes: SettingsTypes.SizesType;
-        }
-
-        callAPI(APINode.Settings, {action: 'loadGeneralSettings'}, (result: SettingsResponseType) => {
-            this.setState({
-                generalSettings: result.Settings,
-                sizes: result.Sizes
-            });
         });
     }
 
@@ -236,12 +225,11 @@ class GeneralSettings extends React.Component<Props, state> {
         }
         settings.DarkMode = GlobalInfos.isDarkTheme();
 
-        console.log(settings);
         callAPI(
             APINode.Settings,
             {
                 action: 'saveGeneralSettings',
-                ...settings
+                Settings: settings
             },
             (result: GeneralSuccess) => {
                 if (result.result) {

src/pages/SettingsPage/MovieSettings.test.js

@@ -1,7 +1,7 @@
 import {shallow} from 'enzyme';
 import React from 'react';
 import MovieSettings from './MovieSettings';
-import {callAPI} from '../../utils/Api';
+import {callAPI} from "../../utils/Api";
 
 describe('<MovieSettings/>', function () {
     it('renders without crashing ', function () {
@@ -23,55 +23,106 @@ describe('<MovieSettings/>', function () {
     });
 
     it('test simulate reindex', function () {
-        callAPIMock({success: true})
+        global.fetch = global.prepareFetchApi({success: true});
         const wrapper = shallow(<MovieSettings/>);
 
         wrapper.find('button').findWhere(e => e.text() === 'Reindex Movie' && e.type() === 'button').simulate('click');
 
         // initial send of reindex request to server
-        expect(callAPI).toBeCalledTimes(1);
+        expect(global.fetch).toBeCalledTimes(1);
     });
 
-    it('test simulate tvshow reindex', function () {
+    it('test failing reindex start', done => {
-        callAPIMock({success: true})
+        global.fetch = global.prepareFetchApi({success: false});
         const wrapper = shallow(<MovieSettings/>);
 
-        wrapper.find('button').findWhere(e => e.text() === 'TVShow Reindex' && e.type() === 'button').simulate('click');
+        wrapper.find('button').findWhere(e => e.text() === 'Reindex Movie' && e.type() === 'button').simulate('click');
+
+        // initial send of reindex request to server
+        expect(global.fetch).toBeCalledTimes(1);
+
+        process.nextTick(() => {
+            // reindex already running --> so disable startbdn
+            expect(wrapper.state()).toMatchObject({startbtnDisabled: true});
+
+            global.fetch.mockClear();
+            done();
+        });
+    });
+
+    it('content available received and in state', () => {
+        const wrapper = shallow(<MovieSettings/>);
+        callAPIMock({
+            ContentAvailable: true,
+            Messages: ['firstline', 'secondline']
+        })
+
+        wrapper.instance().updateStatus();
+
+        expect(wrapper.state()).toMatchObject({
+            text: [
+                'firstline',
+                'secondline'
+            ]
+        });
+    });
+
+    it('test reindex with no content available', () => {
+        callAPIMock({
+            Messages: [],
+            ContentAvailable: false
+        })
+
+        global.clearInterval = jest.fn();
+
+        const wrapper = shallow(<MovieSettings/>);
+        wrapper.instance().updateStatus();
+
+        // expect the refresh interval to be cleared
+        expect(global.clearInterval).toBeCalledTimes(1);
+
+        // expect startbtn to be reenabled
+        expect(wrapper.state()).toMatchObject({startbtnDisabled: false});
+    });
+
+    it('test simulate gravity cleanup', () => {
+        // global.fetch = global.prepareFetchApi('mmi');
+        callAPIMock({})
+        const wrapper = shallow(<MovieSettings/>);
+        wrapper.instance().setState = jest.fn();
+
+        wrapper.find('button').findWhere(e => e.text() === 'Cleanup Gravity' && e.type() === 'button').simulate('click');
 
         // initial send of reindex request to server
         expect(callAPI).toBeCalledTimes(1);
+
+        expect(wrapper.instance().setState).toBeCalledTimes(1);
     });
 
-    it('test handlemessage ', function () {
+    it('expect insertion before existing ones', function () {
-        const wrapper = shallow(<MovieSettings/>);
-        const func = jest.fn((str) => {})
-        wrapper.instance().appendLog = func
-        wrapper.instance().handleMessage('{"Action":"message", "Message":"testmsg"}')
-
-        expect(func).toHaveBeenCalledTimes(1);
-        expect(func).toHaveBeenLastCalledWith('testmsg')
-
-        wrapper.setState({startbtnDisabled: false});
-
-        // expect button to get disabled!
-        wrapper.instance().handleMessage('{"Action":"reindexAction", "Event":"start"}');
-        expect(wrapper.state().startbtnDisabled).toBeTruthy()
-
-        // expect button to get enabled
-        wrapper.instance().handleMessage('{"Action":"reindexAction", "Event":"stop"}');
-        expect(wrapper.state().startbtnDisabled).not.toBeTruthy()
-    });
-
-    it('test appendlog', function () {
         const wrapper = shallow(<MovieSettings/>);
 
-        wrapper.instance().appendLog("testmsg");
+        callAPIMock({
-        expect(wrapper.state().text).toHaveLength(1)
+            ContentAvailable: true,
-        expect(wrapper.state().text[0]).toBe('testmsg')
+            Messages: ['test']
+        })
 
-        wrapper.instance().appendLog("testmsg2");
+        wrapper.instance().updateStatus();
-        expect(wrapper.state().text).toHaveLength(2)
+
-        expect(wrapper.state().text[0]).toBe('testmsg2')
+        expect(wrapper.state()).toMatchObject({
-        expect(wrapper.state().text[1]).toBe('testmsg')
+            text: ['test']
+        });
+
+        // expect an untouched state if we try to add an empty string...
+        callAPIMock({
+            ContentAvailable: true,
+            Messages: ['']
+        })
+
+        wrapper.instance().updateStatus();
+
+        expect(wrapper.state()).toMatchObject({
+            text: ['', 'test']
+        });
     });
 });

src/pages/SettingsPage/MovieSettings.tsx

@@ -2,6 +2,7 @@ import React from 'react';
 import style from './MovieSettings.module.css';
 import {APINode, callAPI} from '../../utils/Api';
 import {GeneralSuccess} from '../../types/GeneralTypes';
+import {SettingsTypes} from '../../types/ApiTypes';
 
 interface state {
     text: string[];
@@ -10,23 +11,13 @@ interface state {
 
 interface Props {}
 
-interface MessageBase {
-    Action: string;
-}
-
-interface TextMessage extends MessageBase {
-    Message: string;
-}
-
-interface ReindexEvent extends MessageBase {
-    Event: string;
-}
-
 /**
  * Component for MovieSettings on Settingspage
  * handles settings concerning to movies in general
  */
 class MovieSettings extends React.Component<Props, state> {
+    myinterval: number = -1;
+
     constructor(props: Props) {
         super(props);
 
@@ -37,64 +28,12 @@ class MovieSettings extends React.Component<Props, state> {
     }
 
     componentDidMount(): void {
-        // expectingMessage is set to true
+        this.myinterval = window.setInterval(this.updateStatus, 1000);
-        this.dial();
     }
 
-    dial(): void {
+    componentWillUnmount(): void {
-        console.log('trying to connect...');
+        if (this.myinterval !== -1) {
-        // check which ws protocol we need
+            clearInterval(this.myinterval);
-        const wsProt = window.location.protocol === 'http:' ? 'ws' : 'wss';
-
-        const conn = new WebSocket(`${wsProt}://${window.location.host}/subscribe`);
-        conn.addEventListener('close', (ev) => {
-            this.appendLog(`WebSocket Disconnected code: ${ev.code}, reason: ${ev.reason}`, true);
-            if (ev.code !== 1001) {
-                this.appendLog('Reconnecting in 1s', true);
-                setTimeout((): void => this.dial(), 1000);
-            }
-        });
-        conn.addEventListener('open', (_ev) => {
-            console.info('websocket connected');
-        });
-
-        // This is where we handle messages received.
-        conn.addEventListener('message', (ev) => {
-            if (typeof ev.data !== 'string') {
-                console.error('unexpected message type', typeof ev.data);
-                return;
-            }
-            this.handleMessage(ev.data);
-        });
-    }
-
-    handleMessage(message: string): void {
-        const obj: MessageBase = JSON.parse(message);
-
-        if (obj.Action === 'message') {
-            const msg = obj as TextMessage;
-            this.appendLog(msg.Message);
-        } else if (obj.Action === 'reindexAction') {
-            const msg = obj as ReindexEvent;
-            if (msg.Event === 'start') {
-                this.setState({startbtnDisabled: true});
-            } else if (msg.Event === 'stop') {
-                this.setState({startbtnDisabled: false});
-            }
-        } else {
-            console.error('unexpected response from server: ' + message);
-        }
-    }
-
-    // appendLog appends the passed text to messageLog.
-    appendLog(text: string, error?: boolean): void {
-        this.setState({
-            // insert a string for each line
-            text: [text, ...this.state.text]
-        });
-
-        if (error) {
-            console.log('heyy err');
         }
     }
 
@@ -112,9 +51,9 @@ class MovieSettings extends React.Component<Props, state> {
                 <button
                     className='btn btn-warning'
                     onClick={(): void => {
-                        this.startTVShowReindex();
+                        this.cleanupGravity();
                     }}>
-                    TVShow Reindex
+                    Cleanup Gravity
                 </button>
                 <div className={style.indextextarea}>
                     {this.state.text.map((m) => (
@@ -131,15 +70,44 @@ class MovieSettings extends React.Component<Props, state> {
      * starts the reindex process of the videos in the specified folder
      */
     startReindex(): void {
-        this.setState({text: []});
         // clear output text before start
+        this.setState({text: [], startbtnDisabled: true});
+
         callAPI(APINode.Settings, {action: 'startReindex'}, (result: GeneralSuccess): void => {
+            console.log(result);
             if (result.result === 'success') {
                 console.log('started successfully');
+            } else {
+                console.log('error, reindex already running');
+                this.setState({startbtnDisabled: true});
             }
         });
+
+        if (this.myinterval !== -1) {
+            clearInterval(this.myinterval);
+        }
+        this.myinterval = window.setInterval(this.updateStatus, 1000);
     }
 
+    /**
+     * This interval function reloads the current status of reindexing from backend
+     */
+    updateStatus = (): void => {
+        callAPI(APINode.Settings, {action: 'getStatusMessage'}, (result: SettingsTypes.getStatusMessageType) => {
+            this.setState({
+                // insert a string for each line
+                text: [...result.Messages, ...this.state.text]
+            });
+            // todo 2020-07-4: scroll to bottom of div here
+            if (!result.ContentAvailable) {
+                // clear refresh interval if no content available
+                clearInterval(this.myinterval);
+
+                this.setState({startbtnDisabled: false});
+            }
+        });
+    };
+
     /**
      * send request to cleanup db gravity
      */
@@ -150,15 +118,6 @@ class MovieSettings extends React.Component<Props, state> {
             });
         });
     }
-
-    private startTVShowReindex(): void {
-        this.setState({text: []});
-        callAPI(APINode.Settings, {action: 'startTVShowReindex'}, (result: GeneralSuccess): void => {
-            if (result.result === 'success') {
-                console.log('started successfully');
-            }
-        });
-    }
 }
 
 export default MovieSettings;

src/pages/SettingsPage/SettingsPage.tsx

@@ -22,11 +22,9 @@ class SettingsPage extends React.Component {
                     <NavLink to='/settings/movies'>
                         <div className={style.SettingSidebarElement}>Movies</div>
                     </NavLink>
-                    {GlobalInfos.isTVShowEnabled() ? (
+                    <NavLink to='/settings/tv'>
-                        <NavLink to='/settings/tv'>
+                        <div className={style.SettingSidebarElement}>TV Shows</div>
-                            <div className={style.SettingSidebarElement}>TV Shows</div>
+                    </NavLink>
-                        </NavLink>
-                    ) : null}
                 </div>
                 <div className={style.SettingsContent}>
                     <Switch>
@@ -36,11 +34,9 @@ class SettingsPage extends React.Component {
                         <Route path='/settings/movies'>
                             <MovieSettings />
                         </Route>
-                        {GlobalInfos.isTVShowEnabled() ? (
+                        <Route path='/settings/tv'>
-                            <Route path='/settings/tv'>
+                            <span />
-                                <span />
+                        </Route>
-                            </Route>
-                        ) : null}
                         <Route path='/settings'>
                             <Redirect to='/settings/general' />
                         </Route>

src/pages/TVShowPage/EpisodePage.test.js

@@ -1,43 +0,0 @@
-import {shallow} from 'enzyme';
-import React from 'react';
-import {EpisodePage, EpisodeTile} from './EpisodePage';
-
-describe('<EpisodePage/>', function () {
-    it('renders without crashing ', function () {
-        const wrapper = shallow(<EpisodePage  history={{}} location={{}} match={{params: {id: 42}}}/>);
-        wrapper.unmount();
-    });
-
-    it('content showing when loaded', function () {
-        const wrapper = shallow(<EpisodePage  history={{}} location={{}} match={{params: {id: 42}}}/>);
-
-        expect(wrapper.find('DynamicContentContainer')).toHaveLength(0)
-
-        wrapper.setState({loaded: true});
-
-        expect(wrapper.find('DynamicContentContainer')).toHaveLength(1)
-    });
-});
-
-describe('<EpisodeTile/>', () => {
-    it('renders without crashing', function () {
-        const wrapper = shallow(<EpisodeTile  episode={{
-            ID: 0,
-            Name: 'testname',
-            Season: 0,
-            Episode: 0
-        }}/>);
-        wrapper.unmount();
-    });
-
-    it('renders text', function () {
-        const wrapper = shallow(<EpisodeTile  episode={{
-            ID: 0,
-            Name: 'testname',
-            Season: 0,
-            Episode: 0
-        }}/>);
-
-        expect(wrapper.findWhere(e => e.text() === 'testname')).toHaveLength(1)
-    });
-})

src/pages/TVShowPage/EpisodePage.tsx

@@ -1,84 +0,0 @@
-import * as React from 'react';
-import {RouteComponentProps} from 'react-router';
-import {withRouter} from 'react-router-dom';
-import {APINode, callAPI} from '../../utils/Api';
-import {Link} from 'react-router-dom';
-import DynamicContentContainer from '../../elements/DynamicContentContainer/DynamicContentContainer';
-import tileStyle from './EpisodeTile.module.css';
-import GlobalInfos from '../../utils/GlobalInfos';
-import {faPlay} from '@fortawesome/free-solid-svg-icons';
-import {FontAwesomeIcon} from '@fortawesome/react-fontawesome';
-import PageTitle, {Line} from '../../elements/PageTitle/PageTitle';
-import SideBar, {SideBarItem, SideBarTitle} from '../../elements/SideBar/SideBar';
-
-interface Props extends RouteComponentProps<{id: string}> {}
-
-interface State {
-    loaded: boolean;
-}
-
-interface Episode {
-    ID: number;
-    Name: string;
-    Season: number;
-    Episode: number;
-}
-
-export class EpisodePage extends React.Component<Props, State> {
-    episodes: Episode[] = [];
-
-    state = {
-        loaded: false
-    };
-
-    componentDidMount(): void {
-        callAPI(APINode.TVShow, {action: 'getEpisodes', ShowID: parseInt(this.props.match.params.id, 10)}, (episodes: Episode[]) => {
-            this.episodes = episodes;
-            this.setState({loaded: true});
-        });
-    }
-
-    render(): JSX.Element {
-        if (!this.state.loaded) {
-            return <>loading...</>;
-        }
-
-        return (
-            <>
-                <PageTitle title='TV Shows' subtitle='' />
-                <SideBar>
-                    <SideBarTitle>Infos:</SideBarTitle>
-                    <Line />
-                    <SideBarItem>
-                        <b>{this.episodes.length}</b> Episodes Total!
-                    </SideBarItem>
-                </SideBar>
-                <DynamicContentContainer
-                    renderElement={(el): JSX.Element => <EpisodeTile key={el.ID} episode={el} />}
-                    data={this.episodes}
-                    initialLoadNr={-1}
-                />
-            </>
-        );
-    }
-}
-
-export const EpisodeTile = (props: {episode: Episode}): JSX.Element => {
-    const themestyle = GlobalInfos.getThemeStyle();
-    return (
-        <Link to={'/tvplayer/' + props.episode.ID}>
-            <div className={tileStyle.tile + ' ' + themestyle.secbackground + ' ' + themestyle.textcolor}>
-                <FontAwesomeIcon
-                    style={{
-                        marginRight: '10px'
-                    }}
-                    icon={faPlay}
-                    size='1x'
-                />
-                Season: {props.episode.Season} Episode: {props.episode.Episode} {props.episode.Name}
-            </div>
-        </Link>
-    );
-};
-
-export default withRouter(EpisodePage);

src/pages/TVShowPage/EpisodeTile.module.css

@@ -1,15 +0,0 @@
-.tile {
-    margin: 15px;
-    padding-top: 15px;
-    padding-bottom: 15px;
-    width: 50%;
-    padding-left: 15px;
-}
-
-.tile:hover {
-    opacity: 0.7;
-}
-
-.tile:hover svg {
-    color: dodgerblue;
-}

src/pages/TVShowPage/TVPlayer.test.js

@@ -1,10 +0,0 @@
-import {shallow} from 'enzyme';
-import {TVPlayer} from './TVPlayer';
-import React from 'react';
-
-describe('<TVPlayer/>', () => {
-    it('renders without crashing', function () {
-        const wrapper = shallow(<TVPlayer match={{params: {id: 42}}}/>);
-        wrapper.unmount();
-    });
-})

src/pages/TVShowPage/TVPlayer.tsx

@@ -1,101 +0,0 @@
-import * as React from 'react';
-import {RouteComponentProps} from 'react-router';
-import {withRouter} from 'react-router-dom';
-import PageTitle from '../../elements/PageTitle/PageTitle';
-import style from '../Player/Player.module.css';
-import {Plyr} from 'plyr-react';
-import plyrstyle from 'plyr-react/dist/plyr.css';
-import {DefaultPlyrOptions} from '../../types/GeneralTypes';
-import {APINode, callAPI} from '../../utils/Api';
-import GlobalInfos from '../../utils/GlobalInfos';
-import PlyrJS from 'plyr';
-
-interface Props extends RouteComponentProps<{id: string}> {}
-
-interface State {
-    loaded: boolean;
-}
-
-interface EpisodeData {
-    Name: string;
-    Season: number;
-    Episode: number;
-    TVShowID: number;
-    Path: string;
-}
-
-export class TVPlayer extends React.Component<Props, State> {
-    state = {
-        loaded: false
-    };
-
-    data: EpisodeData | null = null;
-
-    componentDidMount(): void {
-        this.loadVideo();
-    }
-
-    loadVideo(): void {
-        callAPI(
-            APINode.TVShow,
-            {
-                action: 'loadEpisode',
-                ID: parseInt(this.props.match.params.id, 10)
-            },
-            (data: EpisodeData) => {
-                console.log(data);
-                this.data = data;
-                this.setState({loaded: true});
-            },
-            (_) => {
-                // if there is an load error redirect to home page
-                this.props.history.push('/');
-            }
-        );
-    }
-
-    assemblePlyrObject(): JSX.Element {
-        if (this.state.loaded && this.data !== null) {
-            const sources: PlyrJS.SourceInfo = {
-                type: 'video',
-                sources: [
-                    {
-                        src:
-                            (process.env.REACT_APP_CUST_BACK_DOMAIN ? process.env.REACT_APP_CUST_BACK_DOMAIN : '') +
-                            GlobalInfos.getTVShowPath() +
-                            this.data.Path,
-                        type: 'video/mp4',
-                        size: 1080
-                    }
-                ],
-                poster: ''
-            };
-
-            return <Plyr style={plyrstyle} source={sources} options={DefaultPlyrOptions} />;
-        } else {
-            return <div>not loaded yet</div>;
-        }
-    }
-
-    render(): JSX.Element {
-        return (
-            <div id='videocontainer'>
-                <PageTitle title='Watch' subtitle='todo' />
-
-                <div className={style.videowrapper}>
-                    {/* video component is added here */}
-                    {this.assemblePlyrObject()}
-                </div>
-                <button className={style.closebutton} onClick={(): void => this.closebtn()}>
-                    Close
-                </button>
-            </div>
-        );
-    }
-
-    private closebtn(): void {
-        this.props.history.goBack();
-    }
-}
-
-export default withRouter(TVPlayer);

src/pages/TVShowPage/TVShowPage.test.js

@@ -1,10 +0,0 @@
-import {shallow} from 'enzyme';
-import {TVShowPage} from './TVShowPage';
-import React from 'react';
-
-describe('<TVShowPage/>', () => {
-    it('renders without crashing', function () {
-        const wrapper = shallow(<TVShowPage />);
-        wrapper.unmount();
-    });
-})

src/pages/TVShowPage/TVShowPage.tsx

@@ -1,83 +0,0 @@
-import React from 'react';
-import Preview from '../../elements/Preview/Preview';
-import {APINode, callAPI, callAPIPlain} from '../../utils/Api';
-import {TVShow} from '../../types/ApiTypes';
-import DynamicContentContainer from '../../elements/DynamicContentContainer/DynamicContentContainer';
-import {Route, Switch, useRouteMatch} from 'react-router-dom';
-import EpisodePage from './EpisodePage';
-import PageTitle, {Line} from '../../elements/PageTitle/PageTitle';
-import SideBar, {SideBarItem, SideBarTitle} from '../../elements/SideBar/SideBar';
-
-interface State {
-    loading: boolean;
-}
-
-interface Props {}
-
-export class TVShowPage extends React.Component<Props, State> {
-    state = {
-        loading: true
-    };
-
-    data: TVShow.TVshowType[] = [];
-
-    componentDidMount(): void {
-        callAPI(APINode.TVShow, {action: 'getTVShows'}, (resp: TVShow.TVshowType[]) => {
-            this.data = resp;
-            this.setState({loading: false});
-        });
-    }
-
-    render(): JSX.Element {
-        return (
-            <>
-                <PageTitle title='TV Shows' subtitle='' />
-                <SideBar>
-                    <SideBarTitle>Infos:</SideBarTitle>
-                    <Line />
-                    <SideBarItem>
-                        <b>{this.data.length}</b> TV-Shows Total!
-                    </SideBarItem>
-                </SideBar>
-                <div>
-                    <DynamicContentContainer
-                        renderElement={(elem): JSX.Element => (
-                            <Preview
-                                key={elem.Id}
-                                name={elem.Name}
-                                picLoader={(callback: (pic: string) => void): void => {
-                                    callAPIPlain(
-                                        APINode.TVShow,
-                                        {
-                                            action: 'readThumbnail',
-                                            Id: elem.Id
-                                        },
-                                        (result) => callback(result)
-                                    );
-                                }}
-                                linkPath={'/tvshows/' + elem.Id}
-                            />
-                        )}
-                        data={this.state.loading ? [] : this.data}
-                        initialLoadNr={20}
-                    />
-                </div>
-            </>
-        );
-    }
-}
-
-export default function (): JSX.Element {
-    let match = useRouteMatch();
-
-    return (
-        <Switch>
-            <Route path={`${match.path}/:id`}>
-                <EpisodePage />
-            </Route>
-            <Route path={match.path}>
-                <TVShowPage />
-            </Route>
-        </Switch>
-    );
-}

src/setupTests.js

@@ -6,8 +6,7 @@ import '@testing-library/jest-dom/extend-expect';
 
 import {configure} from 'enzyme';
 import Adapter from 'enzyme-adapter-react-16';
-import {CookieTokenStore} from "./utils/TokenStore/CookieTokenStore";
+import GlobalInfos from './utils/GlobalInfos';
-import {token} from "./utils/TokenHandler";
 
 configure({adapter: new Adapter()});
 
@@ -45,7 +44,6 @@ global.callAPIMock = (resonse) => {
 global.beforeEach(() => {
     // empty fetch response implementation for each test
     global.fetch = prepareFetchApi({});
-    token.init(new CookieTokenStore());
     // todo with callAPIMock
 });
 

src/types/ApiTypes.ts

@@ -35,11 +35,9 @@ export namespace SettingsTypes {
         Password: boolean;
         MediacenterName: string;
         VideoPath: string;
-        TVShowPath: string;
-        TVShowEnabled: boolean;
     }
 
-    export interface SettingsType {
+    export interface loadGeneralSettingsType {
         VideoPath: string;
         EpisodePath: string;
         MediacenterName: string;
@@ -47,9 +45,7 @@ export namespace SettingsTypes {
         PasswordEnabled: boolean;
         TMDBGrabbing: boolean;
         DarkMode: boolean;
-    }
 
-    export interface SizesType {
         VideoNr: number;
         DBSize: number;
         DifferentTags: number;
@@ -62,16 +58,6 @@ export namespace SettingsTypes {
     }
 }
 
-export namespace TVShow {
-    /**
-     * result of actor fetch
-     */
-    export interface TVshowType {
-        Id: number;
-        Name: string;
-    }
-}
-
 export namespace ActorTypes {
     /**
      * result of actor fetch

src/types/GeneralTypes.ts

@@ -1,5 +1,4 @@
 import {TagType} from './VideoTypes';
-import PlyrJS from 'plyr';
 
 export interface GeneralSuccess {
     result: string;
@@ -15,20 +14,3 @@ export const DefaultTags: TagarrayType = {
     lowq: {TagId: 3, TagName: 'lowquality'},
     hd: {TagId: 4, TagName: 'hd'}
 };
-
-export const DefaultPlyrOptions: PlyrJS.Options = {
-    controls: [
-        'play-large', // The large play button in the center
-        'play', // Play/pause playback
-        'progress', // The progress bar and scrubber for playback and buffering
-        'current-time', // The current time of playback
-        'duration', // The full duration of the media
-        'mute', // Toggle mute
-        'volume', // Volume control
-        'captions', // Toggle captions
-        'settings', // Settings menu
-        'airplay', // Airplay (currently Safari only)
-        'download', // Show a download button with a link to either the current source or a custom URL you specify in your options
-        'fullscreen' // Toggle fullscreen
-    ]
-};

src/utils/Api.ts

@@ -1,5 +1,4 @@
 import GlobalInfos from './GlobalInfos';
-import {token} from './TokenHandler';
 
 const APIPREFIX: string = '/api/';
 
@@ -12,6 +11,169 @@ interface ApiBaseRequest {
     [_: string]: string | number | boolean | object;
 }
 
+// store api token - empty if not set
+let apiToken = '';
+
+// a callback que to be called after api token refresh
+let callQue: ((error: string) => void)[] = [];
+// flag to check wheter a api refresh is currently pending
+let refreshInProcess = false;
+// store the expire seconds of token
+let expireSeconds = -1;
+
+/**
+ * refresh the api token or use that one in cookie if still valid
+ * @param callback to be called after successful refresh
+ * @param password
+ * @param force
+ */
+export function refreshAPIToken(callback: (error: string) => void, force?: boolean, password?: string): void {
+    callQue.push(callback);
+
+    // check if already is a token refresh is in process
+    if (refreshInProcess) {
+        // if yes return
+        return;
+    } else {
+        // if not set flat
+        refreshInProcess = true;
+    }
+
+    if (apiTokenValid() && !force) {
+        console.log('token still valid...');
+        callFuncQue('');
+        return;
+    }
+
+    const formData = new FormData();
+    formData.append('grant_type', 'client_credentials');
+    formData.append('client_id', 'openmediacenter');
+    formData.append('client_secret', password ? password : 'openmediacenter');
+    formData.append('scope', 'all');
+
+    interface APIToken {
+        error?: string;
+        // eslint-disable-next-line camelcase
+        access_token: string; // no camel case allowed because of backendlib
+        // eslint-disable-next-line camelcase
+        expires_in: number; // no camel case allowed because of backendlib
+        scope: string;
+        // eslint-disable-next-line camelcase
+        token_type: string; // no camel case allowed because of backendlib
+    }
+
+    fetch('/token', {method: 'POST', body: formData}).then((response) =>
+        response.json().then((result: APIToken) => {
+            if (result.error) {
+                callFuncQue(result.error);
+                return;
+            }
+            console.log(result);
+            // set api token
+            apiToken = result.access_token;
+            // set expire time
+            expireSeconds = new Date().getTime() / 1000 + result.expires_in;
+            setTokenCookie(apiToken, expireSeconds);
+            // call all handlers and release flag
+            callFuncQue('');
+        })
+    );
+}
+
+export function apiTokenValid(): boolean {
+    // check if a cookie with token is available
+    const token = getTokenCookie();
+    if (token !== null) {
+        // check if token is at least valid for the next minute
+        if (token.expire > new Date().getTime() / 1000 + 60) {
+            apiToken = token.token;
+            expireSeconds = token.expire;
+
+            return true;
+        }
+    }
+    return false;
+}
+
+/**
+ * call all qued callbacks
+ */
+function callFuncQue(error: string): void {
+    // call all pending handlers
+    callQue.map((func) => {
+        return func(error);
+    });
+    // reset pending que
+    callQue = [];
+    // release flag to be able to start new refresh
+    refreshInProcess = false;
+}
+
+/**
+ * set the cookie for the currently gotten token
+ * @param token token string
+ * @param validSec second time when the token will be invalid
+ */
+function setTokenCookie(token: string, validSec: number): void {
+    let d = new Date();
+    d.setTime(validSec * 1000);
+    console.log('token set' + d.toUTCString());
+    let expires = 'expires=' + d.toUTCString();
+    document.cookie = 'token=' + token + ';' + expires + ';path=/';
+    document.cookie = 'token_expire=' + validSec + ';' + expires + ';path=/';
+}
+
+/**
+ * get all required cookies for the token
+ */
+function getTokenCookie(): {token: string; expire: number} | null {
+    const token = decodeCookie('token');
+    const expireInString = decodeCookie('token_expire');
+    const expireIn = parseInt(expireInString, 10);
+
+    if (expireIn !== 0 && token !== '') {
+        return {token: token, expire: expireIn};
+    } else {
+        return null;
+    }
+}
+
+/**
+ * decode a simple cookie with key specified
+ * @param key cookie key
+ */
+function decodeCookie(key: string): string {
+    let name = key + '=';
+    let decodedCookie = decodeURIComponent(document.cookie);
+    let ca = decodedCookie.split(';');
+    for (let i = 0; i < ca.length; i++) {
+        let c = ca[i];
+        while (c.charAt(0) === ' ') {
+            c = c.substring(1);
+        }
+        if (c.indexOf(name) === 0) {
+            return c.substring(name.length, c.length);
+        }
+    }
+    return '';
+}
+
+/**
+ * check if api token is valid -- if not request new one
+ * when finished call callback
+ * @param callback function to be called afterwards
+ */
+function checkAPITokenValid(callback: () => void): void {
+    // check if token is valid and set
+    if (apiToken === '' || expireSeconds <= new Date().getTime() / 1000) {
+        refreshAPIToken(() => {
+            callback();
+        });
+    } else {
+        callback();
+    }
+}
+
 /**
  * A backend api call
  * @param apinode which api backend handler to call
@@ -25,8 +187,36 @@ export function callAPI<T>(
     callback: (_: T) => void,
     errorcallback: (_: string) => void = (_: string): void => {}
 ): void {
-    token.checkAPITokenValid((mytoken) => {
+    checkAPITokenValid(() => {
-        generalAPICall<T>(apinode, fd, callback, errorcallback, false, true, mytoken);
+        console.log(apiToken);
+        fetch(APIPREFIX + apinode, {
+            method: 'POST',
+            body: JSON.stringify(fd),
+            headers: new Headers({
+                'Content-Type': 'application/json',
+                Authorization: 'Bearer ' + apiToken
+            })
+        })
+            .then((response) => {
+                if (response.status === 200) {
+                    // success
+                    response.json().then((result: T) => {
+                        callback(result);
+                    });
+                } else if (response.status === 400) {
+                    // Bad Request --> invalid token
+                    console.log('loading Password page.');
+                    // load password page
+                    if (GlobalInfos.loadPasswordPage) {
+                        GlobalInfos.loadPasswordPage(() => {
+                            callAPI(apinode, fd, callback, errorcallback);
+                        });
+                    }
+                } else {
+                    console.log('Error: ' + response.statusText);
+                }
+            })
+            .catch((reason) => errorcallback(reason));
     });
 }
 
@@ -43,7 +233,18 @@ export function callApiUnsafe<T>(
     callback: (_: T) => void,
     errorcallback?: (_: string) => void
 ): void {
-    generalAPICall(apinode, fd, callback, errorcallback, true, true, '');
+    fetch(APIPREFIX + apinode, {method: 'POST', body: JSON.stringify(fd)})
+        .then((response) => {
+            if (response.status !== 200) {
+                console.log('Error: ' + response.statusText);
+                // todo place error popup here
+            } else {
+                response.json().then((result: T) => {
+                    callback(result);
+                });
+            }
+        })
+        .catch((reason) => (errorcallback ? errorcallback(reason) : {}));
 }
 
 /**
@@ -53,55 +254,20 @@ export function callApiUnsafe<T>(
  * @param callback the callback with PLAIN text reply from backend
  */
 export function callAPIPlain(apinode: APINode, fd: ApiBaseRequest, callback: (_: string) => void): void {
-    token.checkAPITokenValid((mytoken) => {
+    checkAPITokenValid(() => {
-        generalAPICall(apinode, fd, callback, () => {}, false, false, mytoken);
+        fetch(APIPREFIX + apinode, {
-    });
-}
-
-function generalAPICall<T>(
-    apinode: APINode,
-    fd: ApiBaseRequest,
-    callback: (_: T) => void,
-    errorcallback: (_: string) => void = (_: string): void => {},
-    unsafe: boolean,
-    json: boolean,
-    mytoken: string
-): void {
-    (async function (): Promise<void> {
-        const response = await fetch(APIPREFIX + apinode, {
             method: 'POST',
             body: JSON.stringify(fd),
             headers: new Headers({
-                'Content-Type': json ? 'application/json' : 'text/plain',
+                'Content-Type': 'application/json',
-                ...(!unsafe && {Authorization: 'Bearer ' + mytoken})
+                Authorization: 'Bearer ' + apiToken
             })
-        });
+        }).then((response) =>
-
+            response.text().then((result) => {
-        if (response.status === 200) {
+                callback(result);
-            // success
+            })
-            try {
+        );
-                // decode json or text
+    });
-                const data = json ? await response.json() : await response.text();
-                callback(data);
-            } catch (e) {
-                errorcallback(e);
-            }
-        } else if (response.status === 400) {
-            // Bad Request --> invalid token
-            console.log('loading Password page.');
-            // load password page
-            if (GlobalInfos.loadPasswordPage) {
-                GlobalInfos.loadPasswordPage(() => {
-                    callAPI(apinode, fd, callback, errorcallback);
-                });
-            }
-        } else {
-            console.log('Error: ' + response.statusText);
-            if (errorcallback) {
-                errorcallback(response.statusText);
-            }
-        }
-    })();
 }
 
 /**
@@ -114,5 +280,5 @@ export enum APINode {
     Tags = 'tags',
     Actor = 'actor',
     Video = 'video',
-    TVShow = 'tvshow'
+    Init = 'init'
 }

src/utils/GlobalInfos.ts

@@ -8,8 +8,6 @@ import lighttheme from '../AppLightTheme.module.css';
 class StaticInfos {
     private darktheme: boolean = true;
     private videopath: string = '';
-    private tvshowpath: string = '';
-    private TVShowsEnabled: boolean = false;
 
     /**
      * check if the current theme is the dark theme
@@ -28,7 +26,7 @@ class StaticInfos {
 
         // trigger onThemeChange handlers
         this.handlers.map((func) => {
-            func();
+            return func();
         });
     }
 
@@ -49,9 +47,8 @@ class StaticInfos {
      * set the current videopath
      * @param vidpath videopath with beginning and ending slash
      */
-    setVideoPaths(vidpath: string, tvshowpath: string): void {
+    setVideoPath(vidpath: string): void {
         this.videopath = vidpath;
-        this.tvshowpath = tvshowpath;
     }
 
     /**
@@ -61,25 +58,10 @@ class StaticInfos {
         return this.videopath;
     }
 
-    /**
-     * return the current tvshow path
-     */
-    getTVShowPath(): string {
-        return this.tvshowpath;
-    }
-
     /**
      * load the Password page manually
      */
     loadPasswordPage: ((callback?: () => void) => void) | undefined = undefined;
-
-    setTVShowsEnabled(TVShowEnabled: boolean): void {
-        this.TVShowsEnabled = TVShowEnabled;
-    }
-
-    isTVShowEnabled(): boolean {
-        return this.TVShowsEnabled;
-    }
 }
 
 export default new StaticInfos();

src/utils/TokenHandler.ts

@@ -1,135 +0,0 @@
-import {TokenStore} from './TokenStore/TokenStore';
-
-export namespace token {
-    // store api token - empty if not set
-    let apiToken = '';
-
-    // a callback que to be called after api token refresh
-    let callQue: ((error: string) => void)[] = [];
-    // flag to check wheter a api refresh is currently pending
-    let refreshInProcess = false;
-    // store the expire seconds of token
-    let expireSeconds = -1;
-
-    let tokenStore: TokenStore;
-    let APiHost: string = '/';
-
-    export function init(ts: TokenStore, apiHost?: string): void {
-        tokenStore = ts;
-        if (apiHost) {
-            APiHost = apiHost;
-        }
-    }
-
-    /**
-     * refresh the api token or use that one in cookie if still valid
-     * @param callback to be called after successful refresh
-     * @param password
-     * @param force
-     */
-    export function refreshAPIToken(callback: (error: string) => void, force?: boolean, password?: string): void {
-        callQue.push(callback);
-
-        // check if already is a token refresh is in process
-        if (refreshInProcess) {
-            // if yes return
-            return;
-        } else {
-            // if not set flat
-            refreshInProcess = true;
-        }
-
-        if (apiTokenValid() && !force) {
-            console.log('token still valid...');
-            callFuncQue('');
-            return;
-        }
-
-        const formData = new FormData();
-        formData.append('grant_type', 'client_credentials');
-        formData.append('client_id', 'openmediacenter');
-        formData.append('client_secret', password ? password : 'openmediacenter');
-        formData.append('scope', 'all');
-
-        interface APIToken {
-            error?: string;
-            // eslint-disable-next-line camelcase
-            access_token: string; // no camel case allowed because of backendlib
-            // eslint-disable-next-line camelcase
-            expires_in: number; // no camel case allowed because of backendlib
-            scope: string;
-            // eslint-disable-next-line camelcase
-            token_type: string; // no camel case allowed because of backendlib
-        }
-
-        console.log(APiHost);
-
-        fetch(APiHost + 'token', {method: 'POST', body: formData})
-            .then((response) =>
-                response.json().then((result: APIToken) => {
-                    if (result.error) {
-                        callFuncQue(result.error);
-                        return;
-                    }
-                    // set api token
-                    apiToken = result.access_token;
-                    // set expire time
-                    expireSeconds = new Date().getTime() / 1000 + result.expires_in;
-                    // setTokenCookie(apiToken, expireSeconds);
-                    tokenStore.setToken({accessToken: apiToken, expireTime: expireSeconds, tokenType: '', scope: ''});
-                    // call all handlers and release flag
-                    callFuncQue('');
-                })
-            )
-            .catch((e) => {
-                callback(e);
-            });
-    }
-
-    export function apiTokenValid(): boolean {
-        // check if a cookie with token is available
-        // const token = getTokenCookie();
-        const tmptoken = tokenStore.loadToken();
-        if (tmptoken !== null) {
-            // check if token is at least valid for the next minute
-            if (tmptoken.expireTime > new Date().getTime() / 1000 + 60) {
-                apiToken = tmptoken.accessToken;
-                expireSeconds = tmptoken.expireTime;
-
-                return true;
-            }
-        }
-        return false;
-    }
-
-    /**
-     * call all qued callbacks
-     */
-    function callFuncQue(error: string): void {
-        // call all pending handlers
-        callQue.map((func) => {
-            return func(error);
-        });
-        // reset pending que
-        callQue = [];
-        // release flag to be able to start new refresh
-        refreshInProcess = false;
-    }
-
-    /**
-     * check if api token is valid -- if not request new one
-     * when finished call callback
-     * @param callback function to be called afterwards
-     */
-    export function checkAPITokenValid(callback: (mytoken: string) => void): void {
-        // check if token is valid and set
-        if (apiToken === '' || expireSeconds <= new Date().getTime() / 1000) {
-            console.log('token not valid...');
-            refreshAPIToken(() => {
-                callback(apiToken);
-            });
-        } else {
-            callback(apiToken);
-        }
-    }
-}

src/utils/TokenStore/CookieTokenStore.ts

@@ -1,48 +0,0 @@
-import {Token, TokenStore} from './TokenStore';
-
-export class CookieTokenStore extends TokenStore {
-    loadToken(): Token | null {
-        const token = this.decodeCookie('token');
-        const expireInString = this.decodeCookie('token_expire');
-        const expireIn = parseInt(expireInString, 10);
-
-        if (expireIn !== 0 && token !== '') {
-            return {accessToken: token, expireTime: expireIn, scope: '', tokenType: ''};
-        } else {
-            return null;
-        }
-    }
-
-    /**
-     * set the cookie for the currently gotten token
-     * @param token the token to set
-     */
-    setToken(token: Token): void {
-        let d = new Date();
-        d.setTime(token.expireTime * 1000);
-        console.log('token set' + d.toUTCString());
-        let expires = 'expires=' + d.toUTCString();
-        document.cookie = 'token=' + token.accessToken + ';' + expires + ';path=/';
-        document.cookie = 'token_expire=' + token.expireTime + ';' + expires + ';path=/';
-    }
-
-    /**
-     * decode a simple cookie with key specified
-     * @param key cookie key
-     */
-    decodeCookie(key: string): string {
-        let name = key + '=';
-        let decodedCookie = decodeURIComponent(document.cookie);
-        let ca = decodedCookie.split(';');
-        for (let i = 0; i < ca.length; i++) {
-            let c = ca[i];
-            while (c.charAt(0) === ' ') {
-                c = c.substring(1);
-            }
-            if (c.indexOf(name) === 0) {
-                return c.substring(name.length, c.length);
-            }
-        }
-        return '';
-    }
-}

src/utils/TokenStore/TokenStore.ts

@@ -1,11 +0,0 @@
-export interface Token {
-    accessToken: string;
-    expireTime: number; // second time when token will be invalidated
-    scope: string;
-    tokenType: string;
-}
-
-export abstract class TokenStore {
-    abstract loadToken(): Token | null;
-    abstract setToken(token: Token): void;
-}