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

implement full load of videos and startdata

Browse Source 
modify api where necessary
This commit is contained in:
Lukas Heiligenbrunner 2021-02-23 16:01:29 +00:00
parent 2967aee16d
commit f2b5fb6587
69 changed files with 14016 additions and 21001 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

69
.gitlab-ci.yml
View File

@ -1,48 +1,72 @@
image: node:14 image: node:14
stages: stages:
- prepare
- build - build
- test - test
- packaging - packaging
- deploy - deploy
cache:
key: ${CI_COMMIT_REF_SLUG}
paths:
- .npm/
- node_modules/
include: include:
- template: Code-Quality.gitlab-ci.yml - template: Code-Quality.gitlab-ci.yml
variables: variables:
SAST_DISABLE_DIND: "true" SAST_DISABLE_DIND: "true"
Node_dependencies: Minimize_Frontend:
stage: prepare
script:
- npm ci --cache .npm --prefer-offline
Minimize:
stage: build stage: build
before_script:
- yarn install --cache-folder .yarn
script: script:
- npm run build - yarn run build
artifacts: artifacts:
expire_in: 7 days expire_in: 2 days
paths: paths:
- build/ - build/
needs: ["Node_dependencies"] cache:
key: ${CI_COMMIT_REF_SLUG}
paths:
- .yarn/
- node_modules/
Build_Backend:
image: golang:latest
stage: build
script:
- cd apiGo
- go build -v -o openmediacenter
- env GOOS=windows GOARCH=amd64 go build -v -o openmediacenter.exe
artifacts:
expire_in: 2 days
paths:
- "./apiGo/openmediacenter*"
Frontend_Tests: Frontend_Tests:
stage: test stage: test
before_script:
- yarn install --cache-folder .yarn
script: script:
- npm run test - yarn run test
artifacts: artifacts:
reports: reports:
junit: junit:
- ./junit.xml - ./junit.xml
needs: ["Node_dependencies"] cache:
key: ${CI_COMMIT_REF_SLUG}
paths:
- .yarn/
- node_modules/
Backend_Tests:
image: golang:latest
stage: test
script:
- cd apiGo
- go get -u github.com/jstemmer/go-junit-report
- go test -v ./... 2>&1 | go-junit-report -set-exit-code > report.xml
artifacts:
when: always
reports:
junit: ./apiGo/report.xml
code_quality: code_quality:
tags: tags:
@ -56,23 +80,28 @@ Debian_Server:
- cd deb - cd deb
- mkdir -p "./OpenMediaCenter/var/www/openmediacenter/videos/" - mkdir -p "./OpenMediaCenter/var/www/openmediacenter/videos/"
- mkdir -p "./OpenMediaCenter/tmp/" - mkdir -p "./OpenMediaCenter/tmp/"
- mkdir -p "./OpenMediaCenter/usr/bin/"
- cp -r ../build/* ./OpenMediaCenter/var/www/openmediacenter/ - cp -r ../build/* ./OpenMediaCenter/var/www/openmediacenter/
- cp -r ../api ./OpenMediaCenter/var/www/openmediacenter/ - cp ../apiGo/openmediacenter ./OpenMediaCenter/usr/bin/
- cp ../database.sql ./OpenMediaCenter/tmp/openmediacenter.sql - cp ../database.sql ./OpenMediaCenter/tmp/openmediacenter.sql
- 'echo "Version: ${vers}" >> ./OpenMediaCenter/DEBIAN/control' - 'echo "Version: ${vers}" >> ./OpenMediaCenter/DEBIAN/control'
- chmod -R 0775 * - chmod -R 0775 *
- dpkg-deb --build OpenMediaCenter - dpkg-deb --build OpenMediaCenter
- mv OpenMediaCenter.deb OpenMediaCenter-${vers}_amd64.deb - mv OpenMediaCenter.deb OpenMediaCenter-${vers}_amd64.deb
artifacts: artifacts:
expire_in: 7 days
paths: paths:
- deb/OpenMediaCenter-*.deb - deb/OpenMediaCenter-*.deb
needs: ["Minimize"] needs:
- Minimize_Frontend
- Build_Backend
Test_Server: Test_Server:
stage: deploy stage: deploy
image: luki42/alpineopenssh:latest image: luki42/alpineopenssh:latest
needs: needs:
- Frontend_Tests - Frontend_Tests
- Backend_Tests
- Debian_Server - Debian_Server
only: only:
- master - master

2
README.md
View File

@ -8,7 +8,7 @@ Feel free to contribute or open an issue here: https://gitlab.heili.eu/lukas/ope
## What is this? ## What is this?
Open Media Center is an open source solution for a mediacenter in your home network. Open Media Center is an open source solution for a mediacenter in your home network.
Transform your webserver into a mediaserver. Transform your webserver into a mediaserver.
It's based on Reactjs and PHP is used for backend. It's based on Reactjs and golang is used for backend.
It is optimized for general videos as well as for movies. It is optimized for general videos as well as for movies.
For grabbing movie data TMDB is used. For grabbing movie data TMDB is used.
With the help of tags you can organize your video gravity. With the help of tags you can organize your video gravity.

5
api/actor.php
View File

@ -1,5 +0,0 @@
<?php
include_once __DIR__ . '/src/handlers/Actor.php';
$actor = new Actor();
$actor->handleAction();

18
api/extractvideopreviews.php
View File

@ -1,18 +0,0 @@
<?php
require_once __DIR__ . '/src/Database.php';
require_once __DIR__ . '/src/TMDBMovie.php';
require_once __DIR__ . '/src/SSettings.php';
require_once __DIR__ . '/src/VideoParser.php';
// allow UTF8 characters
setlocale(LC_ALL, 'en_US.UTF-8');
set_time_limit(3600);
$vp = new VideoParser();
$vp->writeLog("starting extraction!!\n");
$sett = new SSettings();
// load video path from settings
$scandir = __DIR__ . "/../" . $sett->getVideoPath();
$vp->extractVideos($scandir);

5
api/settings.php
View File

@ -1,5 +0,0 @@
<?php
require_once __DIR__ . '/src/handlers/Settings.php';
$sett = new Settings();
$sett->handleAction();

57
api/src/Database.php
View File

@ -1,57 +0,0 @@
<?php
/**
* Class Database
*
* Class with all neccessary stuff for the Database connections.
*/
class Database {
private static $instance = null;
private $conn;
private $servername = "127.0.0.1";
private $username = "mediacenteruser";
private $password = "mediapassword";
private $dbname = "mediacenter";
// The db connection is established in the private constructor.
private function __construct() {
// Create connection
$this->conn = new mysqli($this->servername, $this->username, $this->password, $this->dbname);
if ($this->conn->connect_errno) {
echo "connecton failed... nr: " . $this->conn->connect_errno . " -- " . $this->conn->connect_error;
}
}
/**
* get an instance of this database class
* (only possible way to retrieve an object)
*
* @return Database dbobject
*/
public static function getInstance() {
if (!self::$instance) {
self::$instance = new Database();
}
return self::$instance;
}
/**
* get a connection instance of the database
*
* @return mysqli mysqli instance
*/
public function getConnection() {
return $this->conn;
}
/**
* get name of current active database
* @return string name
*/
public function getDatabaseName() {
return $this->dbname;
}
}

45
api/src/SSettings.php
View File

@ -1,45 +0,0 @@
<?php
/**
* Class SSettings
* class handling all Settings used by php scripts
*/
class SSettings {
private $database;
/**
* SSettings constructor.
*/
public function __construct() {
$this->database = Database::getInstance();
}
/**
* get the videopath saved in db
* @return string videopath
*/
public function getVideoPath() {
$query = "SELECT video_path from settings";
$result = $this->database->getConnection()->query($query);
$r = mysqli_fetch_assoc($result);
return $r['video_path'];
}
/**
* check if TMDB is enableds
* @return bool isenabled?
*/
public function isTMDBGrabbingEnabled(): bool {
$query = "SELECT TMDB_grabbing from settings WHERE 1";
$result = $this->database->getConnection()->query($query);
if (!$result) {
return true; // if undefined in db --> default true
} else {
$r = mysqli_fetch_assoc($result);
return $r['TMDB_grabbing'] == '1';
}
}
}

51
api/src/TMDBMovie.php
View File

@ -1,51 +0,0 @@
<?php
/**
* Class TMDBMovie
* class to handle all interactions with the tmdb api
*/
class TMDBMovie {
public $picturebase = "https://image.tmdb.org/t/p/w500";
private $apikey = "9fd90530b11447f5646f8e6fb4733fb4";
private $baseurl = "https://api.themoviedb.org/3/";
/**
* search for a specific movie
*
* @param string $moviename moviename
* @return object movie object or null if not found
*/
public function searchMovie(string $moviename, string $year = null) {
$reply = json_decode(file_get_contents($this->baseurl . "search/movie?api_key=" . $this->apikey . "&query=" . urlencode($moviename)));
if ($reply->total_results == 0) {
// no results found
return null;
} elseif ($year != null) {
// if year is defined check year
$regex = '/[0-9]{4}?/'; // matches year of string
for ($i = 0; $i < count($reply->results); $i++) {
$releasedate = $reply->results[$i]->release_date;
preg_match($regex, $releasedate, $matches);
if (count($matches) > 0) {
$curryear = $matches[0];
if ($curryear == $year)
return $reply->results[$i];
}
}
} else {
return $reply->results[0];
}
}
/**
* query all available genres from tmdb
*
* @return array of all available genres
*/
public function getAllGenres() {
$reply = json_decode(file_get_contents($this->baseurl . "genre/movie/list?api_key=" . $this->apikey));
return $reply->genres;
}
}

332
api/src/VideoParser.php
View File

@ -1,332 +0,0 @@
<?php
require_once 'Database.php';
require_once 'TMDBMovie.php';
require_once 'SSettings.php';
/**
* Class VideoParser
* handling the parsing of all videos of a folder and adding
* all videos with tags and thumbnails to the database
*/
class VideoParser {
/// ffmpeg installation binary
private string $ffmpeg = 'ffmpeg';
private TMDBMovie $tmdb;
/// initial load of all available movie genres
private array $tmdbgenres;
private string $videopath;
/// db connection instance
private mysqli $conn;
/// settings object instance
private SSettings $settings;
private bool $TMDBenabled;
/// videos added in this run
private int $added = 0;
/// all videos in this run
private int $all = 0;
/// failed videos in this run
private int $failed = 0;
/// deleted videos in this run
private int $deleted = 0;
/**
* VideoParser constructor.
*/
public function __construct() {
$this->tmdb = new TMDBMovie();
$this->tmdbgenres = $this->tmdb->getAllGenres();
$this->conn = Database::getInstance()->getConnection();
$this->settings = new SSettings();
$this->TMDBenabled = $this->settings->isTMDBGrabbingEnabled();
$this->videopath = $this->settings->getVideoPath();
}
/**
* searches a folder for mp4 videos and adds them to video gravity
* @param $foldername string the folder where to search (relative to the webserver root)
*/
public function extractVideos(string $foldername) {
echo("TMDB grabbing is " . ($this->TMDBenabled ? "" : "not") . " enabled \n");
$arr = scandir($foldername);
foreach ($arr as $elem) {
if ($elem == '.' || $elem == '..') continue;
$ext = pathinfo($elem, PATHINFO_EXTENSION);
if ($ext == "mp4") {
$this->processVideo($elem);
} else {
echo($elem . " does not contain a valid .mp4 extension! - skipping \n");
$this->writeLog($elem . " does not contain a valid .mp4 extension! - skipping \n");
}
}
// cleanup gravity
$this->cleanUpGravity();
// calculate size of databse here
$size = -1;
$query = "SELECT table_schema AS \"Database\",
ROUND(SUM(data_length + index_length) / 1024 / 1024, 3) AS \"Size\"
FROM information_schema.TABLES
WHERE TABLE_SCHEMA='" . Database::getInstance()->getDatabaseName() . "'
GROUP BY table_schema;";
$result = $this->conn->query($query);
if ($result->num_rows == 1) {
$row = $result->fetch_assoc();
$size = $row["Size"];
}
echo "Total gravity: " . $this->all . "\n";
$this->writeLog("Total gravity: " . $this->all . "\n");
echo "Size of Databse is: " . $size . "MB\n";
$this->writeLog("Size of Databse is: " . $size . "MB\n");
echo "added in this run: " . $this->added . "\n";
$this->writeLog("added in this run: " . $this->added . "\n");
echo "deleted in this run: " . $this->deleted . "\n";
$this->writeLog("deleted in this run: " . $this->deleted . "\n");
echo "errored in this run: " . $this->failed . "\n";
$this->writeLog("errored in this run: " . $this->failed . "\n");
$this->writeLog("-42"); // terminating characters to stop webui requesting infos
}
/**
* processes one mp4 video, extracts tags and adds it to the database
* @param $filename string filename of the video to process
*/
private function processVideo(string $filename) {
$moviename = substr($filename, 0, -4);
$regex = '/\([0-9]{4}?\)/'; //match year pattern
preg_match($regex, $moviename, $matches);
preg_replace($regex, '', $moviename);
$year = null;
if (count($matches) > 0) {
$year = substr($matches[count($matches) - 1], 1, 4);
$moviename = substr($moviename, 0, -6);
}
$query = "SELECT * FROM videos WHERE movie_name = '" . mysqli_real_escape_string($this->conn, $moviename) . "'";
$result = $this->conn->query($query);
// insert if not available in db
if (!mysqli_fetch_assoc($result)) {
$genres = -1;
$insert_query = "";
// extract other video attributes
$video_attributes = $this->_get_video_attributes($filename);
$duration = 0;
$size = 0;
$width = 0;
if ($video_attributes) {
$duration = $video_attributes->media->track[0]->Duration; // in seconds
$size = $video_attributes->media->track[0]->FileSize; // in Bytes
$width = $video_attributes->media->track[1]->Width; // width
}
// extract poster from video
$backpic = shell_exec("$this->ffmpeg -hide_banner -loglevel panic -ss 00:04:00 -i \"../$this->videopath$filename\" -vframes 1 -q:v 2 -f singlejpeg pipe:1 2>/dev/null");
// convert video to base64
$backpic64 = 'data:image/jpeg;base64,' . base64_encode($backpic);
// set default insert query without tmdb poster
$insert_query = "INSERT INTO videos(movie_name,movie_url,thumbnail,quality,length)
VALUES ('" . mysqli_real_escape_string($this->conn, $moviename) . "',
'" . mysqli_real_escape_string($this->conn, $this->videopath . $filename) . "',
'$backpic64',
'$width',
'$duration')";
// check if tmdb grabbing is enabled
if ($this->TMDBenabled) {
// search in tmdb api
if (!is_null($dta = $this->tmdb->searchMovie($moviename, $year))) {
$poster = file_get_contents($this->tmdb->picturebase . $dta->poster_path);
// error handling for download error
if ($poster) {
$poster_base64 = 'data:image/jpeg;base64,' . base64_encode($poster);
// override insert query if pic loaded correctly
$insert_query = "INSERT INTO videos(movie_name,movie_url,poster,thumbnail,quality,length)
VALUES ('" . mysqli_real_escape_string($this->conn, $moviename) . "',
'" . mysqli_real_escape_string($this->conn, $this->videopath . $filename) . "',
'$backpic64',
'$poster_base64',
'$width',
'$duration')";
}
// store genre ids for parsing later
$genres = $dta->genre_ids;
} else {
// nothing found with tmdb
echo "my moviename: " . $moviename;
$this->writeLog("nothing found with TMDB! -- $moviename\n");
}
}
if ($this->conn->query($insert_query) === TRUE) {
echo('successfully added ' . $filename . " to video gravity\n");
$this->writeLog('successfully added ' . $filename . " to video gravity\n");
// add this entry to the default tags
$last_id = $this->conn->insert_id;
$this->insertSizeTag($width, $last_id);
// handle tmdb genres here!
if ($genres != -1) {
// transform genre ids in valid names
foreach ($genres as $genreid) {
// check if genre is already a tag in db if not insert it
$tagname = array_column($this->tmdbgenres, 'name', 'id')[$genreid];
$tagid = $this->tagExists($tagname);
$query = "INSERT INTO video_tags(video_id,tag_id) VALUES ($last_id,$tagid)";
if ($this->conn->query($query) !== TRUE) {
echo "failed to add $genreid tag here.\n";
$this->writeLog("failed to add $genreid tag here.\n");
}
}
}
$this->added++;
$this->all++;
} else {
echo('errored item: ' . $filename . "\n");
$this->writeLog('errored item: ' . $filename . "\n");
echo('{"data":"' . $this->conn->error . '"}\n');
$this->writeLog('{"data":"' . $this->conn->error . '"}\n');
$this->failed++;
}
} else {
$this->all++;
}
}
/**
* get all videoinfos of a video file
*
* @param $video string name including extension
* @return object all infos as object
*/
private function _get_video_attributes(string $video) {
$command = "mediainfo \"../$this->videopath$video\" --Output=JSON";
$output = shell_exec($command);
return json_decode($output);
}
/**
* write a line to the output log file
*
* @param string $message message to write
*/
public function writeLog(string $message) {
file_put_contents("/tmp/output.log", $message, FILE_APPEND);
flush();
}
/**
* insert the corresponding videosize tag to a specific videoid
* @param $width int video width
* @param $videoid int id of video
*/
private function insertSizeTag(int $width, int $videoid) {
// full hd
if ($width >= 1900) {
$query = "INSERT INTO video_tags(video_id,tag_id) VALUES ($videoid,2)";
if ($this->conn->query($query) !== TRUE) {
echo "failed to add default tag here.\n";
$this->writeLog("failed to add default tag here.\n");
}
}
// HD
if ($width >= 1250 && $width < 1900) {
$query = "INSERT INTO video_tags(video_id,tag_id) VALUES ($videoid,4)";
if ($this->conn->query($query) !== TRUE) {
echo "failed to add default tag here.\n";
$this->writeLog("failed to add default tag here.\n");
}
}
// SD
if ($width < 1250 && $width > 0) {
$query = "INSERT INTO video_tags(video_id,tag_id) VALUES ($videoid,3)";
if ($this->conn->query($query) !== TRUE) {
echo "failed to add default tag here.\n";
$this->writeLog("failed to add default tag here.\n");
}
}
}
/**
* ckecks if tag exists -- if not creates it
* @param string $tagname the name of the tag
* @return integer the id of the inserted tag
*/
private function tagExists(string $tagname) {
$query = "SELECT * FROM tags WHERE tag_name='$tagname'";
$result = $this->conn->query($query);
if ($result->num_rows == 0) {
// tag does not exist --> create it
$query = "INSERT INTO tags (tag_name) VALUES ('$tagname')";
if ($this->conn->query($query) !== TRUE) {
echo "failed to create $tagname tag in database\n";
$this->writeLog("failed to create $tagname tag in database\n");
}
return $this->conn->insert_id;
} else {
return $result->fetch_assoc()['tag_id'];
}
}
/**
* cleans up the video gravity and removes non existent videos
*/
public function cleanUpGravity() {
// auto cleanup db entries
$query = "SELECT COUNT(*) as count FROM videos";
$result = $this->conn->query($query);
$r = mysqli_fetch_assoc($result);
if ($this->all < $r['count']) {
echo "\n\nshould be in gravity: " . $this->all . "\n";
$this->writeLog("should be in gravity: " . $this->all . "\n");
echo "really in gravity: " . $r['count'] . "\n";
$this->writeLog("really in gravity: " . $r['count'] . "\n");
echo "cleaning up gravity\n";
$this->writeLog("cleaning up gravity\n");
$query = "SELECT movie_id,movie_url FROM videos";
$result = $this->conn->query($query);
while ($r = mysqli_fetch_assoc($result)) {
$movie_id = $r['movie_id'];
$url = $r['movie_url'];
// todo ORDER BY movie_url and erase duplicates also
if (!file_exists("../$url")) {
$query = "DELETE FROM videos WHERE movie_id=$movie_id";
if ($this->conn->query($query) === TRUE) {
echo("successfully deleted $url from video gravity\n");
$this->writeLog("successfully deleted $url from video gravity\n");
$this->deleted++;
} else {
echo "failed to delete $url from gravity: $this->conn->error \n";
$this->writeLog("failed to delete $url from gravity: $this->conn->error \n");
}
}
}
}
}
}

