mirror of
https://github.com/hkalexling/Mango.git
synced 2025-08-02 02:45:29 -04:00
482 lines
12 KiB
Crystal
482 lines
12 KiB
Crystal
require "image_size"
|
|
require "yaml"
|
|
|
|
abstract class Entry
|
|
getter id : String, book : Title, title : String,
|
|
size : String, pages : Int32, mtime : Time,
|
|
encoded_path : String, encoded_title : String, err_msg : String?
|
|
|
|
def initialize(
|
|
@id, @title, @book,
|
|
@size, @pages, @mtime,
|
|
@encoded_path, @encoded_title, @err_msg)
|
|
end
|
|
|
|
def self.new(ctx : YAML::ParseContext, node : YAML::Nodes::Node)
|
|
# TODO: check node? and select proper subclass
|
|
ZippedEntry.new ctx, node
|
|
end
|
|
|
|
def build_json(*, slim = false)
|
|
JSON.build do |json|
|
|
json.object do
|
|
{% for str in %w(path title size id) %}
|
|
json.field {{str}}, {{str.id}}
|
|
{% end %}
|
|
if err_msg
|
|
json.field "err_msg", err_msg
|
|
end
|
|
json.field "title_id", @book.id
|
|
json.field "title_title", @book.title
|
|
json.field "sort_title", sort_title
|
|
json.field "pages" { json.number @pages }
|
|
unless slim
|
|
json.field "display_name", @book.display_name @title
|
|
json.field "cover_url", cover_url
|
|
json.field "mtime" { json.number @mtime.to_unix }
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
@[YAML::Field(ignore: true)]
|
|
@sort_title : String?
|
|
|
|
def sort_title
|
|
sort_title_cached = @sort_title
|
|
return sort_title_cached if sort_title_cached
|
|
sort_title = @book.entry_sort_title_db id
|
|
if sort_title
|
|
@sort_title = sort_title
|
|
return sort_title
|
|
end
|
|
@sort_title = @title
|
|
@title
|
|
end
|
|
|
|
def set_sort_title(sort_title : String | Nil, username : String)
|
|
Storage.default.set_entry_sort_title id, sort_title
|
|
if sort_title == "" || sort_title.nil?
|
|
@sort_title = nil
|
|
else
|
|
@sort_title = sort_title
|
|
end
|
|
|
|
@book.entry_sort_title_cache = nil
|
|
@book.remove_sorted_entries_cache [SortMethod::Auto, SortMethod::Title],
|
|
username
|
|
end
|
|
|
|
def sort_title_db
|
|
@book.entry_sort_title_db @id
|
|
end
|
|
|
|
def display_name
|
|
@book.display_name @title
|
|
end
|
|
|
|
def encoded_display_name
|
|
URI.encode display_name
|
|
end
|
|
|
|
def cover_url
|
|
return "#{Config.current.base_url}img/icons/icon_x192.png" if @err_msg
|
|
|
|
unless @book.entry_cover_url_cache
|
|
TitleInfo.new @book.dir do |info|
|
|
@book.entry_cover_url_cache = info.entry_cover_url
|
|
end
|
|
end
|
|
entry_cover_url = @book.entry_cover_url_cache
|
|
|
|
url = "#{Config.current.base_url}api/cover/#{@book.id}/#{@id}"
|
|
if entry_cover_url
|
|
info_url = entry_cover_url[@title]?
|
|
unless info_url.nil? || info_url.empty?
|
|
url = File.join Config.current.base_url, info_url
|
|
end
|
|
end
|
|
url
|
|
end
|
|
|
|
def next_entry(username)
|
|
entries = @book.sorted_entries username
|
|
idx = entries.index self
|
|
return nil if idx.nil? || idx == entries.size - 1
|
|
entries[idx + 1]
|
|
end
|
|
|
|
def previous_entry(username)
|
|
entries = @book.sorted_entries username
|
|
idx = entries.index self
|
|
return nil if idx.nil? || idx == 0
|
|
entries[idx - 1]
|
|
end
|
|
|
|
# For backward backward compatibility with v0.1.0, we save entry titles
|
|
# instead of IDs in info.json
|
|
def save_progress(username, page)
|
|
LRUCache.invalidate "#{@book.id}:#{username}:progress_sum"
|
|
@book.parents.each do |parent|
|
|
LRUCache.invalidate "#{parent.id}:#{username}:progress_sum"
|
|
end
|
|
@book.remove_sorted_caches [SortMethod::Progress], username
|
|
|
|
TitleInfo.new @book.dir do |info|
|
|
if info.progress[username]?.nil?
|
|
info.progress[username] = {@title => page}
|
|
else
|
|
info.progress[username][@title] = page
|
|
end
|
|
# save last_read timestamp
|
|
if info.last_read[username]?.nil?
|
|
info.last_read[username] = {@title => Time.utc}
|
|
else
|
|
info.last_read[username][@title] = Time.utc
|
|
end
|
|
info.save
|
|
end
|
|
end
|
|
|
|
def load_progress(username)
|
|
progress = 0
|
|
TitleInfo.new @book.dir do |info|
|
|
unless info.progress[username]?.nil? ||
|
|
info.progress[username][@title]?.nil?
|
|
progress = info.progress[username][@title]
|
|
end
|
|
end
|
|
[progress, @pages].min
|
|
end
|
|
|
|
def load_percentage(username)
|
|
page = load_progress username
|
|
page / @pages
|
|
end
|
|
|
|
def load_last_read(username)
|
|
last_read = nil
|
|
TitleInfo.new @book.dir do |info|
|
|
unless info.last_read[username]?.nil? ||
|
|
info.last_read[username][@title]?.nil?
|
|
last_read = info.last_read[username][@title]
|
|
end
|
|
end
|
|
last_read
|
|
end
|
|
|
|
def finished?(username)
|
|
load_progress(username) == @pages
|
|
end
|
|
|
|
def started?(username)
|
|
load_progress(username) > 0
|
|
end
|
|
|
|
def generate_thumbnail : Image?
|
|
return if @err_msg
|
|
|
|
img = read_page(1).not_nil!
|
|
begin
|
|
size = ImageSize.get img.data
|
|
if size.height > size.width
|
|
thumbnail = ImageSize.resize img.data, width: 200
|
|
else
|
|
thumbnail = ImageSize.resize img.data, height: 300
|
|
end
|
|
img.data = thumbnail
|
|
img.size = thumbnail.size
|
|
unless img.mime == "image/webp"
|
|
# image_size.cr resizes non-webp images to jpg
|
|
img.mime = "image/jpeg"
|
|
end
|
|
Storage.default.save_thumbnail @id, img
|
|
rescue e
|
|
Logger.warn "Failed to generate thumbnail for file #{path}. #{e}"
|
|
end
|
|
|
|
img
|
|
end
|
|
|
|
def get_thumbnail : Image?
|
|
Storage.default.get_thumbnail @id
|
|
end
|
|
|
|
def date_added : Time
|
|
date_added = nil
|
|
TitleInfo.new @book.dir do |info|
|
|
info_da = info.date_added[@title]?
|
|
if info_da.nil?
|
|
date_added = info.date_added[@title] = createtime
|
|
info.save
|
|
else
|
|
date_added = info_da
|
|
end
|
|
end
|
|
date_added.not_nil! # is it ok to set not_nil! here?
|
|
end
|
|
|
|
abstract def path : String
|
|
|
|
abstract def createtime : Time
|
|
|
|
abstract def read_page(page_num)
|
|
|
|
abstract def page_dimensions
|
|
|
|
abstract def exists? : Bool?
|
|
end
|
|
|
|
class ZippedEntry < Entry
|
|
include YAML::Serializable
|
|
|
|
getter zip_path : String
|
|
|
|
def initialize(@zip_path, @book)
|
|
storage = Storage.default
|
|
@encoded_path = URI.encode @zip_path
|
|
@title = File.basename @zip_path, File.extname @zip_path
|
|
@encoded_title = URI.encode @title
|
|
@size = (File.size @zip_path).humanize_bytes
|
|
id = storage.get_entry_id @zip_path, File.signature(@zip_path)
|
|
if id.nil?
|
|
id = random_str
|
|
storage.insert_entry_id({
|
|
path: @zip_path,
|
|
id: id,
|
|
signature: File.signature(@zip_path).to_s,
|
|
})
|
|
end
|
|
@id = id
|
|
@mtime = File.info(@zip_path).modification_time
|
|
|
|
unless File.readable? @zip_path
|
|
@err_msg = "File #{@zip_path} is not readable."
|
|
Logger.warn "#{@err_msg} Please make sure the " \
|
|
"file permission is configured correctly."
|
|
return
|
|
end
|
|
|
|
archive_exception = validate_archive @zip_path
|
|
unless archive_exception.nil?
|
|
@err_msg = "Archive error: #{archive_exception}"
|
|
Logger.warn "Unable to extract archive #{@zip_path}. " \
|
|
"Ignoring it. #{@err_msg}"
|
|
return
|
|
end
|
|
|
|
file = ArchiveFile.new @zip_path
|
|
@pages = file.entries.count do |e|
|
|
SUPPORTED_IMG_TYPES.includes? \
|
|
MIME.from_filename? e.filename
|
|
end
|
|
file.close
|
|
end
|
|
|
|
def path : String
|
|
@zip_path
|
|
end
|
|
|
|
def createtime : Time
|
|
ctime @zip_path
|
|
end
|
|
|
|
private def sorted_archive_entries
|
|
ArchiveFile.open @zip_path do |file|
|
|
entries = file.entries
|
|
.select { |e|
|
|
SUPPORTED_IMG_TYPES.includes? \
|
|
MIME.from_filename? e.filename
|
|
}
|
|
.sort! { |a, b|
|
|
compare_numerically a.filename, b.filename
|
|
}
|
|
yield file, entries
|
|
end
|
|
end
|
|
|
|
def read_page(page_num)
|
|
raise "Unreadble archive. #{@err_msg}" if @err_msg
|
|
img = nil
|
|
begin
|
|
sorted_archive_entries do |file, entries|
|
|
page = entries[page_num - 1]
|
|
data = file.read_entry page
|
|
if data
|
|
img = Image.new data, MIME.from_filename(page.filename),
|
|
page.filename, data.size
|
|
end
|
|
end
|
|
rescue e
|
|
Logger.warn "Unable to read page #{page_num} of #{@zip_path}. Error: #{e}"
|
|
end
|
|
img
|
|
end
|
|
|
|
def page_dimensions
|
|
sizes = [] of Hash(String, Int32)
|
|
sorted_archive_entries do |file, entries|
|
|
entries.each_with_index do |e, i|
|
|
begin
|
|
data = file.read_entry(e).not_nil!
|
|
size = ImageSize.get data
|
|
sizes << {
|
|
"width" => size.width,
|
|
"height" => size.height,
|
|
}
|
|
rescue e
|
|
Logger.warn "Failed to read page #{i} of entry #{zip_path}. #{e}"
|
|
sizes << {"width" => 1000_i32, "height" => 1000_i32}
|
|
end
|
|
end
|
|
end
|
|
sizes
|
|
end
|
|
|
|
def exists? : Bool
|
|
File.exists? @zip_path
|
|
end
|
|
end
|
|
|
|
class DirectoryEntry < Entry
|
|
include YAML::Serializable
|
|
|
|
getter dir_path : String
|
|
|
|
@[YAML::Field(ignore: true)]
|
|
@sorted_files : Array(String)?
|
|
|
|
@signature : String
|
|
|
|
def initialize(@dir_path, @book)
|
|
storage = Storage.default
|
|
@encoded_path = URI.encode @dir_path
|
|
@title = File.basename @dir_path
|
|
@encoded_title = URI.encode @title
|
|
|
|
unless File.readable? @dir_path
|
|
@err_msg = "Directory #{@dir_path} is not readable."
|
|
Logger.warn "#{@err_msg} Please make sure the " \
|
|
"file permission is configured correctly."
|
|
return
|
|
end
|
|
|
|
unless DirectoryEntry.validate_directory_entry @dir_path
|
|
@err_msg = "Directory #{@dir_path} is not valid directory entry."
|
|
Logger.warn "#{@err_msg} Please make sure the " \
|
|
"directory has valid images."
|
|
return
|
|
end
|
|
|
|
size_sum = 0
|
|
sorted_files.each do |file_path|
|
|
size_sum += File.size file_path
|
|
end
|
|
@size = size_sum.humanize_bytes
|
|
|
|
@signature = Dir.directory_entry_signature @dir_path
|
|
id = storage.get_entry_id @dir_path, @signature
|
|
if id.nil?
|
|
id = random_str
|
|
storage.insert_entry_id({
|
|
path: @dir_path,
|
|
id: id,
|
|
signature: @signature,
|
|
})
|
|
end
|
|
@id = id
|
|
|
|
mtimes = sorted_files.map { |file_path| File.info(file_path).modification_time }
|
|
@mtime = mtimes.max
|
|
|
|
@pages = sorted_files.size
|
|
end
|
|
|
|
def path : String
|
|
@dir_path
|
|
end
|
|
|
|
def createtime : Time
|
|
ctime @dir_path
|
|
end
|
|
|
|
def read_page(page_num)
|
|
img = nil
|
|
begin
|
|
files = sorted_files
|
|
file_path = files[page_num - 1]
|
|
data = File.read(file_path).to_slice
|
|
if data
|
|
img = Image.new data, MIME.from_filename(file_path),
|
|
File.basename(file_path), data.size
|
|
end
|
|
rescue e
|
|
Logger.warn "Unable to read page #{page_num} of #{@dir_path}. Error: #{e}"
|
|
end
|
|
img
|
|
end
|
|
|
|
def page_dimensions
|
|
sizes = [] of Hash(String, Int32)
|
|
sorted_files.each_with_index do |path, i|
|
|
data = File.read(path).to_slice
|
|
begin
|
|
data.not_nil!
|
|
size = ImageSize.get data
|
|
sizes << {
|
|
"width" => size.width,
|
|
"height" => size.height,
|
|
}
|
|
rescue e
|
|
Logger.warn "Failed to read page #{i} of entry #{@dir_path}. #{e}"
|
|
sizes << {"width" => 1000_i32, "height" => 1000_i32}
|
|
end
|
|
end
|
|
sizes
|
|
end
|
|
|
|
def exists? : Bool
|
|
existence = File.exists? @dir_path
|
|
return false unless existence
|
|
files = DirectoryEntry.get_valid_files @dir_path
|
|
signature = Dir.directory_entry_signature @dir_path
|
|
existence = files.size > 0 && @signature == signature
|
|
@sorted_files = nil unless existence
|
|
|
|
# For more efficient,
|
|
# Fix a directory instance with new property
|
|
# and return true
|
|
existence
|
|
end
|
|
|
|
def sorted_files
|
|
cached_sorted_files = @sorted_files
|
|
return cached_sorted_files if cached_sorted_files
|
|
@sorted_files = DirectoryEntry.get_valid_files_sorted @dir_path
|
|
@sorted_files.not_nil!
|
|
end
|
|
|
|
def self.validate_directory_entry(dir_path)
|
|
files = DirectoryEntry.get_valid_files dir_path
|
|
files.size > 0
|
|
end
|
|
|
|
def self.get_valid_files(dir_path)
|
|
files = [] of String
|
|
Dir.entries(dir_path).each do |fn|
|
|
next if fn.starts_with? "."
|
|
path = File.join dir_path, fn
|
|
next unless is_supported_image_file path
|
|
next if File.directory? path
|
|
next unless File.readable? path
|
|
files << path
|
|
end
|
|
files
|
|
end
|
|
|
|
def self.get_valid_files_sorted(dir_path)
|
|
files = DirectoryEntry.get_valid_files dir_path
|
|
files.sort! { |a, b| compare_numerically a, b }
|
|
end
|
|
end
|