mirror of
https://github.com/ksyasuda/aniwrapper.git
synced 2024-11-22 03:19:53 -08:00
936 lines
25 KiB
Bash
Executable File
936 lines
25 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
|
|
VERBOSE=0
|
|
|
|
BASE_URL=$(curl -s -L -o /dev/null -w "%{url_effective}\n" https://gogoanime.cm)
|
|
CFG_DIR="${XDG_CONFIG_HOME:-$HOME/.config}/aniwrapper"
|
|
HISTORY_DB="$CFG_DIR/history.sqlite3"
|
|
ANIWRAPPER_ICON_PATH="$CFG_DIR/icons/icon-64.png"
|
|
MAISAN_ICON_PATH="$CFG_DIR/icons/MYsan.png"
|
|
ROFI_THEME="aniwrapper.rasi"
|
|
ROFI_CFG="$CFG_DIR/themes/$ROFI_THEME"
|
|
PLAYER_CMD="mpv"
|
|
THEMES="aniwrapper (default)|dracula|hidpi"
|
|
|
|
# dependencies: grep, sed, curl, video_player, rofi, sqlite3
|
|
# video_player ( needs to be able to play urls )
|
|
player_fn="mpv"
|
|
playable="\.mp4|\.mkv|\.ts|\.mp3|\.webm"
|
|
prog="ani-cli"
|
|
|
|
c_red="\033[1;31m"
|
|
c_green="\033[1;32m"
|
|
c_yellow="\033[1;33m"
|
|
c_blue="\033[1;34m"
|
|
c_magenta="\033[1;35m"
|
|
c_cyan="\033[1;36m"
|
|
c_reset="\033[0m"
|
|
|
|
help_text() {
|
|
while IFS= read -r line; do
|
|
printf "%s\n" "$line"
|
|
done <<- EOF
|
|
USAGE: $prog <query>
|
|
-h show this help text
|
|
-d download episode
|
|
-H continue where you left off
|
|
EOF
|
|
}
|
|
|
|
die() {
|
|
printf "$c_red%s$c_reset\n" "$*" >&2
|
|
exit 1
|
|
}
|
|
|
|
err() {
|
|
printf "$c_red%s$c_reset\n" "$*" >&2
|
|
}
|
|
|
|
log() {
|
|
# prints passed in args to stdout if $VERBOSE is set to 1
|
|
[ "$VERBOSE" -eq 1 ] && printf "%s\n" "$*" >&2
|
|
}
|
|
|
|
search_anime() {
|
|
# get anime name along with its id
|
|
log "NUM ARGS: $#"
|
|
if [[ $# -gt 1 ]]; then
|
|
# if multi-word query, concatenate into one string and replace spaces with '-'
|
|
search="$*"
|
|
search="${search// /-}"
|
|
else
|
|
# if one word, remove leading or trailing whitespace
|
|
search="${1// /}"
|
|
fi
|
|
log "Search Query: $search"
|
|
titlepattern='<a href="/category/'
|
|
curl -s "$BASE_URL//search.html" \
|
|
-G \
|
|
-d "keyword=$search" |
|
|
sed -n -E '
|
|
s_^[[:space:]]*<a href="/category/([^"]*)" title="([^"]*)".*_\1_p
|
|
'
|
|
}
|
|
|
|
search_eps() {
|
|
# get available episodes for anime_id
|
|
anime_id=$1
|
|
|
|
curl -s "$BASE_URL/category/$anime_id" |
|
|
sed -n -E '
|
|
/^[[:space:]]*<a href="#" class="active" ep_start/{
|
|
s/.* '\''([0-9]*)'\'' ep_end = '\''([0-9]*)'\''.*/\2/p
|
|
q
|
|
}
|
|
'
|
|
}
|
|
|
|
check_input() {
|
|
log "Checking input"
|
|
log "EP START: $ep_choice_start"
|
|
log "EP END: $ep_choice_end"
|
|
[ "$ep_choice_start" -eq "$ep_choice_start" ] 2> /dev/null || die "Invalid number entered: $ep_choice_start"
|
|
episodes=$ep_choice_start
|
|
if [ -n "$ep_choice_end" ]; then
|
|
[ "$ep_choice_end" -eq "$ep_choice_end" ] 2> /dev/null || die "Invalid number entered: $ep_choice_end"
|
|
# create list of episodes to download/watch
|
|
episodes=$(seq $ep_choice_start $ep_choice_end)
|
|
fi
|
|
}
|
|
|
|
get_dpage_link() {
|
|
# get the download page url
|
|
anime_id=$1
|
|
ep_no=$2
|
|
|
|
# credits to fork: https://github.com/Dink4n/ani-cli for the fix
|
|
# dub prefix takes the value "-dub" when dub is needed else is empty
|
|
anime_page=$(curl -s "$BASE_URL/$anime_id${dub_prefix}-$ep_no")
|
|
|
|
if printf '%s' "$anime_page" | grep -q "404"; then
|
|
anime_page=$(curl -s "$BASE_URL/$anime_id${dub_prefix}-episode-$ep_no")
|
|
fi
|
|
|
|
printf '%s' "$anime_page" |
|
|
sed -n -E '
|
|
/^[[:space:]]*<li class="dowloads">/{
|
|
s/.*href="([^"]*)".*/\1/p
|
|
q
|
|
}'
|
|
}
|
|
|
|
get_video_quality() {
|
|
dpage_url=$1
|
|
|
|
video_links=$(curl -s "$sb_url" | sed -n -E 's/.*a href="#" onclick="download_video([^"]*)".*/\1/p' | head -1)
|
|
m=$(printf "%s" "$quality" | cut -c1)
|
|
i=$(printf "%s" "$video_links" | cut -d\' -f2)
|
|
h=$(printf "%s" "$video_links" | cut -d\' -f6)
|
|
video_link=$(curl -s "https://sbplay2.com/dl?op=download_orig&id=$i&mode=$m&hash=$h" | sed -n -E 's/<a href="([^"]*.mp4)".*/\1/p')
|
|
if [ -z "$video_link" ]; then
|
|
err "$quality quality doesn't exist, falling back to normal quality"
|
|
video_link=$(curl -s "https://sbplay2.com/dl?op=download_orig&id=$i&mode=n&hash=$h" | sed -n -E 's/<a href="([^"]*.mp4)".*/\1/p')
|
|
fi
|
|
|
|
printf '%s' "$video_link"
|
|
}
|
|
|
|
get_links() {
|
|
dpage_url="$1"
|
|
sb_url=$(curl -s "$dpage_url" |
|
|
sed -n -E 's/^[[:space:]]*href="([^"]*)".*/\1/p' | grep -oE ".*sbplay.*")
|
|
|
|
video_url=$(get_video_quality "$sb_url")
|
|
|
|
printf '%s' "$video_url"
|
|
}
|
|
|
|
dep_ch() {
|
|
for dep; do
|
|
if ! command -v "$dep" > /dev/null; then
|
|
die "Program \"$dep\" not found. Please install it."
|
|
fi
|
|
done
|
|
}
|
|
|
|
check_anime_name() {
|
|
# Check to make sure passed in name is not empty
|
|
log "VAR: $1"
|
|
if [[ "$1" == "" ]] || [[ "$1" == " " ]] || [[ "$1" == "\n" ]]; then
|
|
log "Passed in name is nothing"
|
|
return 1
|
|
fi
|
|
return 0
|
|
}
|
|
|
|
run_stmt() {
|
|
printf "%s\n" "$1" | sqlite3 -noheader "$HISTORY_DB"
|
|
}
|
|
|
|
#####################
|
|
## Database Code ##
|
|
#####################
|
|
|
|
check_db() {
|
|
# Return number of matches for anime/episode in db
|
|
# args:
|
|
# $1: anime name: str
|
|
# $2: either 'search' or 'watch' for which db to query
|
|
log "check_db $*" 1> /dev/stderr
|
|
if [[ "$1" == "file" ]]; then
|
|
stmt="SELECT DISTINCT COUNT(*) \
|
|
FROM file_history \
|
|
WHERE directory = '$2' \
|
|
AND filename = '$3';"
|
|
elif [[ "$2" == "search" ]]; then
|
|
stmt="SELECT DISTINCT COUNT(*) \
|
|
FROM search_history \
|
|
WHERE anime_name = '$1';"
|
|
else
|
|
stmt="SELECT DISTINCT COUNT(*) \
|
|
FROM watch_history \
|
|
WHERE anime_name = '$1' \
|
|
AND episode_number = '$2';"
|
|
fi
|
|
res=$(run_stmt "$stmt")
|
|
log "check_db result: $res"
|
|
return "$res"
|
|
}
|
|
|
|
# updates search/watch date for passed in anime
|
|
update_date() {
|
|
datetime=$(date +'%Y-%m-%d %H:%M:%S')
|
|
stmt=""
|
|
if [[ "$1" == "file" ]]; then
|
|
log "UPDATING FILE_HISTORY: directory='$2', filename='$3', search_date='$datetime'"
|
|
stmt="UPDATE file_history SET watch_date = '$datetime' \
|
|
WHERE directory = '$2' and filename = '$3';"
|
|
elif [[ "$2" == "search" ]]; then
|
|
log "UPDATING SEARCH_HISTORY: anime_name='$1', search_date='$datetime'"
|
|
stmt="UPDATE search_history SET search_date = '$datetime' \
|
|
WHERE anime_name = '$1';"
|
|
elif [[ $# -ge 3 ]]; then
|
|
[ -z "$3" ] && return 1
|
|
log "UPDATING watch_history from sync. watch_date -> $3"
|
|
stmt="UPDATE watch_history SET watch_date = '$3' \
|
|
WHERE anime_name = '$1' \
|
|
AND episode_number = $2;"
|
|
else
|
|
log "UPDATING WATCH_HISTORY: anime_name='$1', episode_number='$2' search_date='$datetime'"
|
|
stmt="UPDATE watch_history SET watch_date = '$datetime' \
|
|
WHERE anime_name = '$1' \
|
|
AND episode_number = $2;"
|
|
fi
|
|
run_stmt "$stmt"
|
|
}
|
|
|
|
insert_history() {
|
|
# inserts into search/watch history db
|
|
# check the anime_name/id
|
|
log "BEGIN: insert_history function"
|
|
if [[ ! "$1" == "file" ]]; then
|
|
if ! check_anime_name "$1"; then
|
|
log "ERROR: Anime name is none... exiting"
|
|
return 1
|
|
fi
|
|
fi
|
|
datetime=$(date +'%Y-%m-%d %H:%M:%S')
|
|
check_db "$@"
|
|
res="$?"
|
|
if [[ $res -gt 0 ]]; then
|
|
if [[ "$1" == "file" ]]; then
|
|
log "Already in file history db... updaing watch_date"
|
|
elif [[ "$2" == "search" ]]; then
|
|
log "Already in search db... Updating search_date"
|
|
else
|
|
log "Already in watch db... Updating watch_date"
|
|
fi
|
|
update_date "$@"
|
|
else
|
|
if [[ "$1" == "file" ]]; then
|
|
log "inserting $2/$3 into file_history..."
|
|
stmt="INSERT INTO file_history(directory, filename, watch_date) \
|
|
VALUES('$2', '$3', '$datetime');"
|
|
elif [[ "$2" == "search" ]]; then
|
|
stmt="INSERT INTO search_history(anime_name, search_date) \
|
|
VALUES('$1', '$datetime');"
|
|
else
|
|
stmt="INSERT INTO \
|
|
watch_history(anime_name, episode_number, watch_date) \
|
|
VALUES('$1', '$2', '$datetime');"
|
|
fi
|
|
run_stmt "$stmt"
|
|
fi
|
|
log "END: insert_history function"
|
|
}
|
|
|
|
sync_search_history() {
|
|
cnt=0
|
|
while read -r line; do
|
|
anime_name=$(awk -F '|' '{print $2}' <<< "$line")
|
|
res=$(sqlite3 -noheader "$HISTORY_DB" "SELECT COUNT(*) FROM search_history WHERE anime_name = '$anime_name'")
|
|
if [[ "$res" -eq 0 ]]; then
|
|
search_date=$(awk -F '|' '{print $3}' <<< "$line")
|
|
log "Adding ($anime_name|$search_date) to search history..."
|
|
if ! sqlite3 "$HISTORY_DB" "INSERT INTO search_history(anime_name, search_date) VALUES('$anime_name', '$search_date')"; then
|
|
err "Error inserting row $line"
|
|
fi
|
|
((++cnt))
|
|
fi
|
|
done <<< "$(sqlite3 -noheader "$temp_db" "SELECT DISTINCT * FROM search_history")"
|
|
log "Inserted $cnt rows into search_history table"
|
|
}
|
|
|
|
sync_watch_history() {
|
|
cnt=0
|
|
while read -r line; do
|
|
# anime_name=$(awk -F '|' '{print $2}' <<<"$line")
|
|
anime_name="${line/ //}"
|
|
log "ANIME: $anime_name"
|
|
episodes=$(sqlite3 -line -list -noheader "$temp_db" "SELECT episode_number, watch_date FROM watch_history WHERE anime_name = '$anime_name'")
|
|
# for each episode of $anime_name on the remote machine, check local
|
|
while read -r ep; do
|
|
log "ROW: $ep"
|
|
episode_num=$(awk -F '|' '{print $1}' <<< "$ep")
|
|
check_db "$anime_name" "$episode_num"
|
|
num=$?
|
|
log "COUNT for $anime_name - episode $episode_num: $num"
|
|
if [[ "$num" -eq 0 ]]; then
|
|
log "$anime_name - E$episode_num NOT IN DB"
|
|
watch_date=$(awk -F '|' '{print $NF}' <<< "$ep")
|
|
log "Adding ($anime_name|$episode_num|$watch_date) to watch history..."
|
|
insert_history "$anime_name" "$episode_num" "$watch_date"
|
|
((++cnt))
|
|
else
|
|
log "$anime_name - Episode: $episode_num found in the db... skipping"
|
|
fi
|
|
done <<< "${episodes[@]}"
|
|
done <<< "$(sqlite3 -noheader "$temp_db" "SELECT DISTINCT anime_name FROM watch_history")"
|
|
log "Inserted $cnt rows into watch_history table"
|
|
}
|
|
|
|
#####################
|
|
### Play from file###
|
|
#####################
|
|
|
|
# opens the passed in file with $PLAYER_CMD
|
|
play_file() {
|
|
log "Checking if file is playable"
|
|
if [[ "$1" =~ ($playable)$ ]]; then
|
|
log "File is playable..."
|
|
filename=$(grep -oE '[^/]*$' <<< "$1")
|
|
log "FILENAME: $filename"
|
|
insert_history "file" "$1" "$filename" &
|
|
if [[ "$1" =~ .mp3 ]]; then
|
|
log ".mp3 file found... playing without video"
|
|
log "MPV COMMAND: $PLAYER_CMD --no-video $1"
|
|
$PLAYER_CMD --no-video "$1"
|
|
else
|
|
log "MPV COMMAND: $PLAYER_CMD $1"
|
|
$PLAYER_CMD "$1"
|
|
fi
|
|
exit $?
|
|
else
|
|
die "File: $1 is not playable... Quitting"
|
|
fi
|
|
}
|
|
|
|
# attempt to generate list of valid files and directories
|
|
generate_inputlist() {
|
|
# start at 2nd line, because first line out output from find is $1
|
|
outstr=""
|
|
while read -r directory; do
|
|
if [[ "${directory// /}" == "" ]]; then
|
|
continue
|
|
fi
|
|
[ "$outstr" = "" ] && outstr="$directory" || outstr="$outstr|$directory"
|
|
done <<< "$(find "$1" -maxdepth 1 -type d | sed "s|$1/||" | tail -n +2 | sort -V)"
|
|
log "DIRS: $outstr" 1> /dev/stderr
|
|
while read -r filename; do
|
|
if [[ "${filename// /}" == "" ]]; then
|
|
continue
|
|
fi
|
|
[ "$outstr" = "" ] && outstr="$filename" || outstr="$outstr|$filename"
|
|
done <<< "$(find "$1" -maxdepth 1 -type f | sed "s|$1/||" | grep -E "$playable$" | sort -V)"
|
|
log "DIRS + FILES: $outstr" 1> /dev/stderr
|
|
outstr="$outstr|Back|Quit"
|
|
printf "%s\n" "$outstr"
|
|
}
|
|
|
|
generate_file_watchedlist() {
|
|
search_dir="$1"
|
|
watched=""
|
|
cnt=0
|
|
while read -r filename; do
|
|
if ! check_db "file" "$search_dir/$filename" "$filename"; then
|
|
log "$filename watched before... adding to list" 1> /dev/stderr
|
|
[ "$watched" = "" ] && watched="$cnt" || watched="$watched, $cnt"
|
|
fi
|
|
((++cnt))
|
|
done <<< "$(find "$search_dir" -maxdepth 1 -type f | sed "s|$search_dir/||" | grep -E "$playable$" | sort -V)"
|
|
log "WATCHED LIST: $watched" 1> /dev/stderr
|
|
printf "%s\n" "$watched"
|
|
}
|
|
|
|
# recursive function for finding path to video file given a starting directory
|
|
find_media() {
|
|
inp="$1"
|
|
[ -z "$inp" ] && inp="/"
|
|
# workaround to allow logging w/o affecting return output
|
|
log "INPUT DIR: $inp" 1> /dev/stderr
|
|
|
|
# base case hit when a file is found
|
|
if [ -f "$inp" ]; then
|
|
printf "%s\n" "$inp"
|
|
return 0
|
|
fi
|
|
|
|
span=$(generate_span "Current directory: $inp")
|
|
inputlist=$(generate_inputlist "$inp")
|
|
watched_files=$(generate_file_watchedlist "$inp")
|
|
selection=$(rofi -dmenu -only-match -config "$ROFI_CFG" \
|
|
-l 13 -i -sep '|' -mesg "$span" -a "$watched_files" \
|
|
-p "Enter selection" <<< "${inputlist[@]}")
|
|
|
|
if [ -z "$selection" ] || [ "$selection" = "Quit" ]; then
|
|
return 1
|
|
elif [ "$selection" = "Back" ]; then
|
|
# go up one directory
|
|
find_media "$(sed -E "s/(\/[^\/]*$)//" <<< "$inp")"
|
|
elif [ -d "$inp/$selection" ] || [ -f "$inp/$selection" ]; then
|
|
find_media "$inp/$selection"
|
|
return $?
|
|
fi
|
|
}
|
|
|
|
# get query
|
|
get_search_query() {
|
|
# Query the anime to stream/download
|
|
|
|
# Get search history
|
|
# Construct string "<id>. <anime_name>"
|
|
stmt="SELECT DISTINCT id || '. ' || anime_name \
|
|
FROM search_history \
|
|
ORDER BY id DESC;"
|
|
hist=$(run_stmt "$stmt")
|
|
|
|
msg="Choose from list of searched anime below, or enter a unique name of an anime to search for"
|
|
span="<span foreground='peachpuff' style='italic' size='small' weight='light'>$msg</span>"
|
|
if [ -z "$*" ] && [ "$is_rofi" -eq 1 ]; then
|
|
query=$(rofi -dmenu -l 12 -p "Search Anime:" \
|
|
-mesg "$span" \
|
|
-config "$ROFI_CFG" <<< "${hist[@]}")
|
|
# Remove the id from the query
|
|
query="${query//[1-9]*\. /}"
|
|
# query="${query// /}"
|
|
log "Query: $query"
|
|
elif [ "$is_rofi" -eq 0 ]; then
|
|
printf "Search Anime: "
|
|
read -r query
|
|
else
|
|
query=$*
|
|
fi
|
|
}
|
|
|
|
generate_span() {
|
|
msg="$*"
|
|
span="<span foreground='peachpuff' style='italic' size='small' weight='light'>$msg</span>"
|
|
printf "%s\n" "$span"
|
|
}
|
|
|
|
#####################
|
|
## Anime selection ##
|
|
#####################
|
|
|
|
anime_selection() {
|
|
# Select anime from query results
|
|
search_results=$*
|
|
if [ "$is_rofi" -eq 1 ]; then
|
|
count=1
|
|
menu=()
|
|
res=()
|
|
while read -r anime_id; do
|
|
menu+="$count. $anime_id\n"
|
|
idx=$((count - 1))
|
|
res["$idx"]="$anime_id"
|
|
count=$((count + 1))
|
|
done <<- EOF
|
|
$search_results
|
|
EOF
|
|
|
|
searched=""
|
|
cnt=0
|
|
# Get the comma separated list of indexes of anime that has been searched before
|
|
for anime in "${res[@]}"; do
|
|
log "ANIME: $anime"
|
|
check_db "$anime" "search"
|
|
if [[ $? -gt 0 ]]; then
|
|
log "SEARCHED BEFORE"
|
|
if [ -z "$searched" ]; then
|
|
searched="$cnt"
|
|
else
|
|
searched="$searched, $cnt"
|
|
fi
|
|
fi
|
|
((++cnt))
|
|
done
|
|
|
|
log "SEARCHED: $searched"
|
|
|
|
# get the anime from indexed list
|
|
msg="<span foreground='peachpuff' style='italic' size='small' weight='normal'>Query: $query</span>"
|
|
user_input=$(printf "${menu[@]}" |
|
|
rofi -dmenu -config "$ROFI_CFG" \
|
|
-a "$searched" \
|
|
-l 12 -i -p "Enter selection:" \
|
|
-mesg "$msg" -only-match)
|
|
[ -z "$user_input" ] && return 1
|
|
|
|
choice=$(printf '%s\n' "$user_input" | awk '{print $1}')
|
|
# Remove period after number
|
|
choice="${choice::-1}"
|
|
name=$(printf '%s\n' "$user_input" | awk '{print $NF}')
|
|
else
|
|
menu_format_string='[%d] %s\n'
|
|
menu_format_string_c1="$c_blue[$c_cyan%d$c_blue] $c_reset%s\n"
|
|
menu_format_string_c2="$c_blue[$c_cyan%d$c_blue] $c_yellow%s$c_reset\n"
|
|
|
|
count=1
|
|
while read anime_id; do
|
|
# alternating colors for menu
|
|
[ $((count % 2)) -eq 0 ] &&
|
|
menu_format_string=$menu_format_string_c1 ||
|
|
menu_format_string=$menu_format_string_c2
|
|
|
|
printf "$menu_format_string" "$count" "$anime_id"
|
|
count=$((count + 1))
|
|
done <<< "$search_results"
|
|
|
|
# User input
|
|
printf "$c_blue%s$c_green" "Enter number: "
|
|
read choice
|
|
printf "$c_reset"
|
|
name="$anime_id"
|
|
fi
|
|
|
|
log "CHOICE: $choice"
|
|
|
|
if [ "$is_rofi" -eq 1 ]; then
|
|
# check both choice and name are set
|
|
if [[ ! "$choice" ]] || [[ ! "$name" ]]; then
|
|
die "Invalid choice... committing seppuku"
|
|
fi
|
|
fi
|
|
# Check if input is a number
|
|
[ "$choice" -eq "$choice" ] 2> /dev/null || die "Invalid number entered"
|
|
|
|
# Select respective anime_id
|
|
count=1
|
|
while read -r anime_id; do
|
|
if [ "$count" -eq "$choice" ]; then
|
|
selection_id=$anime_id
|
|
break
|
|
fi
|
|
count=$((count + 1))
|
|
done <<- EOF
|
|
$search_results
|
|
EOF
|
|
|
|
[ -z "$name" ] && name="$anime_id"
|
|
log "NAME: $name"
|
|
insert_history "$name" "search" &
|
|
|
|
printf "$c_reset"
|
|
|
|
[ -z "$selection_id" ] && die "Invalid number entered"
|
|
|
|
read -r last_ep_number <<- EOF
|
|
$(search_eps "$selection_id")
|
|
EOF
|
|
}
|
|
|
|
##################
|
|
## Ep selection ##
|
|
##################
|
|
|
|
episode_selection() {
|
|
ep_choice_start="1"
|
|
if [ "$is_rofi" -eq 1 ]; then
|
|
# select episode number for anime
|
|
log "Anime ID: $anime_id"
|
|
stmt="SELECT DISTINCT episode_number \
|
|
FROM watch_history \
|
|
WHERE anime_name = '$anime_id';"
|
|
hist=$(run_stmt "$stmt")
|
|
# log "HISTORY: ${hist[*]}"
|
|
|
|
# Get Watch History for $anime_id as comma separated list
|
|
watch_history=""
|
|
for i in $hist; do
|
|
if [[ "$watch_history" == "" ]]; then
|
|
watch_history="$((--i))"
|
|
else
|
|
watch_history="$watch_history, $((--i))"
|
|
fi
|
|
done
|
|
|
|
# get user choice and set the start and end
|
|
msg='<span foreground="peachpuff" style="italic" size="small" weight="light">Range of episodes can be provided as: START_EPISODE - END_EPISODE</span>'
|
|
choice=$(
|
|
seq 1 "$last_ep_number" |
|
|
rofi -dmenu -l 12 \
|
|
-a "$watch_history" \
|
|
-p "Select Episode [1, $last_ep_number]:" \
|
|
-mesg "$msg" \
|
|
-config "$ROFI_CFG"
|
|
)
|
|
ep_choice_start=$(printf '%s\n' "${choice}" | awk '{print $1}')
|
|
ep_choice_end=$(printf '%s\n' "${choice}" | awk '{print $NF}')
|
|
log "START: $ep_choice_start | END: $ep_choice_end"
|
|
elif [ $last_ep_number -gt 1 ]; then
|
|
[ $is_download -eq 1 ] &&
|
|
printf "Range of episodes can be specified: start_number end_number\n"
|
|
|
|
printf "${c_blue}Choose episode $c_cyan[1-%d]$c_reset:$c_green " $last_ep_number
|
|
read ep_choice_start ep_choice_end
|
|
printf "$c_reset"
|
|
fi
|
|
# check for half episode
|
|
log "Checking if selected a half episode"
|
|
if [ "$(echo "$ep_choice_start" | awk '{ printf substr($0, 1, 1) }')" = "h" ]; then
|
|
log "IS A HALF EPISODE"
|
|
half_ep=1
|
|
ep_choice_start=$(echo "$ep_choice_start" | awk '{ printf substr($0, 2) }')
|
|
ep_choice_end=$ep_choice_start
|
|
fi
|
|
if [[ -z "$ep_choice_start" ]] && [[ -z "$ep_choice_end" ]]; then
|
|
die "No episode range entered"
|
|
fi
|
|
# if only one episode was entered, set ep_choice_end to empty string so only selected episode plays
|
|
# otherwise plays from ep 1 - ep_choice_start
|
|
if [[ "$ep_choice_start" -eq "$ep_choice_end" ]]; then
|
|
ep_choice_end=""
|
|
fi
|
|
|
|
printf "$c_reset"
|
|
|
|
}
|
|
|
|
open_episode() {
|
|
anime_id=$1
|
|
episode=$2
|
|
ddir="$3"
|
|
|
|
if [ $half_ep -eq 1 ]; then
|
|
temp_ep=$episode
|
|
episode=$episode"-5"
|
|
fi
|
|
|
|
log "Getting data for episode $episode"
|
|
|
|
# Don't update watch history if downloading episode
|
|
if [ "$is_download" -eq 0 ]; then
|
|
insert_history "$anime_id" "$episode" &
|
|
fi
|
|
|
|
dpage_link=$(get_dpage_link "$anime_id" "$episode")
|
|
video_url=$(get_links "$dpage_link")
|
|
referer_link="https://sbplay2.com"
|
|
|
|
if [ $half_ep -eq 1 ]; then
|
|
episode=$temp_ep
|
|
half_ep=0
|
|
fi
|
|
|
|
if [ "$is_download" -eq 0 ]; then
|
|
kill "$PID" > /dev/null 2>&1
|
|
log "PLAYING VIDEO: $video_url"
|
|
log "REFERRER: $referer_link"
|
|
nohup "$player_fn" --http-header-fields="Referer:$referer_link" "$video_url" > /dev/null 2>&1 &
|
|
PID=$!
|
|
printf "${c_green}\nVideo playing"
|
|
else
|
|
log "Downloading episode $episode ..."
|
|
log "$video_url"
|
|
dl_dir="${ddir// /}/$anime_id"
|
|
# add 0 padding to the episode name
|
|
episode=$(printf "%03d" "$episode")
|
|
{
|
|
mkdir -p "$dl_dir" || die "Could not create directory"
|
|
if command -v "notify-send" > /dev/null; then
|
|
aria2c -x 16 -s 16 --referer="$referer_link" "$video_url" --dir="$dl_dir" -o "$episode.mp4" --download-result=hide &&
|
|
notify-send -i "$ANIWRAPPER_ICON_PATH" "Download complete for ${anime_id//-/ } - Episode: $episode" ||
|
|
notify-send -i "$MAISAN_ICON_PATH" "Download failed for ${anime_id//-/ } - Episode: $episode. Please retry or check your internet connection"
|
|
else
|
|
aria2c -x 16 -s 16 --referer="$referer_link" "$video_url" --dir="$dl_dir" -o "$episode.mp4" --download-result=hide &&
|
|
notify-send -i "$ANIWRAPPER_ICON_PATH" "Download complete for ${anime_id//-/ } - Episode: $episode" ||
|
|
printf "${c_green}Downloaded complete for %s - Episode: %s${c_reset}\n" "${anime_id//-/ }" "$episode" ||
|
|
printf "${c_red}Download failed for %s - Episode: %s, please retry or check your internet connection${c_reset}\n" "${anime_id//-/ }" "$episode"
|
|
fi
|
|
}
|
|
fi
|
|
}
|
|
|
|
stream() {
|
|
log "Running stream()"
|
|
log "args: $*"
|
|
get_search_query "$*"
|
|
searched=0
|
|
if [ $# -le 1 ]; then
|
|
# check if anime has been searched before
|
|
anime_id="${query// /}"
|
|
log "Checking if anime: $anime_id has been searched before..."
|
|
check_db "$anime_id" "search"
|
|
searched="$?"
|
|
log "Searched before: $searched"
|
|
fi
|
|
if [ "$searched" -eq 0 ]; then
|
|
search_results=$(search_anime $query)
|
|
[ -z "$search_results" ] && die "No search results found"
|
|
if ! anime_selection "$search_results"; then
|
|
die "No anime selection found"
|
|
fi
|
|
else
|
|
# if the query is a previous search
|
|
# skip search_anime function and assign $query
|
|
anime_id="${query// /}"
|
|
selection_id="$anime_id"
|
|
insert_history "$anime_id" "search" &
|
|
read -r last_ep_number <<< "$(search_eps "$selection_id")"
|
|
fi
|
|
episode_selection
|
|
}
|
|
|
|
############
|
|
# Start Up #
|
|
############
|
|
|
|
# to clear the colors when exited using SIGINT
|
|
trap "printf '$c_reset'" INT HUP
|
|
|
|
# option parsing
|
|
scrape=query
|
|
quality=normal
|
|
is_rofi=1
|
|
is_download=0
|
|
download_dir="."
|
|
half_ep=0
|
|
while getopts 'hd:Hsvq:c-:f:t:' OPT; do
|
|
case "$OPT" in
|
|
h)
|
|
help_text
|
|
exit 0
|
|
;;
|
|
d)
|
|
is_download=1
|
|
download_dir="$OPTARG"
|
|
log "DOWNLOAD DIR: $download_dir"
|
|
;;
|
|
H)
|
|
scrape=history
|
|
;;
|
|
s)
|
|
scrape=sync
|
|
;;
|
|
v)
|
|
VERBOSE=1
|
|
;;
|
|
q)
|
|
quality="$OPTARG"
|
|
log "passed in quality: $quality"
|
|
;;
|
|
c)
|
|
is_rofi=0
|
|
;;
|
|
-)
|
|
case $OPTARG in
|
|
dub)
|
|
dub_prefix="-dub"
|
|
;;
|
|
*)
|
|
help_text
|
|
exit 1
|
|
;;
|
|
esac
|
|
;;
|
|
f)
|
|
scrape="file"
|
|
play_dir="$OPTARG"
|
|
;;
|
|
t)
|
|
theme="$OPTARG"
|
|
case "$theme" in
|
|
aniwrapper)
|
|
ROFI_THEME=aniwrapper.rasi
|
|
;;
|
|
dracula)
|
|
ROFI_THEME=aniwrapper-dracula.rasi
|
|
;;
|
|
hidpi)
|
|
ROFI_THEME=aniwrapper-hidpi.rasi
|
|
;;
|
|
default)
|
|
ROFI_THEME=aniwrapper.rasi
|
|
;;
|
|
*)
|
|
log "$1 not a valid theme file. Themes: [$THEMES]"
|
|
ROFI_THEME=aniwrapper.rasi
|
|
;;
|
|
esac
|
|
log "Setting theme for ani-cli -> $ROFI_THEME"
|
|
ROFI_CFG="$CFG_DIR/themes/$ROFI_THEME"
|
|
log "ROFI_CFG: $ROFI_CFG"
|
|
;;
|
|
*)
|
|
printf "%s\n" "Invalid option"
|
|
exit 1
|
|
;;
|
|
esac
|
|
done
|
|
shift $((OPTIND - 1))
|
|
|
|
dep_ch "$player_fn" "curl" "sed" "grep" "sqlite3" "rofi" "git" "aria2c"
|
|
|
|
########
|
|
# main #
|
|
########
|
|
|
|
case $scrape in
|
|
query)
|
|
stream "$*"
|
|
;;
|
|
history)
|
|
stmt="SELECT DISTINCT anime_name FROM watch_history ORDER BY watch_date DESC"
|
|
search_results=$(printf "%s\n" "$stmt" | sqlite3 -noheader "$HISTORY_DB")
|
|
[ -z "$search_results" ] && die "History is empty"
|
|
if ! anime_selection "${search_results[@]}"; then
|
|
die "No anime selection found"
|
|
fi
|
|
log "SELECTION: $selection_id"
|
|
|
|
stmt="SELECT episode_number \
|
|
FROM watch_history \
|
|
WHERE anime_name = '$selection_id' \
|
|
ORDER BY watch_date DESC \
|
|
LIMIT 1"
|
|
ep_choice_start=$(run_stmt "$stmt")
|
|
log "Most recently watched episode: $ep_choice_start"
|
|
;;
|
|
sync)
|
|
printf "%s" "Enter username for remote user: "
|
|
read -r username
|
|
printf "%s" "Enter host for remote user: "
|
|
read -r host
|
|
|
|
connection_str="$username@$host"
|
|
printf "%s" "Enter port to connect to remote host with or leave blank for default (22): "
|
|
read -r port
|
|
if [[ "${port/ //}" == "" ]]; then
|
|
PORT=22
|
|
else
|
|
PORT="$port"
|
|
fi
|
|
|
|
printf "%s" "Enter path to private key (leave blank if unsure or not needed): "
|
|
read -r key_path
|
|
|
|
printf "%s\n" "Syncing database with: $connection_str on port $PORT"
|
|
temp_db="/tmp/aniwrapper_tmp_history.sqlite3"
|
|
|
|
if [[ -z "$key_path" ]]; then
|
|
scp -P "$PORT" "$connection_str:$HISTORY_DB" "$temp_db"
|
|
else
|
|
scp -P "$PORT" -i "$key_path" "$connection_str:$HISTORY_DB" "$temp_db"
|
|
fi
|
|
if [[ "$?" -ne 0 ]]; then
|
|
die "Error getting database file from remote host"
|
|
fi
|
|
sync_search_history && sync_watch_history
|
|
exit $?
|
|
;;
|
|
file)
|
|
log "STARTING DIR: $play_dir"
|
|
[ ! -d "$play_dir" ] && die "$play_dir does not exist"
|
|
video_path=$(find_media "$play_dir") || die
|
|
log "VIDEO PATH: $video_path"
|
|
if [ -z "$video_path" ]; then
|
|
die "Something went wrong getting path... path is empty"
|
|
fi
|
|
play_file "$video_path"
|
|
exit $?
|
|
;;
|
|
esac
|
|
|
|
check_input
|
|
|
|
# plays selected episode(s)
|
|
for ep in $episodes; do
|
|
open_episode "$selection_id" "$ep" "$download_dir"
|
|
done
|
|
|
|
if [[ "$is_download" -eq 1 ]]; then
|
|
log "Finished downloading episodes: $episodes for $selection_id... exiting"
|
|
exit 0
|
|
fi
|
|
|
|
episode=${ep_choice_end:-$ep_choice_start}
|
|
|
|
choice=''
|
|
while :; do
|
|
printf "\n${c_green}Currently playing %s episode ${c_cyan}%d/%d\n" "$selection_id" $episode $last_ep_number
|
|
if [ "$episode" -ne "$last_ep_number" ]; then
|
|
printf "$c_blue[${c_cyan}%s$c_blue] $c_yellow%s$c_reset\n" "n" "next episode"
|
|
fi
|
|
if [ "$episode" -ne "1" ]; then
|
|
printf "$c_blue[${c_cyan}%s$c_blue] $c_magenta%s$c_reset\n" "p" "previous episode"
|
|
fi
|
|
if [ "$last_ep_number" -ne "1" ]; then
|
|
printf "$c_blue[${c_cyan}%s$c_blue] $c_yellow%s$c_reset\n" "s" "select episode"
|
|
fi
|
|
printf "$c_blue[${c_cyan}%s$c_blue] $c_magenta%s$c_reset\n" "r" "replay current episode"
|
|
printf "$c_blue[${c_cyan}%s$c_blue] $c_yellow%s$c_reset\n" "a" "search for another anime"
|
|
# printf "$c_blue[${c_cyan}%s$c_blue] $c_magenta%s$c_reset\n" "h" "search history"
|
|
printf "$c_blue[${c_cyan}%s$c_blue] $c_red%s$c_reset\n" "q" "exit"
|
|
printf "${c_blue}Enter choice:${c_green} "
|
|
read -r choice
|
|
|
|
printf "$c_reset"
|
|
case $choice in
|
|
n)
|
|
episode=$((episode + 1))
|
|
;;
|
|
p)
|
|
episode=$((episode - 1))
|
|
;;
|
|
|
|
s)
|
|
printf "${c_blue}Choose episode $c_cyan[1-%d]$c_reset:$c_green " "$last_ep_number"
|
|
read -r episode
|
|
if [ "$(echo "$episode" | cut -c1-1)" = "h" ]; then
|
|
half_ep=1
|
|
episode=$(echo "$episode" | cut -c2-)
|
|
fi
|
|
printf "$c_reset"
|
|
[ "$episode" -eq "$episode" ] 2> /dev/null || die "Invalid number entered"
|
|
;;
|
|
|
|
r)
|
|
episode=$((episode))
|
|
;;
|
|
a)
|
|
stream
|
|
episode=$ep_choice_start
|
|
log "NEW EPISODE: $selection_id - $episode"
|
|
;;
|
|
|
|
q)
|
|
break
|
|
;;
|
|
|
|
*)
|
|
die "invalid choice"
|
|
;;
|
|
esac
|
|
open_episode "$selection_id" "$episode" "$download_dir"
|
|
done
|