75
api/src/handlers/Actor.php
View File

@ -1,75 +0,0 @@
<?php
require_once __DIR__ . '/../SSettings.php';
require_once 'RequestBase.php';
class Actor extends RequestBase {
function initHandlers() {
$this->databaseAdds();
$this->databaseRequests();
}
function databaseAdds() {
$this->addActionHandler("createActor", function () {
// skip tag create if already existing
$actorname = $_POST["actorname"];
$query = "INSERT IGNORE INTO actors (name) VALUES ('$actorname')";
if ($this->conn->query($query) === TRUE) {
$this->commitMessage('{"result":"success"}');
} else {
$this->commitMessage('{"result":"' . $this->conn->error . '"}');
}
});
$this->addActionHandler("addActorToVideo", function () {
// skip tag create if already existing
$actorid = $_POST["actorid"];
$videoid = $_POST["videoid"];
$query = "INSERT IGNORE INTO actors_videos (actor_id, video_id) VALUES ($actorid,$videoid)";
if ($this->conn->query($query) === TRUE) {
$this->commitMessage('{"result":"success"}');
} else {
$this->commitMessage('{"result":"' . $this->conn->error . '"}');
}
});
}
function databaseRequests() {
$this->addActionHandler("getAllActors", function () {
// query the actors corresponding to video
$query = "SELECT * FROM actors";
$result = $this->conn->query($query);
$this->commitMessage(json_encode(mysqli_fetch_all($result, MYSQLI_ASSOC)));
});
$this->addActionHandler("getActorsOfVideo", function () {
// query the actors corresponding to video
$video_id = $_POST["videoid"];
$query = "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=$video_id";
$result = $this->conn->query($query);
$this->commitMessage(json_encode(mysqli_fetch_all($result, MYSQLI_ASSOC)));
});
$this->addActionHandler("getActorInfo", function (){
$actorid = $_POST["actorid"];
$query = "SELECT movie_id, movie_name FROM actors_videos
JOIN videos v on v.movie_id = actors_videos.video_id
WHERE actors_videos.actor_id=$actorid";
$result = $this->conn->query($query);
$actorinfo = $this->conn->query("SELECT name, thumbnail, actor_id FROM actors WHERE actor_id=$actorid");
$reply = array("videos" => mysqli_fetch_all($result, MYSQLI_ASSOC), "info" => mysqli_fetch_assoc($actorinfo));
$this->commitMessage(json_encode($reply));
});
}
}

50
api/src/handlers/RequestBase.php
View File

@ -1,50 +0,0 @@
<?php
require_once __DIR__ . '/../Database.php';
abstract class RequestBase {
protected $conn;
private $actions = array();
/**
* adds a new action handler to the current api file
*
* @param $action string name of the action variable
* @param $callback Closure callback function to be called
*/
function addActionHandler($action, $callback) {
$this->actions[$action] = $callback;
}
/**
* runs the correct handler
* should be called once within the api request
*/
function handleAction() {
$this->conn = Database::getInstance()->getConnection();
if (isset($_POST['action'])) {
$this->initHandlers();
$action = $_POST['action'];
// call the right handler
$this->actions[$action]();
} else {
$this->commitMessage('{"data": "error"}');
}
}
/**
* add the action handlers in this abstract method
*/
abstract function initHandlers();
/**
* Send response message and exit script
* @param $message string the response message
*/
function commitMessage($message) {
echo $message;
exit(0);
}
}

160
api/src/handlers/Settings.php
View File

@ -1,160 +0,0 @@
<?php
require_once 'RequestBase.php';
require_once __DIR__ . '/../VideoParser.php';
/**
* Class Settings
* Backend for the Settings page
*/
class Settings extends RequestBase {
function initHandlers() {
$this->getFromDB();
$this->saveToDB();
$this->reIndexHandling();
}
/**
* handle settings stuff to load from db
*/
private function getFromDB() {
/**
* load currently set settings form db for init of settings page
*/
$this->addActionHandler("loadGeneralSettings", function () {
// query settings and infotile values
$query = "
SELECT (
SELECT COUNT(*)
FROM videos
) AS videonr,
(
SELECT ROUND(SUM(data_length + index_length) / 1024 / 1024, 2) AS Size
FROM information_schema.TABLES
WHERE TABLE_SCHEMA = '" . Database::getInstance()->getDatabaseName() . "'
GROUP BY table_schema
) AS dbsize,
(
SELECT COUNT(*)
FROM tags
) AS difftagnr,
(
SELECT COUNT(*)
FROM video_tags
) AS tagsadded,
settings.*
FROM settings
LIMIT 1
";
$result = $this->conn->query($query);
$r = mysqli_fetch_assoc($result);
// booleans need to be set manually
$r['passwordEnabled'] = $r['password'] != "-1";
$r['TMDB_grabbing'] = ($r['TMDB_grabbing'] != '0');
echo json_encode($r);
});
/**
* load initial data for home page load to check if pwd is set
*/
$this->addActionHandler("loadInitialData", function () {
$query = "SELECT * from settings";
$result = $this->conn->query($query);
$r = mysqli_fetch_assoc($result);
$r['passwordEnabled'] = $r['password'] != "-1";
unset($r['password']);
$r['DarkMode'] = (bool)($r['DarkMode'] != '0');
$this->commitMessage(json_encode($r));
});
}
/**
* handle setting stuff to save to db
*/
private function saveToDB() {
/**
* save changed settings to db
*/
$this->addActionHandler("saveGeneralSettings", function () {
$mediacentername = $_POST['mediacentername'];
$password = $_POST['password'];
$videopath = $_POST['videopath'];
$tvshowpath = $_POST['tvshowpath'];
$tmdbsupport = $_POST['tmdbsupport'];
$darkmodeenabled = $_POST['darkmodeenabled'];
$query = "UPDATE settings SET
video_path='$videopath',
episode_path='$tvshowpath',
password='$password',
mediacenter_name='$mediacentername',
TMDB_grabbing=$tmdbsupport,
DarkMode=$darkmodeenabled
WHERE 1";
if ($this->conn->query($query) === true) {
$this->commitMessage('{"result": "success"}');
} else {
$this->commitMessage('{"result": "success"}');
}
});
}
/**
* methods for handling reindexing and cleanup of db gravity
*/
private function reIndexHandling() {
$this->addActionHandler("startReindex", function () {
$indexrunning = false;
if (file_exists("/tmp/output.log")) {
$out = file_get_contents("/tmp/output.log");
if (substr($out, -strlen("-42")) == "-42") {
unlink("/tmp/output.log");
} else {
$indexrunning = true;
}
}
if (!$indexrunning) {
// start extraction of video previews in background
$cmd = 'php extractvideopreviews.php';
exec(sprintf("%s > %s 2>&1 & echo $! >> %s", $cmd, '/dev/zero', '/tmp/openmediacenterpid'));
$this->commitMessage('{"result": "success"}');
} else {
$this->commitMessage('{"result": "success"}');
}
});
$this->addActionHandler("cleanupGravity", function () {
$vp = new VideoParser();
$vp->cleanUpGravity();
});
$this->addActionHandler("getStatusMessage", function () {
$return = new stdClass();
if (file_exists("/tmp/output.log")) {
$out = file_get_contents("/tmp/output.log");
// clear log file
file_put_contents("/tmp/output.log", "");
$return->message = $out;
$return->contentAvailable = true;
if (substr($out, -strlen("-42")) == "-42") {
unlink("/tmp/output.log");
}
} else {
$return->contentAvailable = false;
}
$this->commitMessage(json_encode($return));
});
}
}

101
api/src/handlers/Tags.php
View File

@ -1,101 +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 with specified id
*/
$this->addActionHandler("deleteTag", function () {
$tag_id = $_POST['tagId'];
$force = $_POST['force'];
// delete key constraints first
if ($force === "true") {
$query = "DELETE FROM video_tags WHERE tag_id=$tag_id";
if ($this->conn->query($query) !== TRUE) {
$this->commitMessage('{"result":"' . $this->conn->error . '"}');
}
}
$query = "DELETE FROM tags WHERE tag_id=$tag_id";
if ($this->conn->query($query) === TRUE) {
$this->commitMessage('{"result":"success"}');
} else {
// check if error is a constraint error
if (preg_match('/^.*a foreign key constraint fails.*$/i', $this->conn->error)) {
$this->commitMessage('{"result":"not empty tag"}');
} else {
$this->commitMessage('{"result":"' . $this->conn->eror . '"}');
}
}
});
}
}

245
api/src/handlers/Video.php
View File

@ -1,245 +0,0 @@
<?php
require_once __DIR__ . '/../SSettings.php';
require_once 'RequestBase.php';
/**
* Class Video
* backend for all interactions with videoloads and receiving of video infos
*/
class Video extends RequestBase {
private $videopath;
public function __construct() {
$settings = new SSettings();
// load video path from settings
$this->videopath = $settings->getVideoPath();
}
function initHandlers() {
$this->getVideos();
$this->loadVideos();
$this->addToVideo();
}
/**
* function handles load of all videos and search for videos
*/
private function getVideos() {
$this->addActionHandler("getMovies", function () {
$query = "SELECT movie_id,movie_name FROM videos ORDER BY create_date DESC, movie_name";
if (isset($_POST['tag'])) {
$tag = $_POST['tag'];
// if not all tags allowed filter for specific one
if (strtolower($_POST['tag']) != "all") {
$query = "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 = '$tag'
ORDER BY likes DESC, create_date, movie_name";
}
}
$result = $this->conn->query($query);
$rows = array();
while ($r = mysqli_fetch_assoc($result)) {
array_push($rows, $r);
}
$this->commitMessage(json_encode($rows));
});
$this->addActionHandler("getRandomMovies", function () {
$return = new stdClass();
$query = "SELECT movie_id,movie_name FROM videos ORDER BY RAND() LIMIT " . $_POST['number'];
$result = $this->conn->query($query);
$return->rows = array();
// get tags of random videos
$ids = [];
while ($r = mysqli_fetch_assoc($result)) {
array_push($return->rows, $r);
array_push($ids, "video_tags.video_id=" . $r['movie_id']);
}
$idstring = implode(" OR ", $ids);
$return->tags = array();
$query = "SELECT t.tag_name,t.tag_id FROM video_tags
INNER JOIN tags t on video_tags.tag_id = t.tag_id
WHERE $idstring
GROUP BY t.tag_id";
$result = $this->conn->query($query);
while ($r = mysqli_fetch_assoc($result)) {
array_push($return->tags, array('tag_name' => $r['tag_name'], 'tag_id' => $r['tag_id']));
}
$this->commitMessage(json_encode($return));
});
$this->addActionHandler("getSearchKeyWord", function () {
$search = $_POST['keyword'];
$query = "SELECT movie_id,movie_name FROM videos
WHERE movie_name LIKE '%$search%'
ORDER BY likes DESC, create_date DESC, movie_name";
$result = $this->conn->query($query);
$rows = array();
while ($r = mysqli_fetch_assoc($result)) {
array_push($rows, $r);
}
$this->commitMessage(json_encode($rows));
});
}
/**
* function to handle stuff for loading specific videos and startdata
*/
private function loadVideos() {
$this->addActionHandler("loadVideo", function () {
$video_id = $_POST['movieid'];
// todo join with actor db and add actors of movieid
$query = " SELECT movie_name,movie_id,movie_url,thumbnail,poster,likes,quality,length
FROM videos WHERE movie_id=$video_id";
$result = $this->conn->query($query);
$row = $result->fetch_assoc();
$arr = array();
if ($row["poster"] == null) {
$arr["thumbnail"] = $row["thumbnail"];
} else {
$arr["thumbnail"] = $row["poster"];
}
$arr["movie_id"] = $row["movie_id"];
$arr["movie_name"] = $row["movie_name"];
// todo drop video url from db -- maybe one with and one without extension
// extension hardcoded here!!!
$arr["movie_url"] = str_replace("?", "%3F", $this->videopath . $row["movie_name"] . ".mp4");
$arr["likes"] = (int)$row["likes"];
$arr["quality"] = $row["quality"];
$arr["length"] = $row["length"];
// load tags of this video
$arr['tags'] = array();
$query = "SELECT t.tag_name, t.tag_id FROM video_tags
INNER JOIN tags t on video_tags.tag_id = t.tag_id
WHERE video_tags.video_id=$video_id
GROUP BY t.tag_id";
$result = $this->conn->query($query);
while ($r = mysqli_fetch_assoc($result)) {
array_push($arr['tags'], $r);
}
// get the random predict tags
$arr['suggesttag'] = array();
// select 5 random tags which are not selected for current video
$query = "SELECT * FROM tags
WHERE tag_id NOT IN (
SELECT video_tags.tag_id FROM video_tags
WHERE video_id=$video_id)
ORDER BY rand()
LIMIT 5";
$result = $this->conn->query($query);
while ($r = mysqli_fetch_assoc($result)) {
array_push($arr['suggesttag'], $r);
}
// query the actors corresponding to video
$query = "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=$video_id";
$result = $this->conn->query($query);
$arr['actors'] = mysqli_fetch_all($result, MYSQLI_ASSOC);
$this->commitMessage(json_encode($arr));
});
$this->addActionHandler("readThumbnail", function () {
$query = "SELECT thumbnail FROM videos WHERE movie_id='" . $_POST['movieid'] . "'";
$result = $this->conn->query($query);
$row = $result->fetch_assoc();
$this->commitMessage($row["thumbnail"]);
});
$this->addActionHandler("getStartData", function () {
$query = "SELECT COUNT(*) as nr FROM videos";
$result = $this->conn->query($query);
$r = mysqli_fetch_assoc($result);
$arr = array();
$arr['total'] = $r['nr'];
$query = "SELECT COUNT(*) as nr 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";
$result = $this->conn->query($query);
$r = mysqli_fetch_assoc($result);
$arr['tagged'] = $r['nr'];
$query = "SELECT COUNT(*) as nr 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_name='hd'";
$result = $this->conn->query($query);
$r = mysqli_fetch_assoc($result);
$arr['hd'] = $r['nr'];
$query = "SELECT COUNT(*) as nr 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_name='fullhd'";
$result = $this->conn->query($query);
$r = mysqli_fetch_assoc($result);
$arr['fullhd'] = $r['nr'];
$query = "SELECT COUNT(*) as nr 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_name='lowquality'";
$result = $this->conn->query($query);
$r = mysqli_fetch_assoc($result);
$arr['sd'] = $r['nr'];
$query = "SELECT COUNT(*) as nr FROM tags";
$result = $this->conn->query($query);
$r = mysqli_fetch_assoc($result);
$arr['tags'] = $r['nr'];
$this->commitMessage(json_encode($arr));
});
}
/**
* function to handle api handlers for stuff to add to video or database
*/
private function addToVideo() {
$this->addActionHandler("addLike", function () {
$movieid = $_POST['movieid'];
$query = "update videos set likes = likes + 1 where movie_id = '$movieid'";
if ($this->conn->query($query) === TRUE) {
$this->commitMessage('{"result":"success"}');
} else {
$this->commitMessage('{"result":"' . $this->conn->error . '"}');
}
});
$this->addActionHandler("deleteVideo", function () {
$movieid = $_POST['movieid'];
// delete video entry and corresponding tag infos
$query = "DELETE FROM videos WHERE movie_id=$movieid";
if ($this->conn->query($query) === TRUE) {
$this->commitMessage('{"result":"success"}');
} else {
$this->commitMessage('{"result":"' . $this->conn->error . '"}');
}
});
}
}

