2021-11-01 00:23:51 -07:00
#!/usr/bin/env bash
2021-06-09 05:25:23 -07:00
2021-11-02 15:18:23 -07:00
# Set config directory if not already set
if [[ -z "$XDG_CONFIG_HOME" ]]; then
XDG_CONFIG_HOME="$HOME/.config"
fi
2021-11-09 00:54:55 -08:00
VERBOSE=0
2021-12-30 11:08:50 -08:00
# BASE_URL="https://www2.gogoanime.cm/"
BASE_URL=$(curl -s -L -o /dev/null -w "%{url_effective}\n" https://gogoanime.cm)
2021-11-08 00:41:30 -08:00
CFG_DIR="$XDG_CONFIG_HOME/aniwrapper"
2021-11-04 18:37:16 -07:00
ROFI_CFG="meh.rasi"
2021-12-30 20:00:49 -08:00
ANIWRAPPER_ICON_PATH="$CFG_DIR/icons/icon-64.png"
MAISAN_ICON_PATH="$CFG_DIR/icons/MYsan.png"
2021-11-02 15:18:23 -07:00
2021-11-08 00:41:30 -08:00
HISTORY_DB="$XDG_CONFIG_HOME/aniwrapper/history.sqlite3"
2021-11-02 15:18:23 -07:00
2021-11-08 00:41:30 -08:00
# dependencies: grep, sed, curl, video_player, rofi, sqlite3
2021-06-13 04:54:19 -07:00
# video_player ( needs to be able to play urls )
2021-06-13 04:34:16 -07:00
player_fn="mpv"
2021-06-09 05:25:23 -07:00
prog="ani-cli"
2021-06-14 02:22:02 -07:00
logfile="${XDG_CACHE_HOME:-$HOME/.cache}/ani-hsts"
2021-06-09 05:25:23 -07:00
2021-06-09 08:53:30 -07:00
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"
2021-10-29 22:49:52 -07:00
help_text() {
2021-11-25 10:52:59 -08:00
while IFS= read -r line; do
2021-06-09 05:25:23 -07:00
printf "%s\n" "$line"
done <<-EOF
2021-10-29 22:49:52 -07:00
USAGE: $prog <query>
-h show this help text
-d download episode
-H continue where you left off
2021-06-09 05:25:23 -07:00
EOF
}
2021-10-29 22:49:52 -07:00
die() {
2021-06-11 06:40:54 -07:00
printf "$c_red%s$c_reset\n" "$*" >&2
2021-06-09 05:25:23 -07:00
exit 1
}
2021-10-29 22:49:52 -07:00
err() {
2021-06-18 03:18:16 -07:00
printf "$c_red%s$c_reset\n" "$*" >&2
}
2021-11-18 15:52:37 -08:00
log() {
2021-11-24 18:24:17 -08:00
# prints passed in args to stdout if $VERBOSE is set to 1
2021-11-18 15:52:37 -08:00
[ "$VERBOSE" -eq 1 ] && printf "%s\n" "$*" >&2
}
2021-10-29 22:49:52 -07:00
search_anime() {
2021-06-09 05:25:23 -07:00
# get anime name along with its id
2022-01-01 16:54:32 -08:00
log "NUM ARGS: $#"
if [[ $# -gt 1 ]]; then
2022-01-01 17:37:22 -08:00
# if multi-word query, concatenate into one string and replace spaces with '-'
2022-01-01 16:54:32 -08:00
search="$*"
search="${search// /-}"
else
2022-01-01 17:37:22 -08:00
# if one word, remove leading or trailing whitespace
search="${1// /}"
2022-01-01 16:54:32 -08:00
fi
# search=${1// /-}
2021-12-30 11:08:50 -08:00
log "Search Query: $search"
titlepattern='<a href="/category/'
2021-11-06 21:18:24 -07:00
curl -s "$BASE_URL//search.html" \
2021-06-09 05:25:23 -07:00
-G \
-d "keyword=$search" |
2021-12-30 11:08:50 -08:00
sed -n -E '
s_^[[:space:]]*<a href="/category/([^"]*)" title="([^"]*)".*_\1_p
'
2021-06-09 05:25:23 -07:00
}
2021-10-29 22:49:52 -07:00
search_eps() {
2021-06-09 05:25:23 -07:00
# get available episodes for anime_id
anime_id=$1
2021-11-06 21:18:24 -07:00
curl -s "$BASE_URL/category/$anime_id" |
2021-12-30 11:08:50 -08:00
sed -n -E '
2021-06-09 05:25:23 -07:00
/^[[:space:]]*<a href="#" class="active" ep_start/{
s/.* '\''([0-9]*)'\'' ep_end = '\''([0-9]*)'\''.*/\2/p
q
}
'
}
2021-12-30 11:08:50 -08:00
check_input() {
[ "$ep_choice_start" -eq "$ep_choice_start" ] 2>/dev/null || die "Invalid number entered"
episodes=$ep_choice_start
if [ -n "$ep_choice_end" ]; then
[ "$ep_choice_end" -eq "$ep_choice_end" ] 2>/dev/null || die "Invalid number entered"
# create list of episodes to download/watch
episodes=$(seq $ep_choice_start $ep_choice_end)
fi
2021-10-07 03:21:38 -07:00
}
2021-12-10 23:15:40 -08:00
get_embedded_video_link() {
# get the download page url
anime_id=$1
ep_no=$2
2021-06-09 05:25:23 -07:00
2021-12-10 23:15:40 -08:00
# 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
curl -s "$BASE_URL/$anime_id${dub_prefix}-episode-$ep_no" |
sed -n -E '
/^[[:space:]]*<a href="#" rel="100"/{
s/.*data-video="([^"]*)".*/https:\1/p
2021-10-07 03:21:38 -07:00
q
2021-12-10 23:15:40 -08:00
}'
}
2021-12-30 11:08:50 -08:00
get_links() {
embedded_video_url=$(get_embedded_video_link "$anime_id" "$episode")
episode_id=$(echo "$embedded_video_url" | grep -oE "id.+?&")
video_url="https://gogoplay1.com/download?${episode_id}"
}
2021-12-10 23:15:40 -08:00
2021-12-30 11:08:50 -08:00
get_video_quality() {
get_links
video_quality=$(curl -s get_links "$video_url" | grep -oE "(http|https):\/\/.*com\/cdn.*expiry=[0-9]*"| sort -V | sed 's/amp;//')
2021-12-10 23:15:40 -08:00
case $quality in
best)
2021-12-30 11:08:50 -08:00
play_link=$(echo "$video_quality" | sort -V | tail -n 1)
;;
2021-12-10 23:15:40 -08:00
worst)
2021-12-30 11:08:50 -08:00
play_link=$(echo "$video_quality" | sort -V | head -n 1)
;;
*)
play_link=$(echo "$video_quality" | grep -oE "(http|https):\/\/.*com\/cdn.*"${quality}".*expiry=[0-9]*")
if [ -z "$play_link" ]; then
printf "$c_red%s$c_reset\n" "Current video quality is not available (defaulting to highest quality)" >&2
quality=best
play_link=$(echo "$video_quality" | sort -V | tail -n 1)
fi
printf '%s' "$play_link"
;;
esac
2021-06-09 05:25:23 -07:00
}
2021-10-29 22:49:52 -07:00
dep_ch() {
2021-06-11 06:18:20 -07:00
for dep; do
2021-10-29 22:49:52 -07:00
if ! command -v "$dep" >/dev/null; then
2021-06-11 06:18:20 -07:00
die "Program \"$dep\" not found. Please install it."
fi
done
}
2021-10-30 16:30:00 -07:00
check_anime_name() {
2021-11-01 00:23:51 -07:00
# Check to make sure passed in name is not empty
2021-11-18 15:52:37 -08:00
log "VAR: $1"
2021-11-01 03:16:38 -07:00
if [[ "$1" == "" ]] || [[ "$1" == " " ]] || [[ "$1" == "\n" ]]; then
2021-11-18 15:52:37 -08:00
log "Passed in name is nothing"
2021-10-30 16:30:00 -07:00
return 1
fi
return 0
}
2021-11-01 17:05:43 -07:00
run_stmt() {
2021-11-02 15:18:23 -07:00
printf "%s\n" "$1" | sqlite3 -noheader "$HISTORY_DB"
2021-11-01 17:05:43 -07:00
}
2021-11-11 14:13:11 -08:00
#####################
## Database Code ##
#####################
2021-10-29 22:49:52 -07:00
check_db() {
2022-01-01 16:54:32 -08:00
# Return number of matches for anime/episode in db
# args:
# $1: anime name: str
# $2: either 'search' or 'watch' for which db to query
2021-10-29 22:49:52 -07:00
if [[ "$2" == "search" ]]; then
2021-11-01 15:21:58 -07:00
stmt="SELECT DISTINCT COUNT(*) \
FROM search_history \
WHERE anime_name = '$1';"
2021-11-01 17:05:43 -07:00
res=$(run_stmt "$stmt")
2021-10-29 22:49:52 -07:00
return "$res"
else
2021-11-01 15:21:58 -07:00
stmt="SELECT DISTINCT COUNT(*) \
FROM watch_history \
WHERE anime_name = '$1' \
AND episode_number = $2;"
2021-11-01 17:05:43 -07:00
res=$(run_stmt "$stmt")
2021-10-29 22:49:52 -07:00
return "$res"
fi
}
2021-11-25 10:52:59 -08:00
# updates search/watch date for passed in anime
2021-10-29 22:49:52 -07:00
update_date() {
2021-11-01 12:53:10 -07:00
datetime=$(date +'%Y-%m-%d %H:%M:%S')
2021-11-01 17:05:43 -07:00
stmt=""
2021-10-29 22:49:52 -07:00
if [[ "$2" == "search" ]]; then
2021-11-01 12:53:10 -07:00
stmt="UPDATE search_history SET search_date = '$datetime' \
2021-11-01 17:05:43 -07:00
WHERE anime_name = '$1';"
2021-10-29 22:49:52 -07:00
else
2021-11-01 12:53:10 -07:00
stmt="UPDATE watch_history SET watch_date = '$datetime' \
2021-10-30 11:27:37 -07:00
WHERE anime_name = '$1' \
2021-11-01 17:05:43 -07:00
AND episode_number = $2;"
2021-10-29 22:49:52 -07:00
fi
2021-11-01 17:05:43 -07:00
run_stmt "$stmt"
2021-10-29 22:49:52 -07:00
}
insert_history() {
2021-11-01 00:23:51 -07:00
# inserts into search/watch history db
2021-10-30 16:30:00 -07:00
# check the anime_name/id
2021-11-25 10:52:59 -08:00
if ! check_anime_name "$1"; then
2021-11-18 15:52:37 -08:00
log "ERROR: Anime name is none... exiting"
2021-10-30 16:30:00 -07:00
return 1
fi
2021-11-01 12:53:10 -07:00
datetime=$(date +'%Y-%m-%d %H:%M:%S')
2021-10-29 22:49:52 -07:00
check_db "$@"
2021-11-25 10:52:59 -08:00
res="$?"
if [[ "$res" -gt 0 ]]; then
2021-10-29 22:49:52 -07:00
if [[ "$2" == "search" ]]; then
2021-11-18 15:52:37 -08:00
log "Already in search db... Updating search_date"
2021-10-29 22:49:52 -07:00
else
2021-11-18 15:52:37 -08:00
log "Already in search db... Updating watch_date"
2021-10-29 22:49:52 -07:00
fi
update_date "$@"
else
if [[ "$2" == "search" ]]; then
2021-11-01 12:53:10 -07:00
stmt="INSERT INTO search_history(anime_name, search_date) \
2021-11-01 15:21:58 -07:00
VALUES('$1', '$datetime');"
2021-11-01 17:05:43 -07:00
run_stmt "$stmt"
2021-10-29 22:49:52 -07:00
else
2021-10-30 11:27:37 -07:00
stmt="INSERT INTO \
watch_history(anime_name, episode_number, watch_date) \
2021-11-01 15:21:58 -07:00
VALUES('$1', '$2', '$datetime');"
2021-11-01 17:05:43 -07:00
run_stmt "$stmt"
2021-10-29 22:49:52 -07:00
fi
fi
}
2021-11-11 14:13:11 -08:00
sync_search_history() {
cnt=0
while read -r line; do
anime_name=$(awk -F '|' '{print $2}' <<<"$line")
2022-01-01 16:54:32 -08:00
res=$(sqlite3 -noheader "$HISTORY_DB" "SELECT COUNT(*) FROM search_history WHERE anime_name = '$anime_name'")
if [[ "$res" -eq 0 ]]; then
2021-11-11 14:13:11 -08:00
search_date=$(awk -F '|' '{print $3}' <<<"$line")
2021-11-21 21:43:48 -08:00
log "Adding ($anime_name|$search_date) to search history..."
2022-01-01 16:54:32 -08:00
if ! sqlite3 "$HISTORY_DB" "INSERT INTO search_history(anime_name, search_date) VALUES('$anime_name', '$search_date')"; then
2021-11-11 14:13:11 -08:00
err "Error inserting row $line"
fi
((++cnt))
fi
2022-01-01 16:54:32 -08:00
done <<<"$(sqlite3 -noheader "$temp_db" "SELECT DISTINCT * FROM search_history")"
2021-11-21 21:43:48 -08:00
log "Inserted $cnt rows into search_history table"
2021-11-11 14:13:11 -08:00
}
sync_watch_history() {
cnt=0
while read -r line; do
2021-11-18 15:52:37 -08:00
# anime_name=$(awk -F '|' '{print $2}' <<<"$line")
anime_name="${line/ //}"
log "ANIME: $anime_name"
2022-01-01 16:54:32 -08:00
episodes=$(sqlite3 -noheader "$temp_db" "SELECT episode_number, watch_date FROM watch_history WHERE anime_name = '$anime_name'")
2021-11-18 15:52:37 -08:00
# for each episode of $anime_name on the remote machine, check local
while read -r ep; do
2022-01-01 21:10:53 -08:00
# log "EP: $ep"
2021-11-18 15:52:37 -08:00
episode_num=$(awk -F '|' '{print $1}' <<<"$ep")
2022-01-01 21:10:53 -08:00
# log "EPISODE NUMBER: $episode_num"
check_db "$anime_name" "$episode_num"
2021-11-18 15:52:37 -08:00
num=$?
2022-01-01 21:10:53 -08:00
log "COUNT for $anime_name - episode $episode_num: $num"
2021-11-18 15:52:37 -08:00
if [[ "$num" -eq 0 ]]; then
2022-01-01 21:10:53 -08:00
log "$anime_name - E$episode_num NOT IN DB"
2021-11-18 15:52:37 -08:00
watch_date=$(awk -F '|' '{print $NF}' <<<"$ep")
log "Adding ($anime_name|$episode_num|$watch_date) to watch history..."
2022-01-01 16:54:32 -08:00
if ! sqlite3 "$HISTORY_DB" "INSERT INTO watch_history(anime_name, episode_number, watch_date) VALUES('$anime_name', '$episode_num', '$watch_date')"; then
2021-11-18 15:52:37 -08:00
err "Error inserting row $ep"
fi
((++cnt))
else
2022-01-01 21:10:53 -08:00
log "$anime_name - Episode: $episode_num found in the db... skipping"
2021-11-11 14:13:11 -08:00
fi
2021-11-18 15:52:37 -08:00
done <<<"${episodes[@]}"
2022-01-01 16:54:32 -08:00
done <<<"$(sqlite3 -noheader "$temp_db" "SELECT DISTINCT anime_name FROM watch_history")"
2021-11-18 15:52:37 -08:00
log "Inserted $cnt rows into watch_history table"
2021-11-11 14:13:11 -08:00
}
#####################
## END of db code ##
#####################
2021-06-13 04:34:16 -07:00
# get query
2021-10-29 22:49:52 -07:00
get_search_query() {
2021-11-01 00:23:51 -07:00
# Query the anime to stream/download
# Get search history
2021-11-04 18:37:16 -07:00
# Construct string "<id>. <anime_name>"
stmt="SELECT DISTINCT id || '. ' || anime_name \
2021-11-01 15:21:58 -07:00
FROM search_history \
2021-11-04 23:22:34 -07:00
ORDER BY id DESC;"
2021-11-01 17:05:43 -07:00
hist=$(run_stmt "$stmt")
2021-11-01 00:23:51 -07:00
2021-11-04 18:37:16 -07:00
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>"
2021-12-30 21:20:40 -08:00
if [ -z "$*" ] && [ "$is_rofi" -eq 1 ]; then
2022-01-01 16:54:32 -08:00
query=$(rofi -dmenu -l 12 -p "Search Anime:" \
2021-11-04 18:37:16 -07:00
-mesg "$span" \
2022-01-01 16:54:32 -08:00
-config "$CFG_DIR/${ROFI_CFG}" <<< "${hist[@]}")
2021-12-30 11:57:53 -08:00
# Remove the id from the query
2021-11-13 01:39:54 -08:00
query="${query//[1-9]*\. /}"
2021-12-30 20:06:26 -08:00
# fixes '-' at end of selected anime, but removes spaces from queries
# works with trailing '-' so remove for now
# query="${query// /}"
2021-11-18 15:52:37 -08:00
log "Query: $query"
2021-12-30 21:20:40 -08:00
elif [ "$is_rofi" -eq 0 ]; then
printf "Search Anime: "
read -r query
2021-06-18 03:18:16 -07:00
else
query=$*
fi
}
2021-06-14 02:22:02 -07:00
# create history file
2021-10-29 22:49:52 -07:00
[ -f "$logfile" ] || : >"$logfile"
2021-06-13 04:34:16 -07:00
#####################
## Anime selection ##
#####################
2021-06-09 05:25:23 -07:00
2021-10-29 22:49:52 -07:00
anime_selection() {
2021-11-01 00:23:51 -07:00
# Select anime from query results
2021-06-18 03:18:16 -07:00
search_results=$*
2021-12-30 21:20:40 -08:00
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"
2022-01-01 18:59:11 -08:00
if [ -z "$searched" ]; then
searched="$cnt"
2021-12-30 21:20:40 -08:00
else
2022-01-01 18:59:11 -08:00
searched="$searched, $cnt"
2021-12-30 21:20:40 -08:00
fi
fi
2022-01-01 18:59:11 -08:00
((++cnt))
2021-12-30 21:20:40 -08:00
done
log "SEARCHED: $searched"
# get the anime from indexed list
2022-01-01 18:59:11 -08:00
msg="<span foreground='peachpuff' style='italic' size='small' weight='normal'>Query: $query</span>"
2021-12-30 21:20:40 -08:00
user_input=$(printf "${menu[@]}" |
rofi -dmenu -config "$CFG_DIR/${ROFI_CFG}" \
-a "$searched" \
2022-01-01 19:19:15 -08:00
-l 12 -i -p "Enter selection:" \
2022-01-01 18:59:11 -08:00
-mesg "$msg")
2021-12-30 21:20:40 -08:00
[ -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
2022-01-01 16:54:32 -08:00
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"
2021-11-04 18:37:16 -07:00
fi
2021-06-09 05:25:23 -07:00
2021-12-30 21:20:40 -08:00
log "CHOICE: $choice"
2021-11-04 18:37:16 -07:00
2021-12-30 21:20:40 -08:00
if [ "$is_rofi" -eq 1 ]; then
log "NAME: $name"
# 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"
2021-11-04 18:37:16 -07:00
2021-06-18 03:18:16 -07:00
# Select respective anime_id
count=1
2021-11-25 10:52:59 -08:00
while read -r anime_id; do
if [ "$count" -eq "$choice" ]; then
2021-06-18 03:18:16 -07:00
selection_id=$anime_id
break
fi
2021-10-29 22:49:52 -07:00
count=$((count + 1))
2021-06-18 03:18:16 -07:00
done <<-EOF
2021-10-29 22:49:52 -07:00
$search_results
2021-06-18 03:18:16 -07:00
EOF
2021-12-30 21:20:40 -08:00
[ -z "$name" ] && name="$anime_id"
log "NAME: $name"
insert_history "$name" "search"
printf "$c_reset"
2021-06-18 03:18:16 -07:00
[ -z "$selection_id" ] && die "Invalid number entered"
2021-11-25 10:52:59 -08:00
read -r last_ep_number <<-EOF
2021-10-29 22:49:52 -07:00
$(search_eps "$selection_id")
2021-06-18 03:18:16 -07:00
EOF
}
2021-06-09 05:25:23 -07:00
##################
## Ep selection ##
##################
2021-06-13 04:34:16 -07:00
2021-10-29 22:49:52 -07:00
episode_selection() {
2021-12-30 21:20:40 -08:00
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
log "WATCH HISTORY: %s\n" "$watch_history"
# 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 "$CFG_DIR/${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
2021-11-04 18:37:16 -07:00
if [[ -z "$ep_choice_start" ]] && [[ -z "$ep_choice_end" ]]; then
die "No episode range entered"
fi
2021-11-01 17:05:43 -07:00
# 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
2021-11-01 19:48:19 -07:00
if [[ "$ep_choice_start" -eq "$ep_choice_end" ]]; then
ep_choice_end=""
fi
2021-11-01 17:05:43 -07:00
2021-10-29 22:49:52 -07:00
# read ep_choice_start ep_choice_end
2021-06-18 03:18:16 -07:00
printf "$c_reset"
2021-06-09 05:25:23 -07:00
2021-06-13 04:34:16 -07:00
}
2021-06-09 05:25:23 -07:00
2021-10-29 22:49:52 -07:00
open_episode() {
2021-06-13 04:34:16 -07:00
anime_id=$1
episode=$2
2021-11-08 00:41:30 -08:00
ddir="$3"
2021-06-09 05:25:23 -07:00
2021-11-04 18:37:16 -07:00
if [[ ! "$is_playlist" ]]; then
# clear the screen
printf '\x1B[2J\x1B[1;1H'
if [[ $episode -lt 1 ]] || [[ $episode -gt $last_ep_number ]]; then
err "Episode out of range"
stmt="SELECT DISTINCT episode_number \
FROM watch_history \
WHERE anime_name = '$anime_id' \
ORDER BY episode_number ASC;"
hist=$(run_stmt "$stmt")
2021-11-24 18:24:17 -08:00
log "HISTORY: ${hist[*]}"
2021-11-04 18:37:16 -07:00
episode=$(printf "%s\n" "${hist[@]}" |
rofi -dmenu -l 12 -p "Choose Episode:" \
-config "$CFG_DIR/${ROFI_CFG}")
printf "$c_reset"
2021-10-30 16:30:00 -07:00
fi
2021-06-09 05:25:23 -07:00
fi
2021-11-25 10:52:59 -08:00
log "Getting data for episode $episode"
2021-06-09 05:25:23 -07:00
2021-12-30 16:47:08 -08:00
# Don't update watch history if downloading episode
if [ "$is_download" -eq 0 ]; then
insert_history "$anime_id" "$episode"
fi
2021-10-29 22:49:52 -07:00
2021-12-30 11:08:50 -08:00
get_video_quality
status_code=$(curl -s -I get_video_quality "$play_link" | head -n 1|cut -d ' ' -f2)
log "Status code: $status_code"
2021-06-09 05:25:23 -07:00
2021-11-25 10:52:59 -08:00
if [ "$is_download" -eq 0 ]; then
2021-12-30 11:08:50 -08:00
if echo "$status_code" | grep -vE "^2.*"; then
printf "${c_red}\nCannot reach servers!"
else
setsid -f $player_fn get_video_quality "$play_link" > /dev/null 2>&1
printf "${c_green}\nVideo playing"
fi
2021-06-10 03:48:06 -07:00
else
2021-11-24 18:24:17 -08:00
log "Downloading episode $episode ..."
log "$video_url"
2021-06-18 03:18:16 -07:00
# add 0 padding to the episode name
2021-11-25 10:52:59 -08:00
episode=$(printf "%03d" "$episode")
2021-06-10 03:48:06 -07:00
{
2021-11-08 00:41:30 -08:00
cd "${ddir/ //}" || die "Could not enter directory $ddir"
mkdir -p "$anime_id" || die "Could not create directory"
cd "$anime_id" || die "Could not enter subdirectory $ddir/$anime_id"
2021-12-30 14:30:10 -08:00
# ffmpeg -i "$play_link" -c copy "${anime_id}-${episode}.mkv" >/dev/null 2>&1 &&
2021-12-30 21:58:02 -08:00
if command -v "notify-send" >/dev/null; then
ffmpeg -i "$play_link" -c copy "${episode}.mkv" >/dev/null 2>&1 &&
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
ffmpeg -i "$play_link" -c copy "${episode}.mkv" >/dev/null 2>&1 &&
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
2021-12-30 16:47:08 -08:00
# printf "${c_green}Downloaded episode: %s${c_reset}\n" "$episode" ||
# printf "${c_red}Download failed episode: %s , please retry or check your internet connection${c_reset}\n" "$episode"
2021-06-10 03:48:06 -07:00
}
fi
2021-06-13 04:34:16 -07:00
}
2021-06-18 03:18:16 -07:00
############
# Start Up #
############
2021-06-21 09:23:15 -07:00
# to clear the colors when exited using SIGINT
trap "printf '$c_reset'" INT HUP
2021-06-18 14:28:34 -07:00
2021-11-08 00:41:30 -08:00
dep_ch "$player_fn" "curl" "sed" "grep" "sqlite3" "rofi"
2021-06-18 03:18:16 -07:00
# option parsing
2021-12-30 21:20:40 -08:00
is_rofi=1
2021-06-18 03:18:16 -07:00
is_download=0
scrape=query
2021-10-30 16:30:00 -07:00
download_dir="."
2021-11-04 18:37:16 -07:00
is_playlist=0
playlist_remove=0
playlist_add=0
2021-12-16 00:21:58 -08:00
quality=best
2021-12-30 21:20:40 -08:00
while getopts 'hd:Hpa:P:svq:c' OPT; do
2021-11-11 14:13:11 -08:00
case "$OPT" in
2021-11-29 13:08:41 -08:00
h)
help_text
exit 0
;;
d)
is_download=1
download_dir="$OPTARG"
log "DOWNLOAD DIR: $download_dir"
;;
H)
scrape=history
;;
p)
scrape=playlist
is_playlist=1
;;
a)
is_add=1
scrape=add
playlist_file="${OPTARG/ //}"
;;
P)
is_playlist=1
# remove spaces from $OPTARG
playlist_file="${OPTARG/ //}"
[ -z "$playlist_file" ] && die "Enter in path to playlist"
log "$playlist_file"
$player_fn "$playlist_file"
exit 0
;;
s)
scrape=sync
;;
v)
VERBOSE=1
;;
2021-12-30 21:20:40 -08:00
q)
quality="$OPTARG"
log "passed in quality: $quality"
;;
c)
is_rofi=0
;;
2021-11-29 13:08:41 -08:00
*)
printf "%s\n" "Invalid option"
exit 1
;;
2021-06-18 03:18:16 -07:00
esac
done
shift $((OPTIND - 1))
########
# main #
########
case $scrape in
2021-11-29 13:08:41 -08:00
query)
get_search_query "$*"
2022-01-01 17:37:22 -08:00
searched=0
if [ $# -eq 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
2021-11-29 13:08:41 -08:00
episode_selection
;;
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"
2021-11-21 21:43:48 -08:00
2021-11-29 13:08:41 -08:00
stmt="SELECT episode_number \
2021-11-12 17:22:22 -08:00
FROM watch_history \
WHERE anime_name = '$selection_id' \
ORDER BY watch_date DESC \
LIMIT 1"
2021-11-29 13:08:41 -08:00
ep_choice_start=$(run_stmt "$stmt")
log "Most recently watched episode: $ep_choice_start"
;;
playlist)
lines=$(wc -l <"$playlist_file")
log "Num lines in playlist: " "$lines"
if [[ "$lines" -eq 0 ]]; then
2021-11-11 14:13:11 -08:00
get_search_query "$*"
search_results=$(search_anime "$query")
[ -z "$search_results" ] && die "No search results found"
2021-11-29 13:08:41 -08:00
if ! anime_selection "$search_results"; then
die "No anime selection found"
fi
2021-11-11 14:13:11 -08:00
episode_selection
2021-11-29 13:08:41 -08:00
else
line=($(sed '1q;d' "$playlist_file"))
if [[ "${#line[@]}" -ne 2 ]]; then
die "Something went wrong with the playlist file... exiting"
2021-11-11 14:36:04 -08:00
fi
2021-11-29 13:08:41 -08:00
selection_id="${line[0]}"
episodes=("$selection_id")
ep_choice_start="${line[1]}"
ep_choice_end=""
read -r last_ep_number <<-EOF
$(search_eps "$selection_id")
EOF
[ "$VERBOSE" -eq 1 ] && printf "Anime: %s Episode: %d\n" "$episodes" "$ep_choice_start"
[ "$VERBOSE" -eq 1 ] && printf "Episodes: %s\n" "${episodes[@]}"
fi
;;
add)
get_search_query "$*"
search_results=$(search_anime "$query")
[ -z "$search_results" ] && die "No search results found"
anime_selection "$search_results"
[ $? -ne 0 ] && die "No anime selection found"
episode_selection
;;
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
2021-11-11 14:36:04 -08:00
2021-11-29 13:08:41 -08:00
printf "%s" "Enter path to private key (leave blank if unsure or not needed): "
read -r key_path
2021-11-04 23:22:34 -07:00
2021-11-29 13:08:41 -08:00
printf "%s\n" "Syncing database with: $connection_str on port $PORT"
temp_db="/tmp/aniwrapper_tmp_history.sqlite3"
2021-11-11 14:36:04 -08:00
2021-11-29 13:08:41 -08:00
if [[ -z "$key_path" ]]; then
scp -P "$PORT" "$connection_str:$XDG_CONFIG_HOME/aniwrapper/history.sqlite3" "$temp_db"
else
scp -P "$PORT" -i "$key_path" "$connection_str:$XDG_CONFIG_HOME/aniwrapper/history.sqlite3" "$temp_db"
fi
if [[ "$?" -ne 0 ]]; then
die "Error getting database file from remote host"
fi
sync_search_history && sync_watch_history
exit 0
;;
2021-06-18 03:18:16 -07:00
esac
{ # checking input
[ "$ep_choice_start" -eq "$ep_choice_start" ] 2>/dev/null || die "Invalid number entered"
episodes=$ep_choice_start
if [ -n "$ep_choice_end" ]; then
[ "$ep_choice_end" -eq "$ep_choice_end" ] 2>/dev/null || die "Invalid number entered"
# create list of episodes to download/watch
2021-11-01 19:48:19 -07:00
episodes=$(seq $ep_choice_start $ep_choice_end)
2021-06-18 03:18:16 -07:00
fi
}
2021-11-24 18:24:17 -08:00
# plays selected episode(s)
2021-10-29 22:49:52 -07:00
for ep in $episodes; do
2021-11-04 18:37:16 -07:00
if [[ "$is_add" -eq 1 ]]; then
2021-11-24 18:24:17 -08:00
log "ID: $selection_id"
log "EPISODES: $episodes"
2021-11-04 23:22:34 -07:00
printf "%s\n" "$selection_id $ep" >>"$playlist_file"
2021-11-18 15:52:37 -08:00
log "Added to playlist file"
2021-11-04 18:37:16 -07:00
else
open_episode "$selection_id" "$ep" "$download_dir"
if [[ "$is_playlist" -eq 1 ]]; then
sed -i '1d' "$playlist_file"
fi
fi
2021-06-13 04:54:19 -07:00
done
2021-11-12 17:22:22 -08:00
if [[ "$is_add" -eq 1 ]]; then
2021-11-24 18:24:17 -08:00
log "Finished adding to playlist file... exiting"
2021-11-12 17:22:22 -08:00
exit 0
2021-12-30 16:47:08 -08:00
elif [[ "$is_download" -eq 1 ]]; then
log "Finished downloading episodes: $episodes for $selection_id... exiting"
exit 0
2021-11-12 17:22:22 -08:00
fi
2021-06-13 04:54:19 -07:00
episode=${ep_choice_end:-$ep_choice_start}
2021-06-13 04:34:16 -07:00
2021-10-29 22:49:52 -07:00
choice=''
2021-06-13 04:34:16 -07:00
while :; do
2021-06-13 04:54:19 -07:00
printf "\n${c_green}Currently playing %s episode ${c_cyan}%d/%d\n" "$selection_id" $episode $last_ep_number
2021-06-09 08:53:30 -07:00
printf "$c_blue[${c_cyan}%s$c_blue] $c_yellow%s$c_reset\n" "n" "next episode"
printf "$c_blue[${c_cyan}%s$c_blue] $c_magenta%s$c_reset\n" "p" "previous episode"
2021-06-20 23:00:06 -07:00
printf "$c_blue[${c_cyan}%s$c_blue] $c_yellow%s$c_reset\n" "s" "select episode"
2021-10-07 03:24:15 -07:00
printf "$c_blue[${c_cyan}%s$c_blue] $c_magenta%s$c_reset\n" "r" "replay current episode"
2021-06-09 08:53:30 -07:00
printf "$c_blue[${c_cyan}%s$c_blue] $c_red%s$c_reset\n" "q" "exit"
2021-06-09 14:49:28 -07:00
printf "${c_blue}Enter choice:${c_green} "
2021-10-29 22:49:52 -07:00
printf "$c_reset"
2021-11-25 10:52:59 -08:00
read -r choice
2021-10-29 22:49:52 -07:00
2021-06-09 08:53:30 -07:00
printf "$c_reset"
2021-06-09 05:25:23 -07:00
case $choice in
2021-11-29 13:08:41 -08:00
n)
episode=$((episode + 1))
;;
p)
episode=$((episode - 1))
;;
2021-11-01 17:41:00 -07:00
2021-11-29 13:08:41 -08:00
s)
printf "${c_blue}Choose episode $c_cyan[1-%d]$c_reset:$c_green " "$last_ep_number"
read -r episode
printf "$c_reset"
[ "$episode" -eq "$episode" ] 2>/dev/null || die "Invalid number entered"
;;
2021-11-09 00:54:55 -08:00
2021-11-29 13:08:41 -08:00
r) ;;
2021-11-09 00:54:55 -08:00
2021-11-29 13:08:41 -08:00
q)
break
;;
*)
die "invalid choice"
;;
2021-10-29 22:49:52 -07:00
esac
2021-10-30 16:30:00 -07:00
open_episode "$selection_id" "$episode" "$download_dir"
2021-06-09 05:25:23 -07:00
done