new apihandler mechanics to allow asynchronous api calls

document some api nodes with apidoc

apiGo/api/Actors.go

@@ -12,32 +12,83 @@ func AddActorsHandlers() {
 }
 
 func getActorsFromDB() {
-	AddHandler("getAllActors", ActorNode, nil, func() []byte {
+	/**
+	 * @api {post} /api/actor [getAllActors]
+	 * @apiDescription Get all available Actors
+	 * @apiName getAllActors
+	 * @apiGroup Actor
+	 *
+	 * @apiSuccess {Object[]} . Array of Actors available
+	 * @apiSuccess {uint32} .ActorId Actor Id
+	 * @apiSuccess {string} .Name Actor Name
+	 * @apiSuccess {string} .Thumbnail Portrait Thumbnail
+	 */
+	AddHandler("getAllActors", ActorNode, func(info *HandlerInfo) []byte {
 		query := "SELECT actor_id, name, thumbnail FROM actors"
 		return jsonify(readActorsFromResultset(database.Query(query)))
 	})
 
-	var gaov struct {
+	/**
+	 * @api {post} /api/actor [getActorsOfVideo]
+	 * @apiDescription Get all actors playing in one video
+	 * @apiName getActorsOfVideo
+	 * @apiGroup Actor
+	 *
+	 * @apiParam {int} MovieId ID of video
+	 *
+	 * @apiSuccess {Object[]} . Array of Actors available
+	 * @apiSuccess {uint32} .ActorId Actor Id
+	 * @apiSuccess {string} .Name Actor Name
+	 * @apiSuccess {string} .Thumbnail Portrait Thumbnail
+	 */
+	AddHandler("getActorsOfVideo", ActorNode, func(info *HandlerInfo) []byte {
+		var args struct {
 			MovieId int
 		}
-	AddHandler("getActorsOfVideo", ActorNode, &gaov, func() []byte {
+		if err := FillStruct(&args, info.Data); err != nil {
+			fmt.Println(err.Error())
+			return nil
+		}
+
 		query := fmt.Sprintf(`SELECT a.actor_id, name, thumbnail FROM actors_videos
 									JOIN actors a on actors_videos.actor_id = a.actor_id
-									WHERE actors_videos.video_id=%d`, gaov.MovieId)
+									WHERE actors_videos.video_id=%d`, args.MovieId)
 
 		return jsonify(readActorsFromResultset(database.Query(query)))
 	})
 
-	var gai struct {
+	/**
+	 * @api {post} /api/actor [getActorInfo]
+	 * @apiDescription Get all infos for an actor
+	 * @apiName getActorInfo
+	 * @apiGroup Actor
+	 *
+	 * @apiParam {int} ActorId ID of Actor
+	 *
+	 * @apiSuccess {VideoUnloadedType[]} Videos Array of Videos this actor plays in
+	 * @apiSuccess {uint32} Videos.MovieId Video Id
+	 * @apiSuccess {string} Videos.MovieName Video Name
+	 *
+	 * @apiSuccess {Info} Info Infos about the actor
+	 * @apiSuccess {uint32} Info.ActorId Actor Id
+	 * @apiSuccess {string} Info.Name Actor Name
+	 * @apiSuccess {string} Info.Thumbnail Actor Thumbnail
+	 */
+	AddHandler("getActorInfo", ActorNode, func(info *HandlerInfo) []byte {
+		var args struct {
 			ActorId int
 		}
-	AddHandler("getActorInfo", ActorNode, &gai, func() []byte {
+		if err := FillStruct(&args, info.Data); err != nil {
+			fmt.Println(err.Error())
+			return nil
+		}
+
 		query := fmt.Sprintf(`SELECT movie_id, movie_name FROM actors_videos
 										JOIN videos v on v.movie_id = actors_videos.video_id
-										WHERE actors_videos.actor_id=%d`, gai.ActorId)
+										WHERE actors_videos.actor_id=%d`, args.ActorId)
 		videos := readVideosFromResultset(database.Query(query))
 
-		query = fmt.Sprintf("SELECT actor_id, name, thumbnail FROM actors WHERE actor_id=%d", gai.ActorId)
+		query = fmt.Sprintf("SELECT actor_id, name, thumbnail FROM actors WHERE actor_id=%d", args.ActorId)
 		actor := readActorsFromResultset(database.Query(query))[0]
 
 		var result = struct {
@@ -53,20 +104,51 @@ func getActorsFromDB() {
 }
 
 func saveActorsToDB() {
-	var ca struct {
+	/**
+	 * @api {post} /api/video [createActor]
+	 * @apiDescription Create a new Actor
+	 * @apiName createActor
+	 * @apiGroup Actor
+	 *
+	 * @apiParam {string} ActorName Name of new Actor
+	 *
+	 * @apiSuccess {string} result 'success' if successfully or error message if not
+	 */
+	AddHandler("createActor", ActorNode, func(info *HandlerInfo) []byte {
+		var args struct {
 			ActorName string
 		}
-	AddHandler("createActor", ActorNode, &ca, func() []byte {
+		if err := FillStruct(&args, info.Data); err != nil {
+			fmt.Println(err.Error())
+			return nil
+		}
+
 		query := "INSERT IGNORE INTO actors (name) VALUES (?)"
-		return database.SuccessQuery(query, ca.ActorName)
+		return database.SuccessQuery(query, args.ActorName)
 	})
 
-	var aatv struct {
+	/**
+	 * @api {post} /api/video [addActorToVideo]
+	 * @apiDescription Add Actor to Video
+	 * @apiName addActorToVideo
+	 * @apiGroup Actor
+	 *
+	 * @apiParam {int} ActorId Id of Actor
+	 * @apiParam {int} MovieId Id of Movie to add to
+	 *
+	 * @apiSuccess {string} result 'success' if successfully or error message if not
+	 */
+	AddHandler("addActorToVideo", ActorNode, func(info *HandlerInfo) []byte {
+		var args struct {
 			ActorId int
 			MovieId int
 		}
-	AddHandler("addActorToVideo", ActorNode, &aatv, func() []byte {
+		if err := FillStruct(&args, info.Data); err != nil {
-		query := fmt.Sprintf("INSERT IGNORE INTO actors_videos (actor_id, video_id) VALUES (%d,%d)", aatv.ActorId, aatv.MovieId)
+			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,6 +4,7 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
+	"gopkg.in/oauth2.v3"
 	"net/http"
 	"openmediacenter/apiGo/api/oauth"
 )
@@ -18,22 +19,27 @@ const (
 	TVShowNode   = iota
 )
 
+type HandlerInfo struct {
+	ID    string
+	Token string
+	Data  map[string]interface{}
+}
+
 type actionStruct struct {
 	Action string
 }
 
 type Handler struct {
 	action  string
-	handler   func() []byte
+	handler func(info *HandlerInfo) []byte
-	arguments interface{}
 	apiNode int
 }
 
-var handlers []Handler
+var handlers = make(map[string]Handler)
 
-func AddHandler(action string, apiNode int, n interface{}, h func() []byte) {
+func AddHandler(action string, apiNode int, h func(info *HandlerInfo) []byte) {
 	// append new handler to the handlers
-	handlers = append(handlers, Handler{action, h, n, apiNode})
+	handlers[fmt.Sprintf("%s/%d", action, apiNode)] = Handler{action, h, apiNode}
 }
 
 func ServerInit() {
@@ -47,27 +53,39 @@ func ServerInit() {
 	oauth.InitOAuth()
 }
 
-func handleAPICall(action string, requestBody string, apiNode int) []byte {
+func handleAPICall(action string, requestBody string, apiNode int, info *HandlerInfo) []byte {
-	for i := range handlers {
+	handler, ok := handlers[fmt.Sprintf("%s/%d", action, apiNode)]
-		if handlers[i].action == action && handlers[i].apiNode == apiNode {
+	if !ok {
-			// call the handler and return
+		// handler doesn't exist!
-
-			if handlers[i].arguments != nil {
-				// decode the arguments to the corresponding arguments object
-				err := json.Unmarshal([]byte(requestBody), &handlers[i].arguments)
-				if err != nil {
-					fmt.Printf("failed to decode arguments of action %s :: %s\n", action, requestBody)
-				}
-			}
-
-			return handlers[i].handler()
-		}
-	}
 		fmt.Printf("no handler found for Action: %d/%s\n", apiNode, action)
 		return nil
+	}
+
+	// check if info even exists
+	if info == nil {
+		info = &HandlerInfo{}
+	}
+
+	// parse the arguments
+	var args map[string]interface{}
+	err := json.Unmarshal([]byte(requestBody), &args)
+
+	if err != nil {
+		fmt.Printf("failed to decode arguments of action %s :: %s\n", action, requestBody)
+	} else {
+		// check if map has an action
+		if _, ok := args["action"]; ok {
+			delete(args, "action")
+		}
+
+		info.Data = args
+	}
+
+	// call the handler
+	return handler.handler(info)
 }
 
-func handlefunc(rw http.ResponseWriter, req *http.Request, node int) {
+func handlefunc(rw http.ResponseWriter, req *http.Request, node int, tokenInfo *oauth2.TokenInfo) {
 	// only allow post requests
 	if req.Method != "POST" {
 		return
@@ -83,5 +101,13 @@ func handlefunc(rw http.ResponseWriter, req *http.Request, node int) {
 		fmt.Println("failed to read action from request! :: " + body)
 	}
 
-	rw.Write(handleAPICall(t.Action, body, node))
+	// load userid from received token object
+	id := (*tokenInfo).GetClientID()
+
+	userinfo := &HandlerInfo{
+		ID:    id,
+		Token: (*tokenInfo).GetCode(),
+	}
+
+	rw.Write(handleAPICall(t.Action, body, node, userinfo))
 }

apiGo/api/Helpers.go

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

apiGo/api/Settings.go

@@ -2,6 +2,7 @@ package api
 
 import (
 	"encoding/json"
+	"fmt"
 	"openmediacenter/apiGo/api/types"
 	"openmediacenter/apiGo/database"
 	"openmediacenter/apiGo/database/settings"
@@ -17,11 +18,12 @@ func AddSettingsHandlers() {
 }
 
 func getSettingsFromDB() {
-	AddHandler("loadGeneralSettings", SettingsNode, nil, func() []byte {
+	AddHandler("loadGeneralSettings", SettingsNode, func(info *HandlerInfo) []byte {
 		result := database.GetSettings()
 		return jsonify(result)
 	})
-	AddHandler("loadInitialData", SettingsNode, nil, func() []byte {
+
+	AddHandler("loadInitialData", SettingsNode, func(info *HandlerInfo) []byte {
 		sett := settings.LoadSettings()
 
 		type InitialDataTypeResponse struct {
@@ -52,10 +54,15 @@ func getSettingsFromDB() {
 }
 
 func saveSettingsToDB() {
-	var sgs struct {
+	AddHandler("saveGeneralSettings", SettingsNode, func(info *HandlerInfo) []byte {
+		var args struct {
 			Settings types.SettingsType
 		}
-	AddHandler("saveGeneralSettings", SettingsNode, &sgs, func() []byte {
+		if err := FillStruct(&args, info.Data); err != nil {
+			fmt.Println(err.Error())
+			return nil
+		}
+
 		query := `
 					UPDATE settings SET 
                         video_path=?,
@@ -66,24 +73,24 @@ func saveSettingsToDB() {
                         DarkMode=?
                     WHERE 1`
 		return database.SuccessQuery(query,
-			sgs.Settings.VideoPath, sgs.Settings.EpisodePath, sgs.Settings.Password,
+			args.Settings.VideoPath, args.Settings.EpisodePath, args.Settings.Password,
-			sgs.Settings.MediacenterName, sgs.Settings.TMDBGrabbing, sgs.Settings.DarkMode)
+			args.Settings.MediacenterName, args.Settings.TMDBGrabbing, args.Settings.DarkMode)
 	})
 }
 
 // methods for handling reindexing and cleanup of db gravity
 func reIndexHandling() {
-	AddHandler("startReindex", SettingsNode, nil, func() []byte {
+	AddHandler("startReindex", SettingsNode, func(info *HandlerInfo) []byte {
 		videoparser.StartReindex()
 		return database.ManualSuccessResponse(nil)
 	})
 
-	AddHandler("startTVShowReindex", SettingsNode, nil, func() []byte {
+	AddHandler("startTVShowReindex", SettingsNode, func(info *HandlerInfo) []byte {
 		videoparser.StartTVShowReindex()
 		return database.ManualSuccessResponse(nil)
 	})
 
-	AddHandler("cleanupGravity", SettingsNode, nil, func() []byte {
+	AddHandler("cleanupGravity", SettingsNode, func(info *HandlerInfo) []byte {
 		videoparser.StartCleanup()
 		return nil
 	})

apiGo/api/TVShows.go

@@ -6,17 +6,22 @@ import (
 )
 
 func AddTvshowHandlers() {
-	AddHandler("getTVShows", TVShowNode, nil, func() []byte {
+	AddHandler("getTVShows", TVShowNode, func(info *HandlerInfo) []byte {
 		query := "SELECT id, name FROM tvshow"
 		rows := database.Query(query)
 		return jsonify(readTVshowsFromResultset(rows))
 	})
 
-	var ge struct {
+	AddHandler("getEpisodes", TVShowNode, func(info *HandlerInfo) []byte {
+		var args struct {
 			ShowID uint32
 		}
-	AddHandler("getEpisodes", TVShowNode, &ge, func() []byte {
+		if err := FillStruct(&args, info.Data); err != nil {
-		query := fmt.Sprintf("SELECT id, name, season, episode FROM tvshow_episodes WHERE tvshow_id=%d", ge.ShowID)
+			fmt.Println(err.Error())
+			return nil
+		}
+
+		query := fmt.Sprintf("SELECT id, name, season, episode FROM tvshow_episodes WHERE tvshow_id=%d", args.ShowID)
 		rows := database.Query(query)
 
 		type Episode struct {
@@ -41,15 +46,20 @@ func AddTvshowHandlers() {
 		return jsonify(episodes)
 	})
 
-	var le struct {
+	AddHandler("loadEpisode", TVShowNode, func(info *HandlerInfo) []byte {
+		var args struct {
 			ID uint32
 		}
-	AddHandler("loadEpisode", TVShowNode, &le, func() []byte {
+		if err := FillStruct(&args, info.Data); err != nil {
+			fmt.Println(err.Error())
+			return nil
+		}
+
 		query := fmt.Sprintf(`
 SELECT tvshow_episodes.name, season, tvshow_id, episode, filename, t.foldername
 FROM tvshow_episodes 
 JOIN tvshow t on t.id = tvshow_episodes.tvshow_id
-WHERE tvshow_episodes.id=%d`, le.ID)
+WHERE tvshow_episodes.id=%d`, args.ID)
 		row := database.QueryRow(query)
 
 		var ret struct {
@@ -73,17 +83,22 @@ WHERE tvshow_episodes.id=%d`, le.ID)
 		return jsonify(ret)
 	})
 
-	var rtn struct {
+	AddHandler("readThumbnail", TVShowNode, func(info *HandlerInfo) []byte {
+		var args struct {
 			Id int
 		}
-	AddHandler("readThumbnail", TVShowNode, &rtn, func() []byte {
+		if err := FillStruct(&args, info.Data); err != nil {
+			fmt.Println(err.Error())
+			return nil
+		}
+
 		var pic []byte
 
-		query := fmt.Sprintf("SELECT thumbnail FROM tvshow WHERE id=%d", rtn.Id)
+		query := fmt.Sprintf("SELECT thumbnail FROM tvshow WHERE id=%d", args.Id)
 
 		err := database.QueryRow(query).Scan(&pic)
 		if err != nil {
-			fmt.Printf("the thumbnail of movie id %d couldn't be found", rtn.Id)
+			fmt.Printf("the thumbnail of movie id %d couldn't be found", args.Id)
 			return nil
 		}
 

apiGo/api/Tags.go

@@ -13,14 +13,19 @@ func AddTagHandlers() {
 }
 
 func deleteFromDB() {
-	var dT struct {
+	AddHandler("deleteTag", TagNode, func(info *HandlerInfo) []byte {
+		var args struct {
 			TagId int
 			Force bool
 		}
-	AddHandler("deleteTag", TagNode, &dT, func() []byte {
+		if err := FillStruct(&args, info.Data); err != nil {
+			fmt.Println(err.Error())
+			return nil
+		}
+
 		// delete key constraints first
-		if dT.Force {
+		if args.Force {
-			query := fmt.Sprintf("DELETE FROM video_tags WHERE tag_id=%d", dT.TagId)
+			query := fmt.Sprintf("DELETE FROM video_tags WHERE tag_id=%d", args.TagId)
 			err := database.Edit(query)
 
 			// respond only if result not successful
@@ -29,7 +34,7 @@ func deleteFromDB() {
 			}
 		}
 
-		query := fmt.Sprintf("DELETE FROM tags WHERE tag_id=%d", dT.TagId)
+		query := fmt.Sprintf("DELETE FROM tags WHERE tag_id=%d", args.TagId)
 		err := database.Edit(query)
 
 		if err == nil {
@@ -48,27 +53,37 @@ func deleteFromDB() {
 }
 
 func getFromDB() {
-	AddHandler("getAllTags", TagNode, nil, func() []byte {
+	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 {
+	AddHandler("createTag", TagNode, func(info *HandlerInfo) []byte {
+		var args struct {
 			TagName string
 		}
-	AddHandler("createTag", TagNode, &ct, func() []byte {
+		if err := FillStruct(&args, info.Data); err != nil {
+			fmt.Println(err.Error())
+			return nil
+		}
+
 		query := "INSERT IGNORE INTO tags (tag_name) VALUES (?)"
-		return database.SuccessQuery(query, ct.TagName)
+		return database.SuccessQuery(query, args.TagName)
 	})
 
-	var at struct {
+	AddHandler("addTag", TagNode, func(info *HandlerInfo) []byte {
+		var args struct {
 			MovieId int
 			TagId   int
 		}
-	AddHandler("addTag", TagNode, &at, func() []byte {
+		if err := FillStruct(&args, info.Data); err != nil {
+			fmt.Println(err.Error())
+			return nil
+		}
+
 		query := "INSERT IGNORE INTO video_tags(tag_id, video_id) VALUES (?,?)"
-		return database.SuccessQuery(query, at.TagId, at.MovieId)
+		return database.SuccessQuery(query, args.TagId, args.MovieId)
 	})
 }

apiGo/api/Video.go

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

apiGo/api/oauth/Oauth.go

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

package.json

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

src/elements/VideoContainer/VideoContainer.tsx

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

src/pages/CategoryPage/CategoryView.tsx

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

src/pages/HomePage/HomePage.tsx

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

src/pages/RandomPage/RandomPage.tsx

@@ -85,8 +85,7 @@ class RandomPage extends React.Component<{}, state> {
      * @param nr number of videos to load
      */
     loadShuffledvideos(nr: number): void {
-        callAPI<GetRandomMoviesType>(APINode.Video, {action: 'getRandomMovies', number: nr}, (result) => {
+        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,