5
api/tags.php
View File

@ -1,5 +0,0 @@
<?php
include_once __DIR__ . '/src/handlers/Tags.php';
$tags = new Tags();
$tags->handleAction();

5
api/video.php
View File

@ -1,5 +0,0 @@
<?php
include_once __DIR__ . '/src/handlers/Video.php';
$video = new Video();
$video->handleAction();

72
apiGo/api/Actors.go Normal file
View File

@ -0,0 +1,72 @@
package api
import (
"fmt"
"openmediacenter/apiGo/api/types"
"openmediacenter/apiGo/database"
)
func AddActorsHandlers() {
saveActorsToDB()
getActorsFromDB()
}
func getActorsFromDB() {
AddHandler("getAllActors", ActorNode, nil, func() []byte {
query := "SELECT actor_id, name, thumbnail FROM actors"
return jsonify(readActorsFromResultset(database.Query(query)))
})
var gaov struct {
MovieId int
}
AddHandler("getActorsOfVideo", ActorNode, &gaov, func() []byte {
query := fmt.Sprintf(`SELECT a.actor_id, name, thumbnail FROM actors_videos
JOIN actors a on actors_videos.actor_id = a.actor_id
WHERE actors_videos.video_id=%d`, gaov.MovieId)
return jsonify(readActorsFromResultset(database.Query(query)))
})
var gai struct {
ActorId int
}
AddHandler("getActorInfo", ActorNode, &gai, func() []byte {
query := fmt.Sprintf(`SELECT movie_id, movie_name FROM actors_videos
JOIN videos v on v.movie_id = actors_videos.video_id
WHERE actors_videos.actor_id=%d`, gai.ActorId)
videos := readVideosFromResultset(database.Query(query))
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 {
Videos []types.VideoUnloadedType
Info types.Actor
}{
Videos: videos,
Info: actor,
}
return jsonify(result)
})
}
func saveActorsToDB() {
var ca struct {
ActorName string
}
AddHandler("createActor", ActorNode, &ca, func() []byte {
query := "INSERT IGNORE INTO actors (name) VALUES (?)"
return database.SuccessQuery(query, ca.ActorName)
})
var aatv struct {
ActorId int
MovieId int
}
AddHandler("addActorToVideo", ActorNode, &aatv, func() []byte {
query := fmt.Sprintf("INSERT IGNORE INTO actors_videos (actor_id, video_id) VALUES (%d,%d)", aatv.ActorId, aatv.MovieId)
return database.SuccessQuery(query)
})
}

101
apiGo/api/ApiBase.go Normal file
View File

@ -0,0 +1,101 @@
package api
import (
"bytes"
"encoding/json"
"fmt"
"log"
"net/http"
)
const APIPREFIX = "/api"
const (
VideoNode = iota
TagNode = iota
SettingsNode = iota
ActorNode = iota
)
type actionStruct struct {
Action string
}
type Handler struct {
action string
handler func() []byte
arguments interface{}
apiNode int
}
var handlers []Handler
func AddHandler(action string, apiNode int, n interface{}, h func() []byte) {
// append new handler to the handlers
handlers = append(handlers, Handler{action, h, n, apiNode})
}
func ServerInit(port uint16) {
http.Handle(APIPREFIX+"/video", http.HandlerFunc(videoHandler))
http.Handle(APIPREFIX+"/tags", http.HandlerFunc(tagHandler))
http.Handle(APIPREFIX+"/settings", http.HandlerFunc(settingsHandler))
http.Handle(APIPREFIX+"/actor", http.HandlerFunc(actorHandler))
fmt.Printf("OpenMediacenter server up and running on port %d\n", port)
log.Fatal(http.ListenAndServe(fmt.Sprintf(":%d", port), nil))
}
func handleAPICall(action string, requestBody string, apiNode int) []byte {
for i := range handlers {
if handlers[i].action == action && handlers[i].apiNode == apiNode {
// call the handler and return
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
}
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 handlefunc(rw http.ResponseWriter, req *http.Request, node int) {
// only allow post requests
if req.Method != "POST" {
return
}
buf := new(bytes.Buffer)
buf.ReadFrom(req.Body)
body := buf.String()
var t actionStruct
err := json.Unmarshal([]byte(body), &t)
if err != nil {
fmt.Println("failed to read action from request! :: " + body)
}
rw.Write(handleAPICall(t.Action, body, node))
}

66
apiGo/api/ApiBase_test.go Normal file
View File

@ -0,0 +1,66 @@
package api
import (
"testing"
)
func cleanUp() {
handlers = nil
}
func TestAddHandler(t *testing.T) {
cleanUp()
AddHandler("test", ActorNode, nil, func() []byte {
return nil
})
if len(handlers) != 1 {
t.Errorf("Handler insertion failed, got: %d handlers, want: %d.", len(handlers), 1)
}
}
func TestCallOfHandler(t *testing.T) {
cleanUp()
i := 0
AddHandler("test", ActorNode, nil, func() []byte {
i++
return nil
})
// simulate the call of the api
handleAPICall("test", "", ActorNode)
if i != 1 {
t.Errorf("Unexpected number of Lambda calls : %d/1", i)
}
}
func TestDecodingOfArguments(t *testing.T) {
cleanUp()
var myvar struct {
Test string
TestInt int
}
AddHandler("test", ActorNode, &myvar, func() []byte {
return nil
})
// simulate the call of the api
handleAPICall("test", `{"Test":"myString","TestInt":42}`, ActorNode)
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)
if ret != nil {
t.Error("Expect nil return within unhandled api action")
}
}

71
apiGo/api/Helpers.go Normal file
View File

@ -0,0 +1,71 @@
package api
import (
"database/sql"
"encoding/json"
"fmt"
"openmediacenter/apiGo/api/types"
)
// MovieId - MovieName : pay attention to the order!
func readVideosFromResultset(rows *sql.Rows) []types.VideoUnloadedType {
result := []types.VideoUnloadedType{}
for rows.Next() {
var vid types.VideoUnloadedType
err := rows.Scan(&vid.MovieId, &vid.MovieName)
if err != nil {
panic(err.Error()) // proper error handling instead of panic in your app
}
result = append(result, vid)
}
rows.Close()
return result
}
// TagID - TagName : pay attention to the order!
func readTagsFromResultset(rows *sql.Rows) []types.Tag {
// initialize with empty array!
result := []types.Tag{}
for rows.Next() {
var tag types.Tag
err := rows.Scan(&tag.TagId, &tag.TagName)
if err != nil {
panic(err.Error()) // proper error handling instead of panic in your app
}
result = append(result, tag)
}
rows.Close()
return result
}
// ActorId - ActorName - Thumbnail : pay attention to the order!
func readActorsFromResultset(rows *sql.Rows) []types.Actor {
var result []types.Actor
for rows.Next() {
var actor types.Actor
var thumbnail []byte
err := rows.Scan(&actor.ActorId, &actor.Name, &thumbnail)
if len(thumbnail) != 0 {
actor.Thumbnail = string(thumbnail)
}
if err != nil {
panic(err.Error()) // proper error handling instead of panic in your app
}
result = append(result, actor)
}
rows.Close()
return result
}
func jsonify(v interface{}) []byte {
// jsonify results
str, err := json.Marshal(v)
if err != nil {
fmt.Println("Error while Jsonifying return object: " + err.Error())
}
return str
}

94
apiGo/api/Settings.go Normal file
View File

@ -0,0 +1,94 @@
package api
import (
"encoding/json"
"fmt"
"openmediacenter/apiGo/api/types"
"openmediacenter/apiGo/database"
"openmediacenter/apiGo/videoparser"
)
func AddSettingsHandlers() {
saveSettingsToDB()
getSettingsFromDB()
reIndexHandling()
}
func getSettingsFromDB() {
AddHandler("loadInitialData", SettingsNode, nil, func() []byte {
query := "SELECT DarkMode, password, mediacenter_name, video_path from settings"
type InitialDataType struct {
DarkMode int
Pasword int
Mediacenter_name string
VideoPath string
}
result := InitialDataType{}
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())
}
type InitialDataTypeResponse struct {
DarkMode bool
Pasword bool
Mediacenter_name string
VideoPath string
}
res := InitialDataTypeResponse{
DarkMode: result.DarkMode != 0,
Pasword: result.Pasword != -1,
Mediacenter_name: result.Mediacenter_name,
VideoPath: result.VideoPath,
}
str, _ := json.Marshal(res)
return str
})
AddHandler("loadGeneralSettings", SettingsNode, nil, func() []byte {
result := database.GetSettings()
return jsonify(result)
})
}
func saveSettingsToDB() {
var sgs struct {
Settings types.SettingsType
}
AddHandler("saveGeneralSettings", SettingsNode, &sgs, func() []byte {
query := `
UPDATE settings SET
video_path=?,
episode_path=?,
password=?,
mediacenter_name=?,
TMDB_grabbing=?,
DarkMode=?
WHERE 1`
return database.SuccessQuery(query,
sgs.Settings.VideoPath, sgs.Settings.EpisodePath, sgs.Settings.Password,
sgs.Settings.MediacenterName, sgs.Settings.TMDBGrabbing, sgs.Settings.DarkMode)
})
}
// methods for handling reindexing and cleanup of db gravity
func reIndexHandling() {
AddHandler("startReindex", SettingsNode, nil, func() []byte {
videoparser.StartReindex()
return database.ManualSuccessResponse(nil)
})
AddHandler("cleanupGravity", SettingsNode, nil, func() []byte {
videoparser.StartCleanup()
return nil
})
AddHandler("getStatusMessage", SettingsNode, nil, func() []byte {
return jsonify(videoparser.GetStatusMessage())
})
}

74
apiGo/api/Tags.go Normal file
View File

@ -0,0 +1,74 @@
package api
import (
"fmt"
"openmediacenter/apiGo/database"
"regexp"
)
func AddTagHandlers() {
getFromDB()
addToDB()
deleteFromDB()
}
func deleteFromDB() {
var dT struct {
TagId int
Force bool
}
AddHandler("deleteTag", TagNode, &dT, func() []byte {
// delete key constraints first
if dT.Force {
query := fmt.Sprintf("DELETE FROM video_tags WHERE tag_id=%d", dT.TagId)
err := database.Edit(query)
// respond only if result not successful
if err != nil {
return database.ManualSuccessResponse(err)
}
}
query := fmt.Sprintf("DELETE FROM tags WHERE tag_id=%d", dT.TagId)
err := database.Edit(query)
if err == nil {
// return if successful
return database.ManualSuccessResponse(err)
} else {
// check with regex if its the key constraint error
r, _ := regexp.Compile("^.*a foreign key constraint fails.*$")
if r.MatchString(err.Error()) {
return []byte(`{"result":"not empty tag"}`)
} else {
return database.ManualSuccessResponse(err)
}
}
})
}
func getFromDB() {
AddHandler("getAllTags", TagNode, nil, func() []byte {
query := "SELECT tag_id,tag_name from tags"
return jsonify(readTagsFromResultset(database.Query(query)))
})
}
func addToDB() {
var ct struct {
TagName string
}
AddHandler("createTag", TagNode, &ct, func() []byte {
query := "INSERT IGNORE INTO tags (tag_name) VALUES (?)"
return database.SuccessQuery(query, ct.TagName)
})
var at struct {
MovieId int
TagId int
}
AddHandler("addTag", TagNode, &at, func() []byte {
query := "INSERT IGNORE INTO video_tags(tag_id, video_id) VALUES (?,?)"
return database.SuccessQuery(query, at.TagId, at.MovieId)
})
}

233
apiGo/api/Video.go Normal file
View File

