683 lines
25 KiB
Java
683 lines
25 KiB
Java
/**
|
|
* Project-HomeFlix
|
|
*
|
|
* Copyright 2016-2019 <@Seil0>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
|
|
* MA 02110-1301, USA.
|
|
*/
|
|
|
|
package kellerkinder.HomeFlix.controller;
|
|
|
|
import java.io.File;
|
|
import java.io.FileNotFoundException;
|
|
import java.io.IOException;
|
|
import java.net.URLConnection;
|
|
import java.sql.Connection;
|
|
import java.sql.DriverManager;
|
|
import java.sql.PreparedStatement;
|
|
import java.sql.ResultSet;
|
|
import java.sql.SQLException;
|
|
import java.sql.Statement;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
|
|
import org.apache.logging.log4j.LogManager;
|
|
import org.apache.logging.log4j.Logger;
|
|
|
|
import javafx.collections.ObservableList;
|
|
import javafx.scene.Node;
|
|
import javafx.scene.image.Image;
|
|
import javafx.scene.image.ImageView;
|
|
import javafx.scene.text.Font;
|
|
import javafx.scene.text.FontWeight;
|
|
import javafx.scene.text.Text;
|
|
import kellerkinder.HomeFlix.application.MainWindowController;
|
|
import kellerkinder.HomeFlix.datatypes.DatabaseDataType;
|
|
import kellerkinder.HomeFlix.datatypes.FilmTabelDataType;
|
|
import kellerkinder.HomeFlix.datatypes.OMDbAPIResponseDataType;
|
|
|
|
public class DBController {
|
|
|
|
private MainWindowController mainWindowController;
|
|
private String DB_PATH;
|
|
private Image favorite_black = new Image("icons/ic_favorite_black_18dp_1x.png");
|
|
private Image favorite_border_black = new Image("icons/ic_favorite_border_black_18dp_1x.png");
|
|
private List<DatabaseDataType> databaseStream = new ArrayList<DatabaseDataType>(); // contains all films stored in the database
|
|
private List<DatabaseDataType> sourceStreams = new ArrayList<DatabaseDataType>(); // contains all films from the sources
|
|
private Connection connection = null;
|
|
private static final Logger LOGGER = LogManager.getLogger(DBController.class.getName());
|
|
|
|
/**
|
|
* constructor for DBController
|
|
* @param main the Main object
|
|
* @param mainWindowController the MainWindowController object
|
|
*/
|
|
public DBController(MainWindowController mainWindowController) {
|
|
this.mainWindowController = mainWindowController;
|
|
}
|
|
|
|
/**
|
|
* initialize the {@link DBController}
|
|
* initialize the database connection
|
|
* check if there is a need to create a new database
|
|
* refresh the database
|
|
*/
|
|
public void init() {
|
|
LOGGER.info("<========== starting loading sql ==========>");
|
|
initDatabaseConnection();
|
|
createDatabase();
|
|
refreshDataBase();
|
|
LOGGER.info("<========== finished loading sql ==========>");
|
|
}
|
|
|
|
/**
|
|
* create a new connection to the HomeFlix.db database
|
|
* AutoCommit is set to false to prevent some issues, so manual commit is active!
|
|
*/
|
|
private void initDatabaseConnection() {
|
|
DB_PATH = XMLController.getDirHomeFlix() + "/Homeflix.db";
|
|
try {
|
|
// create a database connection
|
|
connection = DriverManager.getConnection("jdbc:sqlite:" + DB_PATH);
|
|
connection.setAutoCommit(false);
|
|
} catch (SQLException e) {
|
|
// if the error message is "out of memory", it probably means no database file is found
|
|
LOGGER.error("error while loading the ROM database", e);
|
|
}
|
|
LOGGER.info("ROM database loaded successfull");
|
|
}
|
|
|
|
/**
|
|
* if tables don't exist create them
|
|
* films table: streamUrl is primary key
|
|
* cache table: streamUrl is primary key
|
|
*/
|
|
private void createDatabase() {
|
|
try {
|
|
Statement stmt = connection.createStatement();
|
|
stmt.executeUpdate("create table if not exists films (streamUrl, title, season, episode, favorite, cached, currentTime)");
|
|
stmt.executeUpdate("create table if not exists cache ("
|
|
+ "streamUrl, Title, Year, Rated, Released, Season, Episode ,Runtime, Genre, Director, Writer,"
|
|
+ " Actors, Plot, Language, Country, Awards, Poster, Metascore, imdbRating, imdbVotes,"
|
|
+ " imdbID, Type, dvd, BoxOffice, Website, Response)");
|
|
stmt.close();
|
|
} catch (SQLException e) {
|
|
LOGGER.error(e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* get all database entries
|
|
*/
|
|
private void loadDatabase() {
|
|
// get all entries from the table
|
|
try {
|
|
Statement stmt = connection.createStatement();
|
|
ResultSet rs = stmt.executeQuery("SELECT * FROM films");
|
|
while (rs.next()) {
|
|
databaseStream.add(new DatabaseDataType(rs.getString("streamUrl"),
|
|
rs.getString("title"), rs.getString("season"), rs.getString("episode"),
|
|
rs.getInt("favorite"), rs.getBoolean("cached"), rs.getDouble("currentTime")));
|
|
}
|
|
stmt.close();
|
|
rs.close();
|
|
} catch (SQLException e) {
|
|
LOGGER.error("Ups! an error occured!", e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* load all sources
|
|
*/
|
|
private void loadSources() {
|
|
SourcesController sourcesController = new SourcesController();
|
|
sourceStreams = sourcesController.loadSources();
|
|
}
|
|
|
|
/**
|
|
* load the data to the mainWindowController
|
|
* order entries by title
|
|
*/
|
|
private void loadDataToFilmsList() {
|
|
ImageView imageView;
|
|
LOGGER.info("loading data to mwc ...");
|
|
try {
|
|
//load local Data
|
|
Statement stmt = connection.createStatement();
|
|
ResultSet rs = stmt.executeQuery("SELECT * FROM films ORDER BY title");
|
|
|
|
while (rs.next()) {
|
|
imageView = rs.getBoolean("favorite") ? new ImageView(favorite_black) : new ImageView(favorite_border_black);
|
|
mainWindowController.getFilmsList().add(new FilmTabelDataType(rs.getString("streamUrl"),
|
|
rs.getString("title"), rs.getString("season"), rs.getString("episode") ,rs.getBoolean("favorite"),
|
|
rs.getBoolean("cached"), imageView));
|
|
}
|
|
stmt.close();
|
|
rs.close();
|
|
} catch (SQLException e) {
|
|
LOGGER.error("Ups! an error occured!", e);
|
|
}
|
|
|
|
LOGGER.info("loading data to the GUI ...");
|
|
mainWindowController.addFilmsToTable(mainWindowController.getFilmsList());
|
|
}
|
|
|
|
/**
|
|
* refresh data in mainWindowController for one element
|
|
* @param streamUrl of the film
|
|
* @param index of the film in LocalFilms list
|
|
*/
|
|
public void refresh(String streamUrl, int indexList) {
|
|
LOGGER.info("refresh data for " + streamUrl);
|
|
try {
|
|
PreparedStatement ps = connection.prepareStatement("SELECT * FROM films WHERE streamUrl = ?");
|
|
ps.setString(1, streamUrl);
|
|
ResultSet rs = ps.executeQuery();
|
|
|
|
while (rs.next()) {
|
|
ImageView imageView = rs.getBoolean("favorite") ? new ImageView(favorite_black) : new ImageView(favorite_border_black);
|
|
mainWindowController.getFilmsList().set(indexList, new FilmTabelDataType(rs.getString("streamUrl"),
|
|
rs.getString("title"), rs.getString("season"), rs.getString("episode"), rs.getBoolean("favorite"),
|
|
rs.getBoolean("cached"), imageView));
|
|
}
|
|
rs.close();
|
|
ps.close();
|
|
} catch (Exception e) {
|
|
LOGGER.error("Ups! error while refreshing mwc!", e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* refresh database to contain all (new added) entries
|
|
* refresh the MainWindowController content,
|
|
* to contain all (new added) entries from the database
|
|
*/
|
|
public void refreshDataBase() {
|
|
LOGGER.info("refreshing the Database ...");
|
|
|
|
// clean all ArraLists
|
|
databaseStream.clear();
|
|
sourceStreams.clear();
|
|
|
|
loadSources(); // reload all sources
|
|
loadDatabase(); // reload all films saved in the DB
|
|
|
|
LOGGER.info("filme in db: " + databaseStream.size());
|
|
|
|
try {
|
|
checkAddEntry();
|
|
checkRemoveEntry();
|
|
} catch (Exception e) {
|
|
LOGGER.error("Error while refreshing the database", e);
|
|
}
|
|
|
|
// clear the FilmsList and FilmRoot children
|
|
mainWindowController.getFilmsList().clear();
|
|
mainWindowController.getFilmRoot().getChildren().clear();
|
|
|
|
loadDataToFilmsList(); // load the new data to the FilmsList
|
|
}
|
|
|
|
/**
|
|
* check if there are any entries that have been removed from the film-directory
|
|
* @throws SQLException
|
|
*/
|
|
private void checkRemoveEntry() throws SQLException {
|
|
PreparedStatement ps = connection.prepareStatement("DELETE FROM films WHERE streamUrl = ?");
|
|
LOGGER.info("checking for entrys to remove to DB ...");
|
|
|
|
for (DatabaseDataType dbStreamEntry : databaseStream) {
|
|
// if the directory doen't contain the entry form the database, remove it
|
|
|
|
// if sourceStreams has a item where StreamUrl equals dbStreamEntry.getStreamUrl() return it, else null
|
|
DatabaseDataType result = sourceStreams.stream()
|
|
.filter(x -> dbStreamEntry.getStreamUrl().equals(x.getStreamUrl()))
|
|
.findAny()
|
|
.orElse(null);
|
|
|
|
// if the result is null, the file is missing, remove it from the database
|
|
if (result == null) {
|
|
ps.setString(1, dbStreamEntry.getStreamUrl());
|
|
ps.addBatch();
|
|
LOGGER.info("removed \"" + dbStreamEntry.getTitle() + "\" from database");
|
|
}
|
|
}
|
|
|
|
ps.executeBatch();
|
|
connection.commit();
|
|
ps.close();
|
|
}
|
|
|
|
/**
|
|
* check if there are new films in the film-directory
|
|
* @throws SQLException
|
|
* @throws FileNotFoundException
|
|
* @throws IOException
|
|
*/
|
|
private void checkAddEntry() throws SQLException, FileNotFoundException, IOException {
|
|
PreparedStatement ps = connection.prepareStatement("insert into films values (?, ?, ?, ?, ?, ?, ?)");
|
|
LOGGER.info("checking for entrys to add to DB ...");
|
|
|
|
// new
|
|
for (DatabaseDataType sourceStreamEntry : sourceStreams) {
|
|
|
|
// if databaseStream has a item where StreamUrl equals sourceStreamEntry.getStreamUrl() return it, else null
|
|
DatabaseDataType result = databaseStream.stream()
|
|
.filter(x -> sourceStreamEntry.getStreamUrl().equals(x.getStreamUrl()))
|
|
.findAny()
|
|
.orElse(null);
|
|
|
|
// if the result is null, the entry is missing, add it to the database
|
|
if (result == null) {
|
|
ps.setString(1, sourceStreamEntry.getStreamUrl());
|
|
ps.setString(2, sourceStreamEntry.getTitle());
|
|
ps.setString(3, sourceStreamEntry.getSeason());
|
|
ps.setString(4, sourceStreamEntry.getEpisode());
|
|
ps.setInt(5, sourceStreamEntry.getFavorite());
|
|
ps.setBoolean(6, sourceStreamEntry.getCached());
|
|
ps.setDouble(7, sourceStreamEntry.getCurrentTime());
|
|
ps.addBatch(); // adds the entry
|
|
LOGGER.info("Added \"" + sourceStreamEntry.getTitle() + "\" to database");
|
|
databaseStream.add(sourceStreamEntry);
|
|
}
|
|
}
|
|
|
|
ps.executeBatch();
|
|
connection.commit();
|
|
ps.close();
|
|
}
|
|
|
|
/**
|
|
* DEBUG
|
|
* prints all entries from the database to the console
|
|
*/
|
|
public void printAllDBEntriesDEBUG() {
|
|
System.out.println("Outputting all entries ... \n");
|
|
try {
|
|
Statement stmt = connection.createStatement();
|
|
ResultSet rs = stmt.executeQuery("SELECT * FROM films");
|
|
while (rs.next()) {
|
|
System.out.println(rs.getString("streamUrl"));
|
|
System.out.println(rs.getString("title"));
|
|
System.out.println(rs.getString("season"));
|
|
System.out.println(rs.getString("episode"));
|
|
System.out.println(rs.getString("rating"));
|
|
System.out.println(rs.getString("cached"));
|
|
System.out.println(rs.getString("currentTime") + "\n");
|
|
}
|
|
rs.close();
|
|
stmt.close();
|
|
} catch (SQLException e) {
|
|
LOGGER.error("An error occured, while printing all entries", e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* update the database entry for the given film, favorite = 0
|
|
* @param streamUrl URL of the film
|
|
*/
|
|
public void dislike(String streamUrl) {
|
|
LOGGER.info("dislike " + streamUrl);
|
|
try {
|
|
PreparedStatement ps = connection.prepareStatement("UPDATE films SET favorite = 0 WHERE streamUrl = ?");
|
|
ps.setString(1, streamUrl);
|
|
ps.executeUpdate();
|
|
connection.commit();
|
|
ps.close();
|
|
} catch (SQLException e) {
|
|
LOGGER.error("Ups! an error occured!", e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* update the database entry for the given film, favorite = 1
|
|
* @param streamUrl URL of the film
|
|
*/
|
|
public void like(String streamUrl) {
|
|
LOGGER.info("like " + streamUrl);
|
|
try {
|
|
PreparedStatement ps = connection.prepareStatement("UPDATE films SET favorite = 1 WHERE streamUrl = ?");
|
|
ps.setString(1, streamUrl);
|
|
ps.executeUpdate();
|
|
connection.commit();
|
|
ps.close();
|
|
} catch (SQLException e) {
|
|
LOGGER.error("Ups! an error occured!", e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* update the database entry for the given film, cached = 1
|
|
* @param streamUrl URL of the film
|
|
*/
|
|
public void setCached(String streamUrl) {
|
|
try {
|
|
PreparedStatement ps = connection.prepareStatement("UPDATE films SET cached = 1 WHERE streamUrl = ?");
|
|
ps.setString(1, streamUrl);
|
|
ps.executeUpdate();
|
|
connection.commit();
|
|
ps.close();
|
|
} catch (SQLException e) {
|
|
LOGGER.error("Ups! an error occured!", e);
|
|
}
|
|
|
|
refresh(streamUrl, mainWindowController.getIndexList());
|
|
}
|
|
|
|
/**
|
|
* add the received data to the cache table
|
|
* @param streamUrl URL of the film
|
|
* @param omdbResponse the response data from omdbAPI
|
|
*/
|
|
public void addCache(String streamUrl, OMDbAPIResponseDataType omdbResponse) {
|
|
try {
|
|
PreparedStatement ps = connection.prepareStatement("insert into cache values (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)");
|
|
|
|
LOGGER.info("adding cache for: " + streamUrl);
|
|
ps.setString(1,streamUrl);
|
|
ps.setString(2,omdbResponse.getTitle());
|
|
ps.setString(3,omdbResponse.getYear());
|
|
ps.setString(4,omdbResponse.getRated());
|
|
ps.setString(5,omdbResponse.getReleased());
|
|
ps.setString(6,omdbResponse.getSeason());
|
|
ps.setString(7,omdbResponse.getEpisode());
|
|
ps.setString(8,omdbResponse.getRuntime());
|
|
ps.setString(9,omdbResponse.getGenre());
|
|
ps.setString(10,omdbResponse.getDirector());
|
|
ps.setString(11,omdbResponse.getWriter());
|
|
ps.setString(12,omdbResponse.getActors());
|
|
ps.setString(13,omdbResponse.getPlot());
|
|
ps.setString(14,omdbResponse.getLanguage());
|
|
ps.setString(15,omdbResponse.getCountry());
|
|
ps.setString(16,omdbResponse.getAwards());
|
|
ps.setString(17,omdbResponse.getPoster());
|
|
ps.setString(18,omdbResponse.getMetascore());
|
|
ps.setString(19,omdbResponse.getImdbRating());
|
|
ps.setString(20,omdbResponse.getImdbVotes());
|
|
ps.setString(21,omdbResponse.getImdbID());
|
|
ps.setString(22,omdbResponse.getType());
|
|
ps.setString(23,omdbResponse.getDvd());
|
|
ps.setString(24,omdbResponse.getBoxOffice());
|
|
ps.setString(25,omdbResponse.getWebsite());
|
|
ps.setString(26,omdbResponse.getResponse());
|
|
|
|
ps.addBatch();
|
|
ps.executeBatch();
|
|
connection.commit();
|
|
ps.close();
|
|
} catch (Exception e) {
|
|
LOGGER.error(e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* checks if there is already a entry with the given streamUrl in the cache
|
|
* @param streamUrl URL of the element
|
|
* @return true if the element is already cached, else false
|
|
*/
|
|
public boolean searchCacheByURL(String streamUrl) {
|
|
boolean retValue = false;
|
|
try {
|
|
PreparedStatement ps = connection.prepareStatement("SELECT * FROM cache WHERE streamUrl = ?");
|
|
ps.setString(1, streamUrl);
|
|
ResultSet rs = ps.executeQuery();
|
|
retValue = rs.next();
|
|
rs.close();
|
|
ps.close();
|
|
} catch (Exception e) {
|
|
LOGGER.error("Ups! error while getting the current time!", e);
|
|
}
|
|
|
|
return retValue;
|
|
}
|
|
|
|
/**
|
|
* sets the cached data to mwc's TextFlow
|
|
* @param streamUrl URL of the film
|
|
*/
|
|
public void readCache(String streamUrl) {
|
|
try {
|
|
PreparedStatement ps = connection.prepareStatement("SELECT * FROM cache WHERE streamUrl = ?");
|
|
ps.setString(1, streamUrl);
|
|
ResultSet rs = ps.executeQuery();
|
|
Font font = Font.font("System", FontWeight.BOLD, (int) Math.round(XMLController.getFontSize()));
|
|
ObservableList<Node> textFlow = mainWindowController.getTextFlow().getChildren();
|
|
ArrayList<Text> nameText = new ArrayList<Text>();
|
|
|
|
nameText.add(new Text(XMLController.getLocalBundle().getString("title") + ": "));
|
|
nameText.add(new Text(XMLController.getLocalBundle().getString("year") + ": "));
|
|
nameText.add(new Text(XMLController.getLocalBundle().getString("rated") + ": "));
|
|
nameText.add(new Text(XMLController.getLocalBundle().getString("released") + ": "));
|
|
nameText.add(new Text(XMLController.getLocalBundle().getString("season") + ": "));
|
|
nameText.add(new Text(XMLController.getLocalBundle().getString("episode") + ": "));
|
|
nameText.add(new Text(XMLController.getLocalBundle().getString("runtime") + ": "));
|
|
nameText.add(new Text(XMLController.getLocalBundle().getString("genre") + ": "));
|
|
nameText.add(new Text(XMLController.getLocalBundle().getString("director") + ": "));
|
|
nameText.add(new Text(XMLController.getLocalBundle().getString("writer") + ": "));
|
|
nameText.add(new Text(XMLController.getLocalBundle().getString("actors") + ": "));
|
|
nameText.add(new Text(XMLController.getLocalBundle().getString("plot") + ": "));
|
|
nameText.add(new Text(XMLController.getLocalBundle().getString("language") + ": "));
|
|
nameText.add(new Text(XMLController.getLocalBundle().getString("country") + ": "));
|
|
nameText.add(new Text(XMLController.getLocalBundle().getString("awards") + ": "));
|
|
nameText.add(new Text(XMLController.getLocalBundle().getString("metascore") + ": "));
|
|
nameText.add(new Text(XMLController.getLocalBundle().getString("imdbRating") + ": "));
|
|
nameText.add(new Text(XMLController.getLocalBundle().getString("type") + ": "));
|
|
nameText.add(new Text(XMLController.getLocalBundle().getString("boxOffice") + ": "));
|
|
nameText.add(new Text(XMLController.getLocalBundle().getString("website") + ": "));
|
|
|
|
// set the correct font for the nameText
|
|
for (Text text : nameText) {
|
|
text.setFont(font);
|
|
}
|
|
|
|
// clear the textFlow and all the new text
|
|
textFlow.clear();
|
|
textFlow.addAll(nameText.get(0), new Text(rs.getString("Title") + "\n"));
|
|
textFlow.addAll(nameText.get(1), new Text(rs.getString("Year") + "\n"));
|
|
textFlow.addAll(nameText.get(2), new Text(rs.getString("Rated") + "\n"));
|
|
textFlow.addAll(nameText.get(3), new Text(rs.getString("Released") + "\n"));
|
|
|
|
if (rs.getString("Episode").length() > 0) {
|
|
textFlow.addAll(nameText.get(4), new Text(rs.getString("Season") + "\n"));
|
|
textFlow.addAll(nameText.get(5), new Text(rs.getString("Episode") + "\n"));
|
|
}
|
|
|
|
textFlow.addAll(nameText.get(6), new Text(rs.getString("Runtime") + "\n"));
|
|
textFlow.addAll(nameText.get(7), new Text(rs.getString("Genre") + "\n"));
|
|
textFlow.addAll(nameText.get(8), new Text(rs.getString("Director") + "\n"));
|
|
textFlow.addAll(nameText.get(9), new Text(rs.getString("Writer") + "\n"));
|
|
textFlow.addAll(nameText.get(10), new Text(rs.getString("Actors") + "\n"));
|
|
textFlow.addAll(nameText.get(11), new Text(rs.getString("Plot") + "\n"));
|
|
textFlow.addAll(nameText.get(12), new Text(rs.getString("Language") + "\n"));
|
|
textFlow.addAll(nameText.get(13), new Text(rs.getString("Country") + "\n"));
|
|
textFlow.addAll(nameText.get(14), new Text(rs.getString("Awards") + "\n"));
|
|
textFlow.addAll(nameText.get(15), new Text(rs.getString("metascore") + "\n"));
|
|
textFlow.addAll(nameText.get(16), new Text(rs.getString("imdbRating") + "\n"));
|
|
textFlow.addAll(nameText.get(17), new Text(rs.getString("Type") + "\n"));
|
|
textFlow.addAll(nameText.get(18), new Text(rs.getString("BoxOffice") + "\n"));
|
|
textFlow.addAll(nameText.get(19), new Text(rs.getString("Website") + "\n"));
|
|
|
|
mainWindowController.getTextFlow().setStyle("-fx-font-size : " + ((int) Math.round(XMLController.getFontSize()) + 1) + "px;");
|
|
|
|
// add the image
|
|
try {
|
|
mainWindowController.getPosterImageView().setImage(new Image(new File(rs.getString("Poster")).toURI().toString()));
|
|
} catch (Exception e) {
|
|
mainWindowController.getPosterImageView().setImage(new Image("icons/close_black_2048x2048.png"));
|
|
LOGGER.error("No Poster found, useing default.");
|
|
}
|
|
|
|
rs.close();
|
|
ps.close();
|
|
} catch (SQLException e) {
|
|
LOGGER.error("Ups! an error occured!", e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* get all NOT cached entries
|
|
* @return a {@link ArrayList} of all NOT cached entries
|
|
*/
|
|
public ArrayList<FilmTabelDataType> getAllNotCachedEntries() {
|
|
ArrayList<FilmTabelDataType> notCachedEntries = new ArrayList<>();
|
|
|
|
try {
|
|
Statement stmt = connection.createStatement();
|
|
ResultSet rs = stmt.executeQuery("SELECT * FROM films WHERE cached = 0");
|
|
while (rs.next()) {
|
|
notCachedEntries.add(new FilmTabelDataType(rs.getString("streamUrl"),
|
|
rs.getString("title"), rs.getString("season"), rs.getString("episode"), rs.getBoolean("favorite"),
|
|
rs.getBoolean("cached"), new ImageView(favorite_border_black)));
|
|
}
|
|
stmt.close();
|
|
rs.close();
|
|
} catch (SQLException e) {
|
|
LOGGER.error("An error occured, while getting all NOT cached entries", e);
|
|
}
|
|
|
|
LOGGER.info("There are {} entries not Chached!", notCachedEntries.size());
|
|
return notCachedEntries;
|
|
}
|
|
|
|
/**
|
|
* return the currentTime in ms saved in the database
|
|
* @param streamUrl URL of the film
|
|
* @return {@link Double} currentTime in ms
|
|
*/
|
|
public double getCurrentTime(String streamUrl) {
|
|
LOGGER.info("get currentTime: " + streamUrl);
|
|
double currentTime = 0;
|
|
try {
|
|
PreparedStatement ps = connection.prepareStatement("SELECT * FROM films WHERE streamUrl = ?");
|
|
ps.setString(1, streamUrl);
|
|
ResultSet rs = ps.executeQuery();
|
|
currentTime = rs.getDouble("currentTime");
|
|
rs.close();
|
|
ps.close();
|
|
} catch (Exception e) {
|
|
LOGGER.error("Ups! error while getting the current time!", e);
|
|
}
|
|
|
|
return currentTime;
|
|
}
|
|
|
|
/**
|
|
* save the currentTime to the database
|
|
* @param streamUrl URL of the film
|
|
* @param currentTime currentTime in ms of the film
|
|
*/
|
|
public void setCurrentTime(String streamUrl, double currentTime) {
|
|
LOGGER.info("set currentTime: " + streamUrl);
|
|
try {
|
|
PreparedStatement ps = connection.prepareStatement("UPDATE films SET currentTime = ? WHERE streamUrl = ?");
|
|
ps.setDouble(1, currentTime);
|
|
ps.setString(2, streamUrl);
|
|
ps.executeUpdate();
|
|
connection.commit();
|
|
ps.close();
|
|
} catch (SQLException e) {
|
|
LOGGER.error("Ups! error while updateing the current time!", e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* get the next episode of a series
|
|
* @param title title of the film
|
|
* @param episode episode currently played
|
|
* @return {@link FilmTabelDataType} the next episode as object
|
|
*/
|
|
public FilmTabelDataType getNextEpisode(String title, int episode, int season) {
|
|
FilmTabelDataType nextFilm = null;
|
|
|
|
try {
|
|
// try to get a new episode of the current season
|
|
PreparedStatement ps = connection.prepareStatement("SELECT * FROM films WHERE title = ? AND season = ? AND episode = ?");
|
|
ps.setString(1, title);
|
|
ps.setString(2, Integer.toString(season));
|
|
ps.setString(3, Integer.toString(episode + 1));
|
|
ResultSet rs = ps.executeQuery();
|
|
|
|
/* if that fails get the next season and try to get a episode there,
|
|
* we need to test only for the next season, first episode,
|
|
* any other entry would not exist in the database
|
|
*/
|
|
if(!rs.next()) {
|
|
ps.setString(1, title);
|
|
ps.setString(2, Integer.toString(season + 1));
|
|
ps.setString(3, Integer.toString(1));
|
|
rs = ps.executeQuery();
|
|
if(!rs.next()) return nextFilm; // if we haven't found anything return an empty object
|
|
}
|
|
|
|
// at this point we have found the correct episode
|
|
nextFilm = new FilmTabelDataType(rs.getString("streamUrl"), rs.getString("title"),
|
|
rs.getString("season"), rs.getString("episode"), rs.getBoolean("favorite"),
|
|
rs.getBoolean("cached"), new ImageView());
|
|
|
|
rs.close();
|
|
ps.close();
|
|
} catch (Exception e) {
|
|
LOGGER.error("Ups! error while getting next episode!", e);
|
|
}
|
|
return nextFilm;
|
|
}
|
|
|
|
/**
|
|
* get the last watched episode
|
|
* @param title the title of the series
|
|
* @return the last watched episode as {@link FilmTabelDataType} object
|
|
*/
|
|
public FilmTabelDataType getLastWatchedEpisode(String title) {
|
|
LOGGER.info("last watched episode of: " + title);
|
|
FilmTabelDataType nextFilm = null;
|
|
double lastCurrentTime = 0;
|
|
|
|
try {
|
|
Statement stmt = connection.createStatement();
|
|
ResultSet rs = stmt.executeQuery("SELECT * FROM films WHERE title = \"" + title + "\";");
|
|
while (rs.next()) {
|
|
nextFilm = new FilmTabelDataType(rs.getString("streamUrl"), rs.getString("title"),
|
|
rs.getString("season"), rs.getString("episode"), rs.getBoolean("favorite"),
|
|
rs.getBoolean("cached"), new ImageView());
|
|
if (rs.getDouble("currentTime") > lastCurrentTime) {
|
|
lastCurrentTime = rs.getDouble("currentTime");
|
|
nextFilm = new FilmTabelDataType(rs.getString("streamUrl"), rs.getString("title"),
|
|
rs.getString("season"), rs.getString("episode"), rs.getBoolean("favorite"),
|
|
rs.getBoolean("cached"), new ImageView());
|
|
break;
|
|
}
|
|
}
|
|
rs.close();
|
|
stmt.close();
|
|
} catch (Exception e) {
|
|
LOGGER.error("Ups! error while getting the last watched episode!", e);
|
|
}
|
|
|
|
return nextFilm;
|
|
}
|
|
|
|
/**
|
|
* check if a file is a video
|
|
* @param path the path to the file
|
|
* @return true if the file is a video, else false
|
|
*/
|
|
public static boolean isVideoFile(String path) {
|
|
String mimeType = URLConnection.guessContentTypeFromName(path);
|
|
return mimeType != null && mimeType.startsWith("video");
|
|
}
|
|
|
|
}
|