@ -0,0 +1,233 @@
package api
import (
"encoding/json"
"fmt"
"net/url"
"openmediacenter/apiGo/api/types"
"openmediacenter/apiGo/database"
"strconv"
)
func AddVideoHandlers() {
getVideoHandlers()
loadVideosHandlers()
addToVideoHandlers()
}
func getVideoHandlers() {
var mrq struct {
Tag int
}
AddHandler("getMovies", VideoNode, &mrq, func() []byte {
var query string
// 1 is the id of the ALL tag
if mrq.Tag != 1 {
query = fmt.Sprintf(`SELECT movie_id,movie_name FROM videos
INNER JOIN video_tags vt on videos.movie_id = vt.video_id
INNER JOIN tags t on vt.tag_id = t.tag_id
WHERE t.tag_id = '%d'
ORDER BY likes DESC, create_date, movie_name`, mrq.Tag)
} else {
query = "SELECT movie_id,movie_name FROM videos ORDER BY create_date DESC, movie_name"
}
result := readVideosFromResultset(database.Query(query))
// jsonify results
str, _ := json.Marshal(result)
return str
})
var rtn struct {
Movieid int
}
AddHandler("readThumbnail", VideoNode, &rtn, func() []byte {
var pic []byte
query := fmt.Sprintf("SELECT thumbnail FROM videos WHERE movie_id='%d'", rtn.Movieid)
err := database.QueryRow(query).Scan(&pic)
if err != nil {
fmt.Printf("the thumbnail of movie id %d couldn't be found", rtn.Movieid)
return nil
}
return pic
})
var grm struct {
Number int
}
AddHandler("getRandomMovies", VideoNode, &grm, func() []byte {
var result struct {
Tags []types.Tag
Videos []types.VideoUnloadedType
}
query := fmt.Sprintf("SELECT movie_id,movie_name FROM videos ORDER BY RAND() LIMIT %d", grm.Number)
result.Videos = readVideosFromResultset(database.Query(query))
var ids string
for i := range result.Videos {
ids += "video_tags.video_id=" + strconv.Itoa(result.Videos[i].MovieId)
if i < len(result.Videos)-1 {
ids += " OR "
}
}
// add the corresponding tags
query = fmt.Sprintf(`SELECT t.tag_name,t.tag_id FROM video_tags
INNER JOIN tags t on video_tags.tag_id = t.tag_id
WHERE %s
GROUP BY t.tag_id`, ids)
rows := database.Query(query)
for rows.Next() {
var tag types.Tag
err := rows.Scan(&tag.TagName, &tag.TagId)
if err != nil {
panic(err.Error()) // proper error handling instead of panic in your app
}
// append to final array
result.Tags = append(result.Tags, tag)
}
// jsonify results
str, _ := json.Marshal(result)
return str
})
var gsk struct {
KeyWord string
}
AddHandler("getSearchKeyWord", VideoNode, &gsk, func() []byte {
query := fmt.Sprintf(`SELECT movie_id,movie_name FROM videos
WHERE movie_name LIKE '%%%s%%'
ORDER BY likes DESC, create_date DESC, movie_name`, gsk.KeyWord)
result := readVideosFromResultset(database.Query(query))
// jsonify results
str, _ := json.Marshal(result)
return str
})
}
// function to handle stuff for loading specific videos and startdata
func loadVideosHandlers() {
var lv struct {
MovieId int
}
AddHandler("loadVideo", VideoNode, &lv, func() []byte {
query := fmt.Sprintf(`SELECT movie_name,movie_url,movie_id,thumbnail,poster,likes,quality,length
FROM videos WHERE movie_id=%d`, lv.MovieId)
var res types.FullVideoType
var poster []byte
var thumbnail []byte
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.Println(err.Error())
return nil
}
// we ned to urlencode the movieurl
res.MovieUrl = url.PathEscape(res.MovieUrl)
// we need to stringify the pic byte array
res.Poster = string(poster)
// if poster in db is empty we use the thumbnail
if res.Poster == "" {
res.Poster = string(thumbnail)
}
// now add the tags of this video
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)
res.Tags = readTagsFromResultset(database.Query(query))
query = fmt.Sprintf(`SELECT * FROM tags
WHERE tag_id NOT IN (
SELECT video_tags.tag_id FROM video_tags
WHERE video_id=%d)
ORDER BY rand()
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`, lv.MovieId)
res.Actors = readActorsFromResultset(database.Query(query))
// jsonify results
str, _ := json.Marshal(res)
return str
})
AddHandler("getStartData", VideoNode, nil, func() []byte {
var result types.StartData
// query settings and infotile values
query := `
SELECT (
SELECT COUNT(*) FROM videos
) AS videonr,
(
SELECT COUNT(*) 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
) AS tagged,
(
SELECT COUNT(*) FROM video_tags as vt
INNER JOIN tags t on vt.tag_id = t.tag_id
WHERE t.tag_name='hd'
) AS hd,
(
SELECT COUNT(*) FROM video_tags as vt
INNER JOIN tags t on vt.tag_id = t.tag_id
WHERE t.tag_name='fullhd'
) AS fullhd,
(
SELECT COUNT(*) FROM video_tags as vt
INNER JOIN tags t on vt.tag_id = t.tag_id
WHERE t.tag_name='lowquality'
) AS lq,
(
SELECT COUNT(*) as nr FROM tags
) as tags
LIMIT 1`
_ = database.QueryRow(query).Scan(&result.VideoNr, &result.Tagged, &result.HDNr, &result.FullHdNr, &result.SDNr, &result.DifferentTags)
// jsonify results
str, _ := json.Marshal(result)
return str
})
}
func addToVideoHandlers() {
var al struct {
MovieId int
}
AddHandler("addLike", VideoNode, &al, func() []byte {
query := fmt.Sprintf("update videos set likes = likes + 1 where movie_id = %d", al.MovieId)
return database.SuccessQuery(query)
})
var dv struct {
MovieId int
}
AddHandler("deleteVideo", VideoNode, &dv, func() []byte {
query := fmt.Sprintf("DELETE FROM videos WHERE movie_id=%d", dv.MovieId)
return database.SuccessQuery(query)
})
}

56
apiGo/api/types/Types.go Normal file
View File

@ -0,0 +1,56 @@
package types
type VideoUnloadedType struct {
MovieId int
MovieName string
}
type FullVideoType struct {
MovieName string
MovieId int
MovieUrl string
Poster string
Likes int
Quality int
Length int
Tags []Tag
SuggestedTag []Tag
Actors []Actor
}
type Tag struct {
TagName string
TagId int
}
type Actor struct {
ActorId int
Name string
Thumbnail string
}
type StartData struct {
VideoNr int
FullHdNr int
HDNr int
SDNr int
DifferentTags int
Tagged int
}
type SettingsType struct {
VideoPath string
EpisodePath string
MediacenterName string
Password string
PasswordEnabled bool
TMDBGrabbing bool
DarkMode bool
VideoNr int
DBSize float32
DifferentTags int
TagsAdded int
PathPrefix string
}

136
apiGo/database/Database.go Normal file
View File

@ -0,0 +1,136 @@
package database
import (
"database/sql"
"fmt"
_ "github.com/go-sql-driver/mysql"
"openmediacenter/apiGo/api/types"
)
var db *sql.DB
var DBName string
// store the command line parameter for Videoprefix
var SettingsVideoPrefix = ""
type DatabaseConfig struct {
DBHost string
DBPort int
DBUser string
DBPassword string
DBName string
}
func InitDB(dbconf *DatabaseConfig) {
DBName = dbconf.DBName
// Open up our database connection.
var err error
db, err = sql.Open("mysql", fmt.Sprintf("%s:%s@tcp(%s:%d)/%s", dbconf.DBUser, dbconf.DBPassword, dbconf.DBHost, dbconf.DBPort, dbconf.DBName))
// if there is an error opening the connection, handle it
if err != nil {
fmt.Printf("Error while connecting to database! - %s\n", err.Error())
}
if db != nil {
ping := db.Ping()
if ping != nil {
fmt.Printf("Error while connecting to database! - %s\n", ping.Error())
}
}
}
func Query(query string, args ...interface{}) *sql.Rows {
// perform a db.Query insert
res, err := db.Query(query, args...)
// if there is an error inserting, handle it
if err != nil {
fmt.Printf("Error while requesting data! - %s\n", err.Error())
}
return res
}
func QueryRow(SQL string, args ...interface{}) *sql.Row {
return db.QueryRow(SQL, args...)
}
// edit something in the DB and give only an error response
func Edit(query string, args ...interface{}) error {
_, err := db.Exec(query, args...)
return err
}
// insert/edit a query and return last insert id
func Insert(query string, args ...interface{}) (error, int64) {
resp, err := db.Exec(query, args...)
var id int64 = 0
if err == nil {
id, err = resp.LastInsertId()
}
return err, id
}
func SuccessQuery(query string, args ...interface{}) []byte {
return ManualSuccessResponse(Edit(query, args...))
}
func ManualSuccessResponse(err error) []byte {
if err == nil {
return []byte(`{"result":"success"}`)
} else {
return []byte(fmt.Sprintf(`{"result":"%s"}`, err.Error()))
}
}
func Close() {
db.Close()
}
func GetSettings() types.SettingsType {
var result types.SettingsType
// query settings and infotile values
query := fmt.Sprintf(`
SELECT (
SELECT COUNT(*)
FROM videos
) AS videonr,
(
SELECT ROUND(SUM(data_length + index_length) / 1024 / 1024, 2) AS Size
FROM information_schema.TABLES
WHERE TABLE_SCHEMA = '%s'
GROUP BY table_schema
) AS dbsize,
(
SELECT COUNT(*)
FROM tags
) AS difftagnr,
(
SELECT COUNT(*)
FROM video_tags
) AS tagsadded,
video_path, episode_path, password, mediacenter_name, TMDB_grabbing, DarkMode
FROM settings
LIMIT 1`, DBName)
var DarkMode int
var TMDBGrabbing int
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 {
fmt.Println(err.Error())
}
result.TMDBGrabbing = TMDBGrabbing != 0
result.PasswordEnabled = result.Password != "-1"
result.DarkMode = DarkMode != 0
result.PathPrefix = SettingsVideoPrefix
return result
}

5
apiGo/go.mod Normal file
View File

@ -0,0 +1,5 @@
module openmediacenter/apiGo
go 1.16
require github.com/go-sql-driver/mysql v1.5.0

2
apiGo/go.sum Normal file
View File

@ -0,0 +1,2 @@
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=

53
apiGo/main.go Normal file
View File

@ -0,0 +1,53 @@
package main
import (
"flag"
"fmt"
"openmediacenter/apiGo/api"
"openmediacenter/apiGo/database"
)
func main() {
fmt.Println("init OpenMediaCenter server")
db, verbose, pathPrefix := handleCommandLineArguments()
// todo some verbosity logger or sth
fmt.Printf("Use verbose output: %t\n", verbose)
fmt.Printf("Videopath prefix: %s\n", *pathPrefix)
// set pathprefix in database settings object
database.SettingsVideoPrefix = *pathPrefix
database.InitDB(db)
defer database.Close()
api.AddVideoHandlers()
api.AddSettingsHandlers()
api.AddTagHandlers()
api.AddActorsHandlers()
api.ServerInit(8081)
}
func handleCommandLineArguments() (*database.DatabaseConfig, bool, *string) {
dbhostPtr := flag.String("DBHost", "127.0.0.1", "database host name")
dbPortPtr := flag.Int("DBPort", 3306, "database port")
dbUserPtr := flag.String("DBUser", "mediacenteruser", "database username")
dbPassPtr := flag.String("DBPassword", "mediapassword", "database username")
dbNamePtr := flag.String("DBName", "mediacenter", "database name")
verbosePtr := flag.Bool("v", true, "Verbose log output")
pathPrefix := flag.String("ReindexPrefix", "/var/www/openmediacenter", "Prefix path for videos to reindex")
flag.Parse()
return &database.DatabaseConfig{
DBHost: *dbhostPtr,
DBPort: *dbPortPtr,
DBUser: *dbUserPtr,
DBPassword: *dbPassPtr,
DBName: *dbNamePtr,
}, *verbosePtr, pathPrefix
}

1
apiGo/videoparser/CleanUp.go Normal file
View File

@ -0,0 +1 @@
package videoparser

294
apiGo/videoparser/ReIndex.go Normal file
View File

@ -0,0 +1,294 @@
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"
)
var mSettings types.SettingsType
var mExtDepsAvailable *ExtDependencySupport
// default Tag ids
const (
FullHd = 2
Hd = 4
LowQuality = 3
)
type ExtDependencySupport struct {
FFMpeg bool
MediaInfo bool
}
type VideoAttributes struct {
Duration float32
FileSize uint
Width uint
}
func ReIndexVideos(path []string, sett types.SettingsType) {
mSettings = sett
// check if the extern dependencies are available
mExtDepsAvailable = checkExtDependencySupport()
fmt.Printf("FFMPEG support: %t\n", mExtDepsAvailable.FFMpeg)
fmt.Printf("MediaInfo support: %t\n", mExtDepsAvailable.MediaInfo)
for _, s := range path {
processVideo(s)
}
AppendMessageBuffer("reindex finished successfully!")
contentAvailable = false
fmt.Println("Reindexing finished!")
}
func processVideo(fileNameOrig string) {
fmt.Printf("Processing %s video-", fileNameOrig)
// match the file extension
r, _ := regexp.Compile(`\.[a-zA-Z0-9]+$`)
fileName := r.ReplaceAllString(fileNameOrig, "")
year, fileName := matchYear(fileName)
// now we should look if this video already exists in db
query := "SELECT * FROM videos WHERE movie_name = ?"
err := database.QueryRow(query, fileName).Scan()
if err == sql.ErrNoRows {
fmt.Printf("The Video %s does't exist! Adding it to database.\n", fileName)
addVideo(fileName, fileNameOrig, year)
} else {
fmt.Println(" :existing!")
}
}
// add a video to the database
func addVideo(videoName string, fileName string, year int) {
var ppic *string
var poster *string
var tmdbData *tmdb.VideoTMDB
var err error
// initialize defaults
vidAtr := &VideoAttributes{
Duration: 0,
FileSize: 0,
Width: 0,
}
if mExtDepsAvailable.FFMpeg {
ppic, err = parseFFmpegPic(fileName)
if err != nil {
fmt.Printf("FFmpeg error occured: %s\n", err.Error())
} else {
fmt.Println("successfully extracted thumbnail!!")
}
}
if mExtDepsAvailable.MediaInfo {
atr := getVideoAttributes(fileName)
if atr != nil {
vidAtr = atr
}
}
// if TMDB grabbing is enabled serach in api for video...
if mSettings.TMDBGrabbing {
tmdbData = tmdb.SearchVideo(videoName, year)
if tmdbData != nil {
// reassign parsed pic as poster
poster = ppic
// and tmdb pic as thumbnail
ppic = &tmdbData.Thumbnail
}
}
query := `INSERT INTO videos(movie_name,movie_url,poster,thumbnail,quality,length) VALUES (?,?,?,?,?,?)`
err, insertId := database.Insert(query, videoName, fileName, poster, ppic, vidAtr.Width, vidAtr.Duration)
if err != nil {
fmt.Printf("Failed to insert video into db: %s\n", err.Error())
return
}
// add default tags
if vidAtr.Width != 0 {
insertSizeTag(vidAtr.Width, uint(insertId))
}
// add tmdb tags
if mSettings.TMDBGrabbing && tmdbData != nil {
insertTMDBTags(tmdbData.GenreIds, insertId)
}
AppendMessageBuffer(fmt.Sprintf("%s - added!", videoName))
}
func matchYear(fileName string) (int, string) {
r, _ := regexp.Compile(`\([0-9]{4}?\)`)
years := r.FindAllString(fileName, -1)
if len(years) == 0 {
return -1, fileName
}
year, err := strconv.Atoi(years[len(years)-1])
if err != nil {
return -1, fileName
}
// cut out year from filename
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
}
backpic64 := "data:image/jpeg;base64," + base64.StdEncoding.EncodeToString(stdout)
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
if width >= 1080 {
tagType = FullHd
} else if width >= 720 {
tagType = Hd
} else {
tagType = LowQuality
}
query := fmt.Sprintf("INSERT INTO video_tags(video_id,tag_id) VALUES (%d,%d)", videoId, tagType)
err := database.Edit(query)
if err != nil {
fmt.Printf("Eror occured while adding default Tag: %s\n", err.Error())
}
}
// insert id array of tmdb geners to database
func insertTMDBTags(ids []int, videoId int64) {
genres := tmdb.GetGenres()
for _, id := range ids {
var idGenre *tmdb.TMDBGenre
for _, genre := range *genres {
if genre.Id == id {
idGenre = &genre
break
}
}
// skip tag if name couldn't be found
if idGenre == nil {
continue
}
// now we check if the tag we want to add already exists
tagId := createTagToDB(idGenre.Name)
// now we add the tag
query := fmt.Sprintf("INSERT INTO video_tags(video_id,tag_id) VALUES (%d,%d)", videoId, tagId)
_ = database.Edit(query)
}
}
// returns id of tag or creates it if not existing
func createTagToDB(tagName string) int64 {
query := fmt.Sprintf("SELECT tag_id FROM tags WHERE tag_name = %s", tagName)
var id int64
err := database.QueryRow(query).Scan(&id)
if err == sql.ErrNoRows {
// tag doesn't exist -- add it
query = fmt.Sprintf("INSERT INTO tags (tag_name) VALUES (%s)", tagName)
err, id = database.Insert(query)
}
return id
}

70
apiGo/videoparser/VideoParser.go Normal file
View File

@ -0,0 +1,70 @@
package videoparser
import (
"fmt"
"openmediacenter/apiGo/database"
"os"
"path/filepath"
"strings"
)
var messageBuffer []string
var contentAvailable = false
type StatusMessage struct {
Messages []string
ContentAvailable bool
}
func StartReindex() bool {
messageBuffer = []string{}
contentAvailable = true
fmt.Println("starting reindex..")
mSettings := database.GetSettings()
// add the path prefix to 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!")
return false
}
var files []string
err := filepath.Walk(mSettings.VideoPath, func(path string, info os.FileInfo, err error) error {
if err != nil {
fmt.Println(err.Error())
return err
}
if !info.IsDir() && strings.HasSuffix(info.Name(), ".mp4") {
files = append(files, info.Name())
}
return nil
})
if err != nil {
fmt.Println(err.Error())
}
// start reindex process
AppendMessageBuffer("Starting Reindexing!")
go ReIndexVideos(files, mSettings)
return true
}
func GetStatusMessage() *StatusMessage {
msg := StatusMessage{
Messages: messageBuffer,
ContentAvailable: contentAvailable,
}
messageBuffer = []string{}
return &msg
}
func StartCleanup() {
// todo start cleanup
}

144
apiGo/videoparser/tmdb/TMDBApi.go Normal file
View File

@ -0,0 +1,144 @@
package tmdb
import (
"encoding/base64"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
"regexp"
)
const apiKey = "9fd90530b11447f5646f8e6fb4733fb4"
const baseUrl = "https://api.themoviedb.org/3/"
const pictureBase = "https://image.tmdb.org/t/p/w500"
type VideoTMDB struct {
Thumbnail string
Overview string
Title string
GenreIds []int
}
type tmdbVidResult struct {
Poster_path string
Adult bool
Overview string
Release_date string
Genre_ids []int
Id int
Original_title string
Original_language string
Title string
Backdrop_path string
Popularity int
Vote_count int
Video bool
Vote_average int
}
type TMDBGenre struct {
Id int
Name string
}
func SearchVideo(MovieName string, year int) *VideoTMDB {
url := fmt.Sprintf("%ssearch/movie?api_key=%s&query=%s", baseUrl, apiKey, MovieName)
resp, err := http.Get(url)
if err != nil {
fmt.Println(err.Error())
return nil
}
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err.Error())
return nil
}
var t struct {
Results []tmdbVidResult
}
err = json.Unmarshal(body, &t)
fmt.Println(len(t.Results))
var tmdbVid tmdbVidResult
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.Release_date) {
tmdbVid = result
// continue parsing
goto cont
}
}
// if there is no match use first one
tmdbVid = t.Results[0]
} else {
tmdbVid = t.Results[0]
}
// continue label
cont:
thumbnail := fetchPoster(tmdbVid)
result := VideoTMDB{
Thumbnail: *thumbnail,
Overview: tmdbVid.Overview,
Title: tmdbVid.Title,
GenreIds: tmdbVid.Genre_ids,
}
return &result
}
func fetchPoster(vid tmdbVidResult) *string {
url := fmt.Sprintf("%s%s", pictureBase, vid.Poster_path)
resp, err := http.Get(url)
if err != nil {
fmt.Println(err.Error())
return nil
}
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err.Error())
return nil
}
backpic64 := "data:image/jpeg;base64," + base64.StdEncoding.EncodeToString(body)
return &backpic64
}
var tmdbGenres *[]TMDBGenre
func fetchGenres() *[]TMDBGenre {
url := fmt.Sprintf("%sgenre/movie/list?api_key=%s", baseUrl, apiKey)
resp, err := http.Get(url)
if err != nil {
fmt.Println(err.Error())
return nil
}
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err.Error())
return nil
}
var t []TMDBGenre
err = json.Unmarshal(body, &t)
return &t
}
func GetGenres() *[]TMDBGenre {
// if generes are nil fetch them once
if tmdbGenres == nil {
tmdbGenres = fetchGenres()
}
return tmdbGenres
}

2
deb/OpenMediaCenter/DEBIAN/control
View File

@ -1,5 +1,5 @@
Package: OpenMediaCenter Package: OpenMediaCenter
Depends: nginx, php-fpm, php-mysqli, mariadb-server Depends: nginx, mariadb-server, mediainfo
Section: web Section: web
Priority: optional Priority: optional
Architecture: all Architecture: all

19
deb/OpenMediaCenter/DEBIAN/postinst
View File

@ -2,20 +2,6 @@
# enable nginx site # enable nginx site
ln -sf /etc/nginx/sites-available/OpenMediaCenter.conf /etc/nginx/sites-enabled/OpenMediaCenter.conf ln -sf /etc/nginx/sites-available/OpenMediaCenter.conf /etc/nginx/sites-enabled/OpenMediaCenter.conf
# link general socket to current one
phpsymlink="/var/run/php/php-fpm.sock";
# create a gneral symlink to the php socket if not already existing
if [ -L ${phpsymlink} ] ; then
if [ -e ${phpsymlink} ] ; then
echo "general php symlink already exists."
else
ln -sf /var/run/php/php*.*-fpm.sock /var/run/php/php-fpm.sock
fi
else
ln -sf /var/run/php/php*.*-fpm.sock /var/run/php/php-fpm.sock
fi
# setup database # setup database
mysql -uroot -pPASS -e "CREATE DATABASE IF NOT EXISTS mediacenter;" mysql -uroot -pPASS -e "CREATE DATABASE IF NOT EXISTS mediacenter;"
mysql -uroot -pPASS -e "CREATE USER IF NOT EXISTS 'mediacenteruser'@'localhost' IDENTIFIED BY 'mediapassword';" mysql -uroot -pPASS -e "CREATE USER IF NOT EXISTS 'mediacenteruser'@'localhost' IDENTIFIED BY 'mediapassword';"
@ -31,6 +17,5 @@ chown -R www-data:www-data /var/www/openmediacenter
# restart services # restart services
systemctl restart nginx systemctl restart nginx
# trigger a movie reindex systemctl enable OpenMediaCenter.service
php /var/www/openmediacenter/api/extractvideopreviews.php systemctl start OpenMediaCenter.service
rm /tmp/output.log

6
deb/OpenMediaCenter/etc/nginx/sites-available/OpenMediaCenter.conf
View File

@ -13,9 +13,7 @@ server {
try_files $uri /index.html; try_files $uri /index.html;
} }
location ~ \.php$ { location /api/ {
include snippets/fastcgi-php.conf; proxy_pass http://127.0.0.1:8081;
fastcgi_pass unix:/var/run/php/php-fpm.sock;
} }
} }

12
deb/OpenMediaCenter/lib/systemd/system/OpenMediaCenter.service Normal file
View File

@ -0,0 +1,12 @@
[Unit]
Description=OpenMediaCenter start job
After=network.target
[Service]
Type=simple
ExecStart=openmediacenter
Restart=always
User=root
[Install]
WantedBy=default.target

19522
package-lock.json generated
View File

File diff suppressed because it is too large Load Diff

6
package.json
View File

@ -37,7 +37,7 @@
"text-summary" "text-summary"
] ]
}, },
"proxy": "http://192.168.0.209", "proxy": "http://127.0.0.1:8081",
"homepage": "/", "homepage": "/",
"eslintConfig": { "eslintConfig": {
"extends": [ "extends": [
@ -72,12 +72,12 @@
"@testing-library/jest-dom": "^5.11.6", "@testing-library/jest-dom": "^5.11.6",
"@testing-library/react": "^11.2.2", "@testing-library/react": "^11.2.2",
"@testing-library/user-event": "^12.6.0", "@testing-library/user-event": "^12.6.0",
"@types/react-router-dom": "^5.1.6",
"@types/react-router": "5.1.8",
"@types/jest": "^26.0.19", "@types/jest": "^26.0.19",
"@types/node": "^12.19.9", "@types/node": "^12.19.9",
"@types/react": "^16.14.2", "@types/react": "^16.14.2",
"@types/react-dom": "^16.9.10", "@types/react-dom": "^16.9.10",
"@types/react-router": "5.1.8",
"@types/react-router-dom": "^5.1.6",
"enzyme": "^3.11.0", "enzyme": "^3.11.0",
"enzyme-adapter-react-16": "^1.15.5", "enzyme-adapter-react-16": "^1.15.5",
"jest-junit": "^12.0.0", "jest-junit": "^12.0.0",

8
src/App.tsx
View File

@ -45,14 +45,16 @@ class App extends React.Component<{}, state> {
// set theme // set theme
GlobalInfos.enableDarkTheme(result.DarkMode); GlobalInfos.enableDarkTheme(result.DarkMode);
GlobalInfos.setVideoPath(result.VideoPath);
this.setState({ this.setState({
generalSettingsLoaded: true, generalSettingsLoaded: true,
passwordsupport: result.passwordEnabled, passwordsupport: result.Password,
mediacentername: result.mediacenter_name, mediacentername: result.Mediacenter_name,
onapierror: false onapierror: false
}); });
// set tab title to received mediacenter name // set tab title to received mediacenter name
document.title = result.mediacenter_name; document.title = result.Mediacenter_name;
}, error => { }, error => {
this.setState({onapierror: true}); this.setState({onapierror: true});
}); });

4
src/elements/ActorTile/ActorTile.test.js
View File

@ -4,13 +4,13 @@ import ActorTile from './ActorTile';
describe('<ActorTile/>', function () { describe('<ActorTile/>', function () {
it('renders without crashing ', function () { it('renders without crashing ', function () {
const wrapper = shallow(<ActorTile actor={{thumbnail: '-1', name: 'testname', id: 3}}/>); const wrapper = shallow(<ActorTile actor={{Thumbnail: '-1', Name: 'testname', id: 3}}/>);
wrapper.unmount(); wrapper.unmount();
}); });
it('simulate click with custom handler', function () { it('simulate click with custom handler', function () {
const func = jest.fn((_) => {}); const func = jest.fn((_) => {});
const wrapper = shallow(<ActorTile actor={{thumbnail: '-1', name: 'testname', id: 3}} onClick={() => func()}/>); const wrapper = shallow(<ActorTile actor={{Thumbnail: '-1', Name: 'testname', id: 3}} onClick={() => func()}/>);
const func1 = jest.fn(); const func1 = jest.fn();
prepareViewBinding(func1); prepareViewBinding(func1);

6
src/elements/ActorTile/ActorTile.tsx
View File

@ -22,7 +22,7 @@ class ActorTile extends React.Component<props> {
return this.renderActorTile(this.props.onClick); return this.renderActorTile(this.props.onClick);
} else { } else {
return ( return (
<Link to={{pathname: '/actors/' + this.props.actor.actor_id}}> <Link to={{pathname: '/actors/' + this.props.actor.ActorId}}>
{this.renderActorTile(() => { {this.renderActorTile(() => {
})} })}
</Link> </Link>
@ -34,11 +34,11 @@ class ActorTile extends React.Component<props> {
return ( return (
<div className={style.actortile} onClick={(): void => customclickhandler(this.props.actor)}> <div className={style.actortile} onClick={(): void => customclickhandler(this.props.actor)}>
<div className={style.actortile_thumbnail}> <div className={style.actortile_thumbnail}>
{this.props.actor.thumbnail === null ? <FontAwesomeIcon style={{ {this.props.actor.Thumbnail === '' ? <FontAwesomeIcon style={{
lineHeight: '130px' lineHeight: '130px'
}} icon={faUser} size='5x'/> : 'dfdf' /* todo render picture provided here! */} }} icon={faUser} size='5x'/> : 'dfdf' /* todo render picture provided here! */}
</div> </div>
<div className={style.actortile_name}>{this.props.actor.name}</div> <div className={style.actortile_name}>{this.props.actor.Name}</div>
</div> </div>
); );
} }

8
src/elements/Popups/AddActorPopup/AddActorPopup.test.js
View File

@ -31,7 +31,7 @@ describe('<AddActorPopup/>', function () {
}); });
it('test api call and insertion of actor tiles', function () { it('test api call and insertion of actor tiles', function () {
global.callAPIMock([{id: 1, name: 'test'}, {id: 2, name: 'test2'}]); global.callAPIMock([{Id: 1, Name: 'test'}, {Id: 2, Name: 'test2'}]);
const wrapper = shallow(<AddActorPopup/>); const wrapper = shallow(<AddActorPopup/>);
@ -44,7 +44,7 @@ describe('<AddActorPopup/>', function () {
global.callAPIMock({result: 'success'}); global.callAPIMock({result: 'success'});
wrapper.setState({actors: [{actor_id: 1, name: 'test'}]}, () => { wrapper.setState({actors: [{ActorId: 1, Name: 'test'}]}, () => {
wrapper.find('ActorTile').dive().simulate('click'); wrapper.find('ActorTile').dive().simulate('click');
expect(callAPI).toHaveBeenCalledTimes(1); expect(callAPI).toHaveBeenCalledTimes(1);
@ -59,7 +59,7 @@ describe('<AddActorPopup/>', function () {
global.callAPIMock({result: 'nosuccess'}); global.callAPIMock({result: 'nosuccess'});
wrapper.setState({actors: [{actor_id: 1, name: 'test'}]}, () => { wrapper.setState({actors: [{ActorId: 1, Name: 'test'}]}, () => {
wrapper.find('ActorTile').dive().simulate('click'); wrapper.find('ActorTile').dive().simulate('click');
expect(callAPI).toHaveBeenCalledTimes(1); expect(callAPI).toHaveBeenCalledTimes(1);
@ -80,7 +80,7 @@ describe('<AddActorPopup/>', function () {
callAPIMock({}); callAPIMock({});
wrapper.setState({actors: [{name: 'test', actor_id: 1}]}); wrapper.setState({actors: [{Name: 'test', ActorId: 1}]});
wrapper.find('PopupBase').props().ParentSubmit(); wrapper.find('PopupBase').props().ParentSubmit();

6
src/elements/Popups/AddActorPopup/AddActorPopup.tsx
View File

@ -134,8 +134,8 @@ class AddActorPopup extends React.Component<props, state> {
// fetch the available actors // fetch the available actors
callAPI<GeneralSuccess>(APINode.Actor, { callAPI<GeneralSuccess>(APINode.Actor, {
action: 'addActorToVideo', action: 'addActorToVideo',
actorid: actor.actor_id, ActorId: actor.ActorId,
videoid: this.props.movie_id MovieId: this.props.movie_id
}, result => { }, result => {
if (result.result === 'success') { if (result.result === 'success') {
// return back to player page // return back to player page
@ -170,7 +170,7 @@ class AddActorPopup extends React.Component<props, state> {
* @param actor * @param actor
*/ */
private filterSearch(actor: ActorType): boolean { private filterSearch(actor: ActorType): boolean {
return actor.name.toLowerCase().includes(this.state.filter.toLowerCase()); return actor.Name.toLowerCase().includes(this.state.filter.toLowerCase());
} }
/** /**

2
src/elements/Popups/AddTagPopup/AddTagPopup.test.js
View File

@ -14,7 +14,7 @@ describe('<AddTagPopup/>', function () {
it('test tag insertion', function () { it('test tag insertion', function () {
const wrapper = shallow(<AddTagPopup/>); const wrapper = shallow(<AddTagPopup/>);
wrapper.setState({ wrapper.setState({
items: [{tag_id: 1, tag_name: 'test'}, {tag_id: 2, tag_name: 'ee'}] items: [{TagId: 1, TagName: 'test'}, {TagId: 2, TagName: 'ee'}]
}, () => { }, () => {
expect(wrapper.find('Tag')).toHaveLength(2); expect(wrapper.find('Tag')).toHaveLength(2);
expect(wrapper.find('Tag').first().dive().text()).toBe('test'); expect(wrapper.find('Tag').first().dive().text()).toBe('test');

2
src/elements/Popups/AddTagPopup/AddTagPopup.tsx
View File

@ -39,7 +39,7 @@ class AddTagPopup extends React.Component<props, state> {
this.state.items.map((i) => ( this.state.items.map((i) => (
<Tag tagInfo={i} <Tag tagInfo={i}
onclick={(): void => { onclick={(): void => {
this.props.submit(i.tag_id, i.tag_name); this.props.submit(i.TagId, i.TagName);
this.props.onHide(); this.props.onHide();
}}/> }}/>
)) : null} )) : null}

2
src/elements/Popups/NewTagPopup/NewTagPopup.tsx
View File

@ -29,7 +29,7 @@ class NewTagPopup extends React.Component<props> {
* store the filled in form to the backend * store the filled in form to the backend
*/ */
storeselection(): void { storeselection(): void {
callAPI(APINode.Tags, {action: 'createTag', tagname: this.value}, (result: GeneralSuccess) => { callAPI(APINode.Tags, {action: 'createTag', TagName: this.value}, (result: GeneralSuccess) => {
if (result.result !== 'success') { if (result.result !== 'success') {
console.log('error occured while writing to db -- todo error handling'); console.log('error occured while writing to db -- todo error handling');
console.log(result.result); console.log(result.result);

6
src/elements/Tag/Tag.test.js
View File

@ -6,12 +6,12 @@ import {shallow} from 'enzyme';
describe('<Tag/>', function () { describe('<Tag/>', function () {
it('renders without crashing ', function () { it('renders without crashing ', function () {
const wrapper = shallow(<Tag tagInfo={{tag_name: 'testname', tag_id: 1}}/>); const wrapper = shallow(<Tag tagInfo={{TagName: 'testname', TagId: 1}}/>);
wrapper.unmount(); wrapper.unmount();
}); });
it('renders childs correctly', function () { it('renders childs correctly', function () {
const wrapper = shallow(<Tag tagInfo={{tag_name: 'test', tag_id: 1}}/>); const wrapper = shallow(<Tag tagInfo={{TagName: 'test', TagId: 1}}/>);
expect(wrapper.children().text()).toBe('test'); expect(wrapper.children().text()).toBe('test');
}); });
@ -19,7 +19,7 @@ describe('<Tag/>', function () {
const func = jest.fn(); const func = jest.fn();
const wrapper = shallow(<Tag const wrapper = shallow(<Tag
tagInfo={{tag_name: 'test', tag_id: 1}} tagInfo={{TagName: 'test', TagId: 1}}
onclick={() => {func();}}>test</Tag>); onclick={() => {func();}}>test</Tag>);
expect(func).toBeCalledTimes(0); expect(func).toBeCalledTimes(0);

6
src/elements/Tag/Tag.tsx
View File

@ -18,7 +18,7 @@ class Tag extends React.Component<props> {
return this.renderButton(); return this.renderButton();
} else { } else {
return ( return (
<Link to={'/categories/' + this.props.tagInfo.tag_id}> <Link to={'/categories/' + this.props.tagInfo.TagId}>
{this.renderButton()} {this.renderButton()}
</Link> </Link>
); );
@ -28,7 +28,7 @@ class Tag extends React.Component<props> {
renderButton(): JSX.Element { renderButton(): JSX.Element {
return ( return (
<button className={styles.tagbtn} onClick={(): void => this.TagClick()} <button className={styles.tagbtn} onClick={(): void => this.TagClick()}
data-testid='Test-Tag'>{this.props.tagInfo.tag_name}</button> data-testid='Test-Tag'>{this.props.tagInfo.TagName}</button>
); );
} }
@ -38,7 +38,7 @@ class Tag extends React.Component<props> {
TagClick(): void { TagClick(): void {
if (this.props.onclick) { if (this.props.onclick) {
// call custom onclick handling // call custom onclick handling
this.props.onclick(this.props.tagInfo.tag_name); // todo check if param is neccessary this.props.onclick(this.props.tagInfo.TagName); // todo check if param is neccessary
return; return;
} }
} }

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

@ -40,9 +40,9 @@ class VideoContainer extends React.Component<props, state> {
<div className={style.maincontent}> <div className={style.maincontent}>
{this.state.loadeditems.map(elem => ( {this.state.loadeditems.map(elem => (
<Preview <Preview
key={elem.movie_id} key={elem.MovieId}
name={elem.movie_name} name={elem.MovieName}
movie_id={elem.movie_id}/> movie_id={elem.MovieId}/>
))} ))}
{/*todo css for no items to show*/} {/*todo css for no items to show*/}
{this.state.loadeditems.length === 0 ? {this.state.loadeditems.length === 0 ?

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

@ -38,7 +38,7 @@ class ActorOverviewPage extends React.Component<props, state> {
<Button title='Add Actor' onClick={(): void => this.setState({NActorPopupVisible: true})}/> <Button title='Add Actor' onClick={(): void => this.setState({NActorPopupVisible: true})}/>
</SideBar> </SideBar>
<div className={style.container}> <div className={style.container}>
{this.state.actors.map((el) => (<ActorTile key={el.actor_id} actor={el}/>))} {this.state.actors.map((el) => (<ActorTile key={el.ActorId} actor={el}/>))}
</div> </div>
{this.state.NActorPopupVisible ? {this.state.NActorPopupVisible ?
<NewActorPopup onHide={(): void => { <NewActorPopup onHide={(): void => {

14
src/pages/ActorPage/ActorPage.test.js
View File

@ -10,13 +10,13 @@ describe('<ActorPage/>', function () {
it('fetch infos', function () { it('fetch infos', function () {
callAPIMock({ callAPIMock({
videos: [{ Videos: [{
movie_id: 0, MovieId: 0,
movie_name: 'test' MovieName: 'test'
}], info: { }], Info: {
thumbnail: '', Thumbnail: '',
name: '', Name: '',
actor_id: 0 ActorId: 0
} }
}); });

10
src/pages/ActorPage/ActorPage.tsx
View File

@ -31,13 +31,13 @@ export class ActorPage extends React.Component<props, state> {
constructor(props: props) { constructor(props: props) {
super(props); super(props);
this.state = {data: [], actor: {actor_id: 0, name: '', thumbnail: ''}}; this.state = {data: [], actor: {ActorId: 0, Name: '', Thumbnail: ''}};
} }
render(): JSX.Element { render(): JSX.Element {
return ( return (
<> <>
<PageTitle title={this.state.actor.name} subtitle={this.state.data ? this.state.data.length + ' videos' : null}> <PageTitle title={this.state.actor.Name} subtitle={this.state.data ? this.state.data.length + ' videos' : null}>
<span className={style.overviewbutton}> <span className={style.overviewbutton}>
<Link to='/actors'> <Link to='/actors'>
<Button onClick={(): void => {}} title='Go to Actor overview'/> <Button onClick={(): void => {}} title='Go to Actor overview'/>
@ -68,11 +68,11 @@ export class ActorPage extends React.Component<props, state> {
getActorInfo(): void { getActorInfo(): void {
callAPI(APINode.Actor, { callAPI(APINode.Actor, {
action: 'getActorInfo', action: 'getActorInfo',
actorid: this.props.match.params.id ActorId: parseInt(this.props.match.params.id)
}, (result: ActorTypes.videofetchresult) => { }, (result: ActorTypes.videofetchresult) => {
this.setState({ this.setState({
data: result.videos ? result.videos : [], data: result.Videos ? result.Videos : [],
actor: result.info actor: result.Info
}); });
}); });
} }

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

@ -103,8 +103,8 @@ export class CategoryView extends React.Component<CategoryViewProps, CategoryVie
private deleteTag(force: boolean): void { private deleteTag(force: boolean): void {
callAPI<GeneralSuccess>(APINode.Tags, { callAPI<GeneralSuccess>(APINode.Tags, {
action: 'deleteTag', action: 'deleteTag',
tagId: parseInt(this.props.match.params.id), TagId: parseInt(this.props.match.params.id),
force: force Force: force
}, result => { }, result => {
console.log(result.result); console.log(result.result);
if (result.result === 'success') { if (result.result === 'success') {

4
src/pages/CategoryPage/TagView.tsx
View File

@ -54,8 +54,8 @@ class TagView extends React.Component<props, TagViewState> {
<div className={videocontainerstyle.maincontent}> <div className={videocontainerstyle.maincontent}>
{this.state.loadedtags ? {this.state.loadedtags ?
this.state.loadedtags.map((m) => ( this.state.loadedtags.map((m) => (
<Link to={'/categories/' + m.tag_id} key={m.tag_id}> <Link to={'/categories/' + m.TagId} key={m.TagId}>
<TagPreview name={m.tag_name}/></Link> <TagPreview name={m.TagName}/></Link>
)) : )) :
'loading'} 'loading'}
</div> </div>

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

@ -10,17 +10,12 @@ import {Route, Switch, withRouter} from 'react-router-dom';
import {RouteComponentProps} from 'react-router'; import {RouteComponentProps} from 'react-router';
import SearchHandling from './SearchHandling'; import SearchHandling from './SearchHandling';
import {VideoTypes} from '../../types/ApiTypes'; import {VideoTypes} from '../../types/ApiTypes';
import {DefaultTags} from "../../types/GeneralTypes";
interface props extends RouteComponentProps {} interface props extends RouteComponentProps {}
interface state { interface state {
sideinfo: { sideinfo: VideoTypes.startDataType
videonr: number,
fullhdvideonr: number,
hdvideonr: number,
sdvideonr: number,
tagnr: number
},
subtitle: string, subtitle: string,
data: VideoTypes.VideoUnloadedType[], data: VideoTypes.VideoUnloadedType[],
selectionnr: number selectionnr: number
@ -38,11 +33,12 @@ export class HomePage extends React.Component<props, state> {
this.state = { this.state = {
sideinfo: { sideinfo: {
videonr: 0, VideoNr: 0,
fullhdvideonr: 0, FullHdNr: 0,
hdvideonr: 0, HDNr: 0,
sdvideonr: 0, SDNr: 0,
tagnr: 0 DifferentTags: 0,
Tagged: 0,
}, },
subtitle: 'All Videos', subtitle: 'All Videos',
data: [], data: [],
@ -52,7 +48,7 @@ export class HomePage extends React.Component<props, state> {
componentDidMount(): void { componentDidMount(): void {
// initial get of all videos // initial get of all videos
this.fetchVideoData('All'); this.fetchVideoData(DefaultTags.all.TagId);
this.fetchStartData(); this.fetchStartData();
} }
@ -62,7 +58,7 @@ export class HomePage extends React.Component<props, state> {
* *
* @param tag tag to fetch videos * @param tag tag to fetch videos
*/ */
fetchVideoData(tag: string): void { 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({ this.setState({
data: [] data: []
@ -70,7 +66,6 @@ export class HomePage extends React.Component<props, state> {
this.setState({ this.setState({
data: result, data: result,
selectionnr: result.length, selectionnr: result.length,
subtitle: `${tag} Videos`
}); });
}); });
} }
@ -80,15 +75,7 @@ export class HomePage extends React.Component<props, state> {
*/ */
fetchStartData(): void { fetchStartData(): void {
callAPI(APINode.Video, {action: 'getStartData'}, (result: VideoTypes.startDataType) => { callAPI(APINode.Video, {action: 'getStartData'}, (result: VideoTypes.startDataType) => {
this.setState({ this.setState({sideinfo: result});
sideinfo: {
videonr: result['total'],
fullhdvideonr: result['fullhd'],
hdvideonr: result['hd'],
sdvideonr: result['sd'],
tagnr: result['tags']
}
});
}); });
} }
@ -119,17 +106,30 @@ export class HomePage extends React.Component<props, state> {
<SideBar> <SideBar>
<SideBarTitle>Infos:</SideBarTitle> <SideBarTitle>Infos:</SideBarTitle>
<Line/> <Line/>
<SideBarItem><b>{this.state.sideinfo.videonr}</b> Videos Total!</SideBarItem> <SideBarItem><b>{this.state.sideinfo.VideoNr}</b> Videos Total!</SideBarItem>
<SideBarItem><b>{this.state.sideinfo.fullhdvideonr}</b> FULL-HD Videos!</SideBarItem> <SideBarItem><b>{this.state.sideinfo.FullHdNr}</b> FULL-HD Videos!</SideBarItem>
<SideBarItem><b>{this.state.sideinfo.hdvideonr}</b> HD Videos!</SideBarItem> <SideBarItem><b>{this.state.sideinfo.HDNr}</b> HD Videos!</SideBarItem>
<SideBarItem><b>{this.state.sideinfo.sdvideonr}</b> SD Videos!</SideBarItem> <SideBarItem><b>{this.state.sideinfo.SDNr}</b> SD Videos!</SideBarItem>
<SideBarItem><b>{this.state.sideinfo.tagnr}</b> different Tags!</SideBarItem> <SideBarItem><b>{this.state.sideinfo.DifferentTags}</b> different Tags!</SideBarItem>
<Line/> <Line/>
<SideBarTitle>Default Tags:</SideBarTitle> <SideBarTitle>Default Tags:</SideBarTitle>
<Tag tagInfo={{tag_name: 'All', tag_id: -1}} onclick={(): void => this.fetchVideoData('All')}/> <Tag tagInfo={{TagName: 'All', TagId: DefaultTags.all.TagId}} onclick={(): void => {
<Tag tagInfo={{tag_name: 'FullHd', tag_id: -1}} onclick={(): void => this.fetchVideoData('FullHd')}/> this.fetchVideoData(DefaultTags.all.TagId);
<Tag tagInfo={{tag_name: 'LowQuality', tag_id: -1}} onclick={(): void => this.fetchVideoData('LowQuality')}/> this.setState({subtitle: `All Videos`});
<Tag tagInfo={{tag_name: 'HD', tag_id: -1}} onclick={(): void => this.fetchVideoData('HD')}/> }}/>
<Tag tagInfo={{TagName: 'Full Hd', TagId: DefaultTags.fullhd.TagId}} onclick={(): void => {
this.fetchVideoData(DefaultTags.fullhd.TagId);
this.setState({subtitle: `Full Hd Videos`});
}}/>
<Tag tagInfo={{TagName: 'Low Quality', TagId: DefaultTags.lowq.TagId}}
onclick={(): void => {
this.fetchVideoData(DefaultTags.lowq.TagId);
this.setState({subtitle: `Low Quality Videos`});
}}/>
<Tag tagInfo={{TagName: 'HD', TagId: DefaultTags.hd.TagId}} onclick={(): void => {
this.fetchVideoData(DefaultTags.hd.TagId);
this.setState({subtitle: `HD Videos`});
}}/>
</SideBar> </SideBar>
{this.state.data.length !== 0 ? {this.state.data.length !== 0 ?
<VideoContainer <VideoContainer

6
src/pages/Player/Player.test.js
View File

@ -190,15 +190,15 @@ describe('<Player/>', function () {
const wrapper = instance(); const wrapper = instance();
global.callAPIMock({result: 'success'}); global.callAPIMock({result: 'success'});
wrapper.setState({suggesttag: [{tag_name: 'test', tag_id: 1}]}, () => { wrapper.setState({suggesttag: [{TagName: 'test', TagId: 1}]}, () => {
// mock funtion should have not been called // mock funtion should have not been called
expect(callAPI).toBeCalledTimes(0); expect(callAPI).toBeCalledTimes(0);
wrapper.find('Tag').findWhere(p => p.props().tagInfo.tag_name === 'test').dive().simulate('click'); wrapper.find('Tag').findWhere(p => p.props().tagInfo.TagName === 'test').dive().simulate('click');
// mock function should have been called once // mock function should have been called once
expect(callAPI).toBeCalledTimes(1); expect(callAPI).toBeCalledTimes(1);
// expect tag added to video tags // expect tag added to video tags
expect(wrapper.state().tags).toMatchObject([{tag_name: 'test'}]); expect(wrapper.state().tags).toMatchObject([{TagName: 'test'}]);
// expect tag to be removed from tag suggestions // expect tag to be removed from tag suggestions
expect(wrapper.state().suggesttag).toHaveLength(0); expect(wrapper.state().suggesttag).toHaveLength(0);
}); });

48
src/pages/Player/Player.tsx
View File

@ -20,6 +20,7 @@ import {ActorType, TagType} from '../../types/VideoTypes';
import PlyrJS from 'plyr'; import PlyrJS from 'plyr';
import {Button} from '../../elements/GPElements/Button'; import {Button} from '../../elements/GPElements/Button';
import {VideoTypes} from '../../types/ApiTypes'; import {VideoTypes} from '../../types/ApiTypes';
import GlobalInfos from "../../utils/GlobalInfos";
interface myprops extends RouteComponentProps<{ id: string }> {} interface myprops extends RouteComponentProps<{ id: string }> {}
@ -131,16 +132,16 @@ export class Player extends React.Component<myprops, mystate> {
<Line/> <Line/>
<SideBarTitle>Tags:</SideBarTitle> <SideBarTitle>Tags:</SideBarTitle>
{this.state.tags.map((m: TagType) => ( {this.state.tags.map((m: TagType) => (
<Tag key={m.tag_id} tagInfo={m}/> <Tag key={m.TagId} tagInfo={m}/>
))} ))}
<Line/> <Line/>
<SideBarTitle>Tag Quickadd:</SideBarTitle> <SideBarTitle>Tag Quickadd:</SideBarTitle>
{this.state.suggesttag.map((m: TagType) => ( {this.state.suggesttag.map((m: TagType) => (
<Tag <Tag
tagInfo={m} tagInfo={m}
key={m.tag_name} key={m.TagName}
onclick={(): void => { onclick={(): void => {
this.quickAddTag(m.tag_id, m.tag_name); this.quickAddTag(m.TagId, m.TagName);
}}/> }}/>
))} ))}
</SideBar> </SideBar>
@ -155,7 +156,7 @@ export class Player extends React.Component<myprops, mystate> {
<div className={style.actorcontainer}> <div className={style.actorcontainer}>
{this.state.actors ? {this.state.actors ?
this.state.actors.map((actr: ActorType) => ( this.state.actors.map((actr: ActorType) => (
<ActorTile key={actr.actor_id} actor={actr}/> <ActorTile key={actr.ActorId} actor={actr}/>
)) : <></> )) : <></>
} }
<div className={style.actorAddTile} onClick={(): void => { <div className={style.actorAddTile} onClick={(): void => {
@ -207,8 +208,8 @@ export class Player extends React.Component<myprops, mystate> {
quickAddTag(tagId: number, tagName: string): void { quickAddTag(tagId: number, tagName: string): void {
callAPI(APINode.Tags, { callAPI(APINode.Tags, {
action: 'addTag', action: 'addTag',
id: tagId, TagId: tagId,
movieid: this.props.match.params.id MovieId: parseInt(this.props.match.params.id)
}, (result: GeneralSuccess) => { }, (result: GeneralSuccess) => {
if (result.result !== 'success') { if (result.result !== 'success') {
console.error('error occured while writing to db -- todo error handling'); console.error('error occured while writing to db -- todo error handling');
@ -216,7 +217,7 @@ export class Player extends React.Component<myprops, mystate> {
} else { } else {
// check if tag has already been added // check if tag has already been added
const tagIndex = this.state.tags.map(function (e: TagType) { const tagIndex = this.state.tags.map(function (e: TagType) {
return e.tag_name; return e.TagName;
}).indexOf(tagName); }).indexOf(tagName);
// only add tag if it isn't already there // only add tag if it isn't already there
@ -224,7 +225,7 @@ export class Player extends React.Component<myprops, mystate> {
// update tags if successful // update tags if successful
let array = [...this.state.suggesttag]; // make a separate copy of the array (because of setState) let array = [...this.state.suggesttag]; // make a separate copy of the array (because of setState)
const quickaddindex = this.state.suggesttag.map(function (e: TagType) { const quickaddindex = this.state.suggesttag.map(function (e: TagType) {
return e.tag_id; return e.TagId;
}).indexOf(tagId); }).indexOf(tagId);
// check if tag is available in quickadds // check if tag is available in quickadds
@ -232,12 +233,12 @@ export class Player extends React.Component<myprops, mystate> {
array.splice(quickaddindex, 1); array.splice(quickaddindex, 1);
this.setState({ this.setState({
tags: [...this.state.tags, {tag_name: tagName, tag_id: tagId}], tags: [...this.state.tags, {TagName: tagName, TagId: tagId}],
suggesttag: array suggesttag: array
}); });
} else { } else {
this.setState({ this.setState({
tags: [...this.state.tags, {tag_name: tagName, tag_id: tagId}] tags: [...this.state.tags, {TagName: tagName, TagId: tagId}]
}); });
} }
} }
@ -249,27 +250,28 @@ export class Player extends React.Component<myprops, mystate> {
* fetch all the required infos of a video from backend * fetch all the required infos of a video from backend
*/ */
fetchMovieData(): void { fetchMovieData(): void {
callAPI(APINode.Video, {action: 'loadVideo', movieid: this.props.match.params.id}, (result: VideoTypes.loadVideoType) => { callAPI(APINode.Video, {action: 'loadVideo', MovieId: parseInt(this.props.match.params.id)}, (result: VideoTypes.loadVideoType) => {
console.log(result)
this.setState({ this.setState({
sources: { sources: {
type: 'video', type: 'video',
sources: [ sources: [
{ {
src: getBackendDomain() + result.movie_url, src: getBackendDomain() + GlobalInfos.getVideoPath() + result.MovieUrl,
type: 'video/mp4', type: 'video/mp4',
size: 1080 size: 1080
} }
], ],
poster: result.thumbnail poster: result.Poster
}, },
movie_id: result.movie_id, movie_id: result.MovieId,
movie_name: result.movie_name, movie_name: result.MovieName,
likes: result.likes, likes: result.Likes,
quality: result.quality, quality: result.Quality,
length: result.length, length: result.Length,
tags: result.tags, tags: result.Tags,
suggesttag: result.suggesttag, suggesttag: result.SuggestedTag,
actors: result.actors actors: result.Actors
}); });
}); });
} }
@ -279,7 +281,7 @@ export class Player extends React.Component<myprops, mystate> {
* click handler for the like btn * click handler for the like btn
*/ */
likebtn(): void { likebtn(): void {
callAPI(APINode.Video, {action: 'addLike', movieid: this.props.match.params.id}, (result: GeneralSuccess) => { callAPI(APINode.Video, {action: 'addLike', MovieId: parseInt(this.props.match.params.id)}, (result: GeneralSuccess) => {
if (result.result === 'success') { if (result.result === 'success') {
// likes +1 --> avoid reload of all data // likes +1 --> avoid reload of all data
this.setState({likes: this.state.likes + 1}); this.setState({likes: this.state.likes + 1});
@ -302,7 +304,7 @@ export class Player extends React.Component<myprops, mystate> {
* delete the current video and return to last page * delete the current video and return to last page
*/ */
deleteVideo(): void { deleteVideo(): void {
callAPI(APINode.Video, {action: 'deleteVideo', movieid: this.props.match.params.id}, (result: GeneralSuccess) => { callAPI(APINode.Video, {action: 'deleteVideo', MovieId: parseInt(this.props.match.params.id)}, (result: GeneralSuccess) => {
if (result.result === 'success') { if (result.result === 'success') {
// return to last element if successful // return to last element if successful
this.props.history.goBack(); this.props.history.goBack();

2
src/pages/RandomPage/RandomPage.test.js
View File

@ -55,7 +55,7 @@ describe('<RandomPage/>', function () {
shallow(<RandomPage/>); shallow(<RandomPage/>);
callAPIMock({rows: [], tags: []}); callAPIMock({Videos: [], Tags: []});
// trigger the keypress event // trigger the keypress event
events.keyup({key: 's'}); events.keyup({key: 's'});

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

@ -15,8 +15,8 @@ interface state {
} }
interface GetRandomMoviesType { interface GetRandomMoviesType {
rows: VideoTypes.VideoUnloadedType[]; Videos: VideoTypes.VideoUnloadedType[];
tags: TagType[]; Tags: TagType[];
} }
/** /**
@ -53,7 +53,7 @@ class RandomPage extends React.Component<{}, state> {
<SideBar> <SideBar>
<SideBarTitle>Visible Tags:</SideBarTitle> <SideBarTitle>Visible Tags:</SideBarTitle>
{this.state.tags.map((m) => ( {this.state.tags.map((m) => (
<Tag key={m.tag_id} tagInfo={m}/> <Tag key={m.TagId} tagInfo={m}/>
))} ))}
</SideBar> </SideBar>
@ -84,10 +84,11 @@ class RandomPage extends React.Component<{}, state> {
*/ */
loadShuffledvideos(nr: number): void { 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: []}); // needed to trigger rerender of main videoview
this.setState({ this.setState({
videos: result.rows, videos: result.Videos,
tags: result.tags tags: result.Tags
}); });
}); });
} }

24
src/pages/SettingsPage/GeneralSettings.test.js
View File

@ -80,48 +80,48 @@ describe('<GeneralSettings/>', function () {
it('test videopath change event', function () { it('test videopath change event', function () {
const wrapper = shallow(<GeneralSettings/>); const wrapper = shallow(<GeneralSettings/>);
expect(wrapper.state().videopath).not.toBe('test'); expect(wrapper.state().generalSettings.VideoPath).not.toBe('test');
const event = {target: {name: 'pollName', value: 'test'}}; const event = {target: {name: 'pollName', value: 'test'}};
wrapper.find('[data-testid=\'videpathform\']').find('FormControl').simulate('change', event); wrapper.find('[data-testid=\'videpathform\']').find('FormControl').simulate('change', event);
expect(wrapper.state().videopath).toBe('test'); expect(wrapper.state().generalSettings.VideoPath).toBe('test');
}); });
it('test tvshowpath change event', function () { it('test tvshowpath change event', function () {
const wrapper = shallow(<GeneralSettings/>); const wrapper = shallow(<GeneralSettings/>);
const event = {target: {name: 'pollName', value: 'test'}}; const event = {target: {name: 'pollName', value: 'test'}};
expect(wrapper.state().tvshowpath).not.toBe('test'); expect(wrapper.state().generalSettings.EpisodePath).not.toBe('test');
wrapper.find('[data-testid=\'tvshowpath\']').find('FormControl').simulate('change', event); wrapper.find('[data-testid=\'tvshowpath\']').find('FormControl').simulate('change', event);
expect(wrapper.state().tvshowpath).toBe('test'); expect(wrapper.state().generalSettings.EpisodePath).toBe('test');
}); });
it('test mediacentername-form change event', function () { it('test mediacentername-form change event', function () {
const wrapper = shallow(<GeneralSettings/>); const wrapper = shallow(<GeneralSettings/>);
const event = {target: {name: 'pollName', value: 'test'}}; const event = {target: {name: 'pollName', value: 'test'}};
expect(wrapper.state().mediacentername).not.toBe('test'); expect(wrapper.state().generalSettings.MediacenterName).not.toBe('test');
wrapper.find('[data-testid=\'nameform\']').find('FormControl').simulate('change', event); wrapper.find('[data-testid=\'nameform\']').find('FormControl').simulate('change', event);
expect(wrapper.state().mediacentername).toBe('test'); expect(wrapper.state().generalSettings.MediacenterName).toBe('test');
}); });
it('test password-form change event', function () { it('test password-form change event', function () {
const wrapper = shallow(<GeneralSettings/>); const wrapper = shallow(<GeneralSettings/>);
wrapper.setState({passwordsupport: true}); wrapper.setState({generalSettings : {PasswordEnabled: true}});
const event = {target: {name: 'pollName', value: 'test'}}; const event = {target: {name: 'pollName', value: 'test'}};
expect(wrapper.state().password).not.toBe('test'); expect(wrapper.state().generalSettings.Password).not.toBe('test');
wrapper.find('[data-testid=\'passwordfield\']').find('FormControl').simulate('change', event); wrapper.find('[data-testid=\'passwordfield\']').find('FormControl').simulate('change', event);
expect(wrapper.state().password).toBe('test'); expect(wrapper.state().generalSettings.Password).toBe('test');
}); });
it('test tmdbsupport change event', function () { it('test tmdbsupport change event', function () {
const wrapper = shallow(<GeneralSettings/>); const wrapper = shallow(<GeneralSettings/>);
wrapper.setState({tmdbsupport: true}); wrapper.setState({generalSettings : {TMDBGrabbing: true}});
expect(wrapper.state().tmdbsupport).toBe(true); expect(wrapper.state().generalSettings.TMDBGrabbing).toBe(true);
wrapper.find('[data-testid=\'tmdb-switch\']').simulate('change'); wrapper.find('[data-testid=\'tmdb-switch\']').simulate('change');
expect(wrapper.state().tmdbsupport).toBe(false); expect(wrapper.state().generalSettings.TMDBGrabbing).toBe(false);
}); });
it('test insertion of 4 infoheaderitems', function () { it('test insertion of 4 infoheaderitems', function () {

139
src/pages/SettingsPage/GeneralSettings.tsx
View File

@ -11,23 +11,13 @@ import {SettingsTypes} from '../../types/ApiTypes';
import {GeneralSuccess} from '../../types/GeneralTypes'; import {GeneralSuccess} from '../../types/GeneralTypes';
interface state { interface state {
passwordsupport: boolean, customapi: boolean
tmdbsupport: boolean, apipath: string
customapi: boolean, generalSettings: SettingsTypes.loadGeneralSettingsType
videopath: string,
tvshowpath: string,
mediacentername: string,
password: string,
apipath: string,
videonr: number,
dbsize: number,
difftagnr: number,
tagsadded: number
} }
interface props {} interface props {
}
/** /**
* Component for Generalsettings tag on Settingspage * Component for Generalsettings tag on Settingspage
@ -38,20 +28,21 @@ class GeneralSettings extends React.Component<props, state> {
super(props); super(props);
this.state = { this.state = {
passwordsupport: false,
tmdbsupport: false,
customapi: false, customapi: false,
videopath: '',
tvshowpath: '',
mediacentername: '',
password: '',
apipath: '', apipath: '',
generalSettings: {
videonr: 0, DarkMode: true,
dbsize: 0, DBSize: 0,
difftagnr: 0, DifferentTags: 0,
tagsadded: 0 EpisodePath: "",
MediacenterName: "",
Password: "",
PasswordEnabled: false,
TagsAdded: 0,
TMDBGrabbing: false,
VideoNr: 0,
VideoPath: ""
}
}; };
} }
@ -65,19 +56,19 @@ class GeneralSettings extends React.Component<props, state> {
<> <>
<div className={style.infoheader}> <div className={style.infoheader}>
<InfoHeaderItem backColor='lightblue' <InfoHeaderItem backColor='lightblue'
text={this.state.videonr} text={this.state.generalSettings.VideoNr}
subtext='Videos in Gravity' subtext='Videos in Gravity'
icon={faArchive}/> icon={faArchive}/>
<InfoHeaderItem backColor='yellow' <InfoHeaderItem backColor='yellow'
text={this.state.dbsize !== undefined ? this.state.dbsize + ' MB' : ''} text={this.state.generalSettings.DBSize + ' MB'}
subtext='Database size' subtext='Database size'
icon={faRulerVertical}/> icon={faRulerVertical}/>
<InfoHeaderItem backColor='green' <InfoHeaderItem backColor='green'
text={this.state.difftagnr} text={this.state.generalSettings.DifferentTags}
subtext='different Tags' subtext='different Tags'
icon={faAddressCard}/> icon={faAddressCard}/>
<InfoHeaderItem backColor='orange' <InfoHeaderItem backColor='orange'
text={this.state.tagsadded} text={this.state.generalSettings.TagsAdded}
subtext='tags added' subtext='tags added'
icon={faBalanceScaleLeft}/> icon={faBalanceScaleLeft}/>
</div> </div>
@ -89,15 +80,26 @@ class GeneralSettings extends React.Component<props, state> {
<Form.Row> <Form.Row>
<Form.Group as={Col} data-testid='videpathform'> <Form.Group as={Col} data-testid='videpathform'>
<Form.Label>Video Path</Form.Label> <Form.Label>Video Path</Form.Label>
<Form.Control type='text' placeholder='/var/www/html/video' value={this.state.videopath} <Form.Control type='text' placeholder='/var/www/html/video'
onChange={(ee): void => this.setState({videopath: ee.target.value})}/> value={this.state.generalSettings.VideoPath}
onChange={(ee): void => this.setState({
generalSettings: {
...this.state.generalSettings,
VideoPath: ee.target.value
}
})}/>
</Form.Group> </Form.Group>
<Form.Group as={Col} data-testid='tvshowpath'> <Form.Group as={Col} data-testid='tvshowpath'>
<Form.Label>TV Show Path</Form.Label> <Form.Label>TV Show Path</Form.Label>
<Form.Control type='text' placeholder='/var/www/html/tvshow' <Form.Control type='text' placeholder='/var/www/html/tvshow'
value={this.state.tvshowpath} value={this.state.generalSettings.EpisodePath}
onChange={(e): void => this.setState({tvshowpath: e.target.value})}/> onChange={(e): void => this.setState({
generalSettings: {
...this.state.generalSettings,
EpisodePath: e.target.value
}
})}/>
</Form.Group> </Form.Group>
</Form.Row> </Form.Row>
@ -131,17 +133,28 @@ class GeneralSettings extends React.Component<props, state> {
id='custom-switch' id='custom-switch'
data-testid='passwordswitch' data-testid='passwordswitch'
label='Enable Password support' label='Enable Password support'
checked={this.state.passwordsupport} checked={this.state.generalSettings.PasswordEnabled}
onChange={(): void => { onChange={(): void => {
this.setState({passwordsupport: !this.state.passwordsupport}); this.setState({
generalSettings: {
...this.state.generalSettings,
PasswordEnabled: !this.state.generalSettings.PasswordEnabled
}
});
}} }}
/> />
{this.state.passwordsupport ? {this.state.generalSettings.PasswordEnabled ?
<Form.Group data-testid='passwordfield'> <Form.Group data-testid='passwordfield'>
<Form.Label>Password</Form.Label> <Form.Label>Password</Form.Label>
<Form.Control type='password' placeholder='**********' value={this.state.password} <Form.Control type='password' placeholder='**********'
onChange={(e): void => this.setState({password: e.target.value})}/> value={this.state.generalSettings.Password}
onChange={(e): void => this.setState({
generalSettings: {
...this.state.generalSettings,
Password: e.target.value
}
})}/>
</Form.Group> : null </Form.Group> : null
} }
@ -150,9 +163,14 @@ class GeneralSettings extends React.Component<props, state> {
id='custom-switch-2' id='custom-switch-2'
data-testid='tmdb-switch' data-testid='tmdb-switch'
label='Enable TMDB video grabbing support' label='Enable TMDB video grabbing support'
checked={this.state.tmdbsupport} checked={this.state.generalSettings.TMDBGrabbing}
onChange={(): void => { onChange={(): void => {
this.setState({tmdbsupport: !this.state.tmdbsupport}); this.setState({
generalSettings: {
...this.state.generalSettings,
TMDBGrabbing: !this.state.generalSettings.TMDBGrabbing
}
});
}} }}
/> />
@ -171,8 +189,14 @@ class GeneralSettings extends React.Component<props, state> {
<Form.Group className={style.mediacenternameform} data-testid='nameform'> <Form.Group className={style.mediacenternameform} data-testid='nameform'>
<Form.Label>The name of the Mediacenter</Form.Label> <Form.Label>The name of the Mediacenter</Form.Label>
<Form.Control type='text' placeholder='Mediacentername' value={this.state.mediacentername} <Form.Control type='text' placeholder='Mediacentername'
onChange={(e): void => this.setState({mediacentername: e.target.value})}/> value={this.state.generalSettings.MediacenterName}
onChange={(e): void => this.setState({
generalSettings: {
...this.state.generalSettings,
MediacenterName: e.target.value
}
})}/>
</Form.Group> </Form.Group>
<Button variant='primary' type='submit'> <Button variant='primary' type='submit'>
@ -192,19 +216,7 @@ class GeneralSettings extends React.Component<props, state> {
*/ */
loadSettings(): void { loadSettings(): void {
callAPI(APINode.Settings, {action: 'loadGeneralSettings'}, (result: SettingsTypes.loadGeneralSettingsType) => { callAPI(APINode.Settings, {action: 'loadGeneralSettings'}, (result: SettingsTypes.loadGeneralSettingsType) => {
this.setState({ this.setState({generalSettings: result});
videopath: result.video_path,
tvshowpath: result.episode_path,
mediacentername: result.mediacenter_name,
password: result.password,
passwordsupport: result.passwordEnabled,
tmdbsupport: result.TMDB_grabbing,
videonr: result.videonr,
dbsize: result.dbsize,
difftagnr: result.difftagnr,
tagsadded: result.tagsadded
});
}); });
} }
@ -212,14 +224,15 @@ class GeneralSettings extends React.Component<props, state> {
* save the selected and typed settings to the backend * save the selected and typed settings to the backend
*/ */
saveSettings(): void { saveSettings(): void {
let settings = this.state.generalSettings;
if(!this.state.generalSettings.PasswordEnabled){
settings.Password = '-1';
}
settings.DarkMode = GlobalInfos.isDarkTheme()
callAPI(APINode.Settings, { callAPI(APINode.Settings, {
action: 'saveGeneralSettings', action: 'saveGeneralSettings',
password: this.state.passwordsupport ? this.state.password : '-1', Settings: settings
videopath: this.state.videopath,
tvshowpath: this.state.tvshowpath,
mediacentername: this.state.mediacentername,
tmdbsupport: this.state.tmdbsupport,
darkmodeenabled: GlobalInfos.isDarkTheme().toString()
}, (result: GeneralSuccess) => { }, (result: GeneralSuccess) => {
if (result.result) { if (result.result) {
console.log('successfully saved settings'); console.log('successfully saved settings');

20
src/pages/SettingsPage/MovieSettings.test.js
View File

@ -52,10 +52,9 @@ describe('<MovieSettings/>', function () {
it('content available received and in state', () => { it('content available received and in state', () => {
const wrapper = shallow(<MovieSettings/>); const wrapper = shallow(<MovieSettings/>);
callAPIMock({ callAPIMock({
contentAvailable: true, ContentAvailable: true,
message: 'firstline\nsecondline' Messages: ['firstline', 'secondline']
}) })
wrapper.instance().updateStatus(); wrapper.instance().updateStatus();
@ -70,7 +69,8 @@ describe('<MovieSettings/>', function () {
it('test reindex with no content available', () => { it('test reindex with no content available', () => {
callAPIMock({ callAPIMock({
contentAvailable: false Messages: [],
ContentAvailable: false
}) })
global.clearInterval = jest.fn(); global.clearInterval = jest.fn();
@ -99,12 +99,12 @@ describe('<MovieSettings/>', function () {
expect(wrapper.instance().setState).toBeCalledTimes(1); expect(wrapper.instance().setState).toBeCalledTimes(1);
}); });
it('test no textDiv insertion if string is empty', function () { it('expect insertion before existing ones', function () {
const wrapper = shallow(<MovieSettings/>); const wrapper = shallow(<MovieSettings/>);
callAPIMock({ callAPIMock({
contentAvailable: true, ContentAvailable: true,
message: 'test' Messages: ['test']
}) })
wrapper.instance().updateStatus(); wrapper.instance().updateStatus();
@ -115,14 +115,14 @@ describe('<MovieSettings/>', function () {
// expect an untouched state if we try to add an empty string... // expect an untouched state if we try to add an empty string...
callAPIMock({ callAPIMock({
contentAvailable: true, ContentAvailable: true,
message: '' Messages: ['']
}) })
wrapper.instance().updateStatus(); wrapper.instance().updateStatus();
expect(wrapper.state()).toMatchObject({ expect(wrapper.state()).toMatchObject({
text: ['test'] text: ['', 'test']
}); });
}); });
}); });

18
src/pages/SettingsPage/MovieSettings.tsx
View File

@ -58,11 +58,7 @@ class MovieSettings extends React.Component<props, state> {
*/ */
startReindex(): void { startReindex(): void {
// clear output text before start // clear output text before start
this.setState({text: []}); this.setState({text: [], startbtnDisabled: true});
this.setState({startbtnDisabled: true});
console.log('starting');
callAPI(APINode.Settings, {action: 'startReindex'}, (result: GeneralSuccess): void => { callAPI(APINode.Settings, {action: 'startReindex'}, (result: GeneralSuccess): void => {
console.log(result); console.log(result);
@ -85,18 +81,12 @@ class MovieSettings extends React.Component<props, state> {
*/ */
updateStatus = (): void => { updateStatus = (): void => {
callAPI(APINode.Settings, {action: 'getStatusMessage'}, (result: SettingsTypes.getStatusMessageType) => { callAPI(APINode.Settings, {action: 'getStatusMessage'}, (result: SettingsTypes.getStatusMessageType) => {
if (result.contentAvailable) {
// ignore if message is empty
console.log(result);
if(result.message === '') return;
// todo 2020-07-4: scroll to bottom of div here
this.setState({ this.setState({
// insert a string for each line // insert a string for each line
text: [...result.message.split('\n'), text: [...result.Messages, ...this.state.text]
...this.state.text]
}); });
} else { // todo 2020-07-4: scroll to bottom of div here
if (!result.ContentAvailable) {
// clear refresh interval if no content available // clear refresh interval if no content available
clearInterval(this.myinterval); clearInterval(this.myinterval);

69
src/types/ApiTypes.ts
View File

@ -2,56 +2,59 @@ import {ActorType, TagType} from './VideoTypes';
export namespace VideoTypes { export namespace VideoTypes {
export interface loadVideoType { export interface loadVideoType {
movie_url: string MovieUrl: string
thumbnail: string Poster: string
movie_id: number MovieId: number
movie_name: string MovieName: string
likes: number Likes: number
quality: number Quality: number
length: number Length: number
tags: TagType[] Tags: TagType[]
suggesttag: TagType[] SuggestedTag: TagType[]
actors: ActorType[] Actors: ActorType[]
} }
export interface startDataType { export interface startDataType {
total: number; VideoNr: number;
fullhd: number; FullHdNr: number;
hd: number; HDNr: number;
sd: number; SDNr: number;
tags: number; DifferentTags: number;
Tagged: number;
} }
export interface VideoUnloadedType { export interface VideoUnloadedType {
movie_id: number; MovieId: number;
movie_name: string MovieName: string
} }
} }
export namespace SettingsTypes { export namespace SettingsTypes {
export interface initialApiCallData { export interface initialApiCallData {
DarkMode: boolean; DarkMode: boolean;
passwordEnabled: boolean; Password: boolean;
mediacenter_name: string; Mediacenter_name: string;
VideoPath: string;
} }
export interface loadGeneralSettingsType { export interface loadGeneralSettingsType {
video_path: string, VideoPath: string,
episode_path: string, EpisodePath: string,
mediacenter_name: string, MediacenterName: string,
password: string, Password: string,
passwordEnabled: boolean, PasswordEnabled: boolean,
TMDB_grabbing: boolean, TMDBGrabbing: boolean,
DarkMode: boolean,
videonr: number, VideoNr: number,
dbsize: number, DBSize: number,
difftagnr: number, DifferentTags: number,
tagsadded: number TagsAdded: number
} }
export interface getStatusMessageType { export interface getStatusMessageType {
contentAvailable: boolean; ContentAvailable: boolean;
message: string; Messages: string[];
} }
} }
@ -60,7 +63,7 @@ export namespace ActorTypes {
* result of actor fetch * result of actor fetch
*/ */
export interface videofetchresult { export interface videofetchresult {
videos: VideoTypes.VideoUnloadedType[]; Videos: VideoTypes.VideoUnloadedType[];
info: ActorType; Info: ActorType;
} }
} }

8
src/types/GeneralTypes.ts
View File

@ -9,8 +9,8 @@ interface TagarrayType {
} }
export const DefaultTags: TagarrayType = { export const DefaultTags: TagarrayType = {
all: {tag_id: 1, tag_name: 'all'}, all: {TagId: 1, TagName: 'all'},
fullhd: {tag_id: 2, tag_name: 'fullhd'}, fullhd: {TagId: 2, TagName: 'fullhd'},
lowq: {tag_id: 3, tag_name: 'lowquality'}, lowq: {TagId: 3, TagName: 'lowquality'},
hd: {tag_id: 4, tag_name: 'hd'} hd: {TagId: 4, TagName: 'hd'}
}; };

10
src/types/VideoTypes.ts
View File

@ -2,12 +2,12 @@
* type accepted by Tag component * type accepted by Tag component
*/ */
export interface TagType { export interface TagType {
tag_name: string TagName: string
tag_id: number TagId: number
} }
export interface ActorType { export interface ActorType {
thumbnail: string; Thumbnail: string;
name: string; Name: string;
actor_id: number; ActorId: number;
} }

27
src/utils/Api.ts
View File

@ -40,20 +40,7 @@ function getAPIDomain(): string {
interface ApiBaseRequest { interface ApiBaseRequest {
action: string | number, action: string | number,
[_: string]: string | number | boolean [_: string]: string | number | boolean | object
}
/**
* helper function to build a formdata for requesting post data correctly
* @param args api request object
*/
function buildFormData(args: ApiBaseRequest): FormData {
const req = new FormData();
for (const i in args) {
req.append(i, (args[i].toString()));
}
return req;
} }
/** /**
@ -64,7 +51,7 @@ function buildFormData(args: ApiBaseRequest): FormData {
* @param errorcallback a optional callback if an error occured * @param errorcallback a optional callback if an error occured
*/ */
export function callAPI<T>(apinode: APINode, fd: ApiBaseRequest, callback: (_: T) => void, errorcallback: (_: string) => void = (_: string): void => {}): void { export function callAPI<T>(apinode: APINode, fd: ApiBaseRequest, callback: (_: T) => void, errorcallback: (_: string) => void = (_: string): void => {}): void {
fetch(getAPIDomain() + apinode, {method: 'POST', body: buildFormData(fd)}) fetch(getAPIDomain() + apinode, {method: 'POST', body: JSON.stringify(fd)})
.then((response) => response.json() .then((response) => response.json()
.then((result) => { .then((result) => {
callback(result); callback(result);
@ -78,7 +65,7 @@ export function callAPI<T>(apinode: APINode, fd: ApiBaseRequest, callback: (_: T
* @param callback the callback with PLAIN text reply from backend * @param callback the callback with PLAIN text reply from backend
*/ */
export function callAPIPlain(apinode: APINode, fd: ApiBaseRequest, callback: (_: string) => void): void { export function callAPIPlain(apinode: APINode, fd: ApiBaseRequest, callback: (_: string) => void): void {
fetch(getAPIDomain() + apinode, {method: 'POST', body: buildFormData(fd)}) fetch(getAPIDomain() + apinode, {method: 'POST', body: JSON.stringify(fd)})
.then((response) => response.text() .then((response) => response.text()
.then((result) => { .then((result) => {
callback(result); callback(result);
@ -90,8 +77,8 @@ export function callAPIPlain(apinode: APINode, fd: ApiBaseRequest, callback: (_:
* API nodes definitions * API nodes definitions
*/ */
export enum APINode { export enum APINode {
Settings = 'settings.php', Settings = 'settings',
Tags = 'tags.php', Tags = 'tags',
Actor = 'actor.php', Actor = 'actor',
Video = 'video.php' Video = 'video'
} }

28
src/utils/GlobalInfos.js → src/utils/GlobalInfos.ts
View File

@ -6,31 +6,47 @@ import lighttheme from '../AppLightTheme.module.css';
* it contains general infos about app - like theme * it contains general infos about app - like theme
*/ */
class StaticInfos { class StaticInfos {
#darktheme = true; private darktheme: boolean = true;
private videopath: string = ""
/** /**
* check if the current theme is the dark theme * check if the current theme is the dark theme
* @returns {boolean} is dark theme? * @returns {boolean} is dark theme?
*/ */
isDarkTheme() { isDarkTheme(): boolean {
return this.#darktheme; return this.darktheme;
}; };
/** /**
* setter to enable or disable the dark or light theme * setter to enable or disable the dark or light theme
* @param enable enable the dark theme? * @param enable enable the dark theme?
*/ */
enableDarkTheme(enable = true) { enableDarkTheme(enable = true): void {
this.#darktheme = enable; this.darktheme = enable;
} }
/** /**
* get the currently selected theme stylesheet * get the currently selected theme stylesheet
* @returns {*} the style object of the current active theme * @returns {*} the style object of the current active theme
*/ */
getThemeStyle() { getThemeStyle(): { [_: string]: string } {
return this.isDarkTheme() ? darktheme : lighttheme; return this.isDarkTheme() ? darktheme : lighttheme;
} }
/**
* set the current videopath
* @param vidpath videopath with beginning and ending slash
*/
setVideoPath(vidpath: string): void {
this.videopath = vidpath;
}
/**
* return the current videopath
*/
getVideoPath(): string {
return this.videopath;
}
} }
const GlobalInfos = new StaticInfos(); const GlobalInfos = new StaticInfos();

12181
yarn.lock Normal file
View File

File diff suppressed because it is too large Load Diff