def get_comicrack_list(self):
query = ReadingList.select().where(
ReadingList.sw_syn_this_active == True) # noqa
self.my_tree.root_options = {
"text": "Synced ReadingLists",
"color": (0, 0, 0, 1),
"font_size": dp(18),
}
self.my_tree.bind(minimum_height=self.my_tree.setter("height"))
self.my_tree.bind(on_node_expand=self.node_expand)
self.my_tree.bind(on_node_collapse=self.node_collapse)
for item in query:
new_node = self.my_tree.add_node(
TreeViewItem(
text=item.name,
color=(
0.9568627450980393,
0.2627450980392157,
0.21176470588235294,
1,
),
))
new_node.rl_slug = item.slug
new_node.bind(on_touch_down=self.open_readinglist)
self.node_list.append(new_node)
self.lists_loaded = False
def open_readinglist(self, instance, node):
def __wait_for_open(dt):
if server_readinglists_screen.loading_done is True:
self.app.manager.current = "server_readinglists_screen"
self.loading_event.cancel()
server_readinglists_screen = self.app.manager.get_screen(
"server_readinglists_screen")
server_readinglists_screen.setup_screen()
server_readinglists_screen.page_number = 1
readinglist_Id = instance.id
readinglist_name = (instance.text).split(" : ")[0]
server_readinglists_screen.list_loaded = False
query = ReadingList.select().where(ReadingList.slug == readinglist_Id)
if query.exists():
Logger.info(f"{readinglist_name} already in Database")
set_mode = "From DataBase"
else:
Logger.info("{} not in Database getting info from server".format(
readinglist_name))
set_mode = "From Server"
# set_mode = 'From Server'
server_readinglists_screen.loading_done = False
Clock.schedule_once(
lambda dt: server_readinglists_screen.collect_readinglist_data(
readinglist_name=readinglist_name,
readinglist_Id=readinglist_Id,
mode=set_mode,
))
self.app.manager.current = "server_readinglists_screen"
def save_settings(self, *args, **kwargs):
try:
rl = ReadingList.get(ReadingList.slug == self.slug)
for key in READINGLIST_SETTINGS_KEYS:
setattr(rl, key, kwargs[key])
setattr(self, key, kwargs[key])
rl.save()
except peewee.OperationalError:
pass
def get_or_create_db_item(self, mode):
tmp_defaults = {}
try:
for key in READINGLIST_DB_KEYS:
if key == "data":
new_dict = {k: self.data[k] for k in self.data.keys()}
tmp_defaults["data"] = new_dict
else:
tmp_defaults[key] = getattr(self, key)
db_item, created = ReadingList.get_or_create(
slug=self.slug, defaults=tmp_defaults
)
self.db = db_item
if db_item:
for key in READINGLIST_DB_KEYS:
setattr(self, key, getattr(db_item, key))
if created is True:
len_dbcomics = len(db_item.comics)
if (
len_dbcomics == len(self.comic_json)
and len(self.comic_json) != 0
):
self.comic_db_in = True
self.comics = self.db.comics.order_by(
-Comic.comic_index.index
)
else:
self.comic_db_in = True
comicindex_db = ComicIndex.get(
ComicIndex.readinglist == self.slug
)
if mode == "local_file":
list_comics = self.db.comics.where(
Comic.is_sync == True, Comic.local_file != ""
).order_by( # noqa
comicindex_db.index
)
print(f"len:{len(list_comics)}")
else:
list_comics = self.db.comics.order_by(
comicindex_db.index
)
for comic in list_comics:
new_comic = ComicBook(
comic_Id=comic.Id,
readlist_obj=self,
mode="db_data",
)
self.comics.append(new_comic)
self.comics_loaded = True
except peewee.OperationalError:
Logger.critical(
"Somthing happened in get_or_create of readinglist"
)
def open_readinglist(self, instance, node):
self.app.manager.current = "local_readinglists_screen"
local_readinglists_screen = self.app.manager.get_screen(
"local_readinglists_screen")
local_readinglists_screen.setup_screen()
local_readinglists_screen.page_number = 1
readinglist_Id = instance.rl_slug
readinglist_name = (instance.text).split(" : ")[0]
local_readinglists_screen.list_loaded = False
query = ReadingList.select().where(ReadingList.slug == readinglist_Id)
if query.exists():
Logger.info(f"{readinglist_name} already in Database")
set_mode = "From DataBase"
else:
Logger.info(
f"{readinglist_name} not in Database getting info from server")
set_mode = "From Server"
# set_mode = 'From Server'
local_readinglists_screen.collect_readinglist_data(readinglist_name,
readinglist_Id,
mode=set_mode)
def got_file(self, comic_obj, comic_file="", *args, **kwargs):
def file_finished_toast(dt):
toast(f"{os.path.basename(comic_file)} Synced")
self.num_file_done += 1
Clock.schedule_once(file_finished_toast)
self.file_download = True
db_comic = Comic.get(Comic.Id == comic_obj.Id)
db_comic.is_sync = True
db_comic.save()
db_comic = Comic.get(Comic.Id == comic_obj.Id)
db_comic.local_file = comic_file
db_comic.been_sync = True
db_comic.save()
rl_db = ReadingList.get(ReadingList.slug == self.slug)
rl_db.end_last_sync_num += 1
rl_db.save()
app = App.get_running_app()
server_readinglists_screen = app.manager.get_screen(
"server_readinglists_screen"
)
server_readinglists_screen.file_sync_update(comic_obj.Id, True)
def do_sync(self):
def _syncrun_callback(*args):
pass
app = App.get_running_app()
if app.sync_is_running is True:
self.please_wait_dialog = MDDialog(
title="Sync Already in Progress",
size_hint=(0.8, 0.4),
text_button_ok="Ok",
text=f"Please wait till current Sync is done",
events_callback=_syncrun_callback,
)
self.please_wait_dialog.open()
return
self.num_file_done = 0
sync_range = 0
self.fetch_data = ComicServerConn()
rl_db = ReadingList.get(ReadingList.slug == self.slug)
end_last_sync_num = rl_db.end_last_sync_num
if end_last_sync_num != 0:
end_last_sync_num = end_last_sync_num - 1
comicindex_db = ComicIndex.get(ComicIndex.readinglist == self.slug)
last_read_comic_db = self.db.comics.where(
(Comic.UserLastPageRead == Comic.PageCount - 1)
& (Comic.PageCount > 1)
).order_by(comicindex_db.index)
if len(last_read_comic_db) > 1:
last_read_index = ComicIndex.get(
ComicIndex.comic == last_read_comic_db[-1].Id,
ComicIndex.readinglist == self.slug,
).index
elif len(last_read_comic_db) != 0:
last_read_index = ComicIndex.get(
ComicIndex.comic == last_read_comic_db[0].Id,
ComicIndex.readinglist == self.slug,
).index
else:
last_read_index = 0
if self.cb_limit_active:
if self.cb_only_read_active:
list_comics = self.db.comics.where(
~(Comic.UserLastPageRead == Comic.PageCount - 1)
& (Comic.PageCount > 1)
& (Comic.been_sync)
!= True
).order_by(
comicindex_db.index
) # noqa: E712
if last_read_index < end_last_sync_num:
sync_range = int(self.limit_num)
tmp_comic_list = list_comics[0:int(sync_range)]
else:
sync_range = int(end_last_sync_num) + int(self.limit_num)
tmp_comic_list = list_comics[end_last_sync_num:int(sync_range)]
purge_list = self.db.comics.where(
(Comic.UserLastPageRead == Comic.PageCount - 1)
& (Comic.PageCount > 1)
& (Comic.is_sync == True)
).order_by(
comicindex_db.index
) # noqa: E712
else:
list_comics = (
Comic.select()
.where(
(Comic.is_sync == False) & (Comic.been_sync == False)
)
.order_by(comicindex_db.index)
) # noqa: E712,E501
sync_range = int(self.limit_num)
tmp_comic_list = list_comics[0:int(sync_range)]
purge_list = self.db.comics.where(
Comic.is_sync == True
).order_by(
comicindex_db.index
) # noqa: E712
else:
sync_range = int(len(self.comics))
# rl_db.end_last_sync_num = new_end_last_sync_num
# rl_db.save()
if self.cb_only_read_active:
list_comics = self.db.comics.where(
~(Comic.UserLastPageRead == Comic.PageCount - 1)
& (Comic.PageCount > 1)
).order_by(
comicindex_db.index
) # noqa: E712
tmp_comic_list = list_comics[0:int(sync_range)]
else:
list_comics = self.db.comics.where(
(Comic.is_sync == False) & (Comic.been_sync == False)
).order_by(
comicindex_db.index
) # noqa: E712,E501
tmp_comic_list = list_comics
db_item = ReadingList.get(ReadingList.slug == self.slug)
for key in READINGLIST_SETTINGS_KEYS:
v = getattr(db_item, key)
globals()["%s" % key] = v
app = App.get_running_app()
id_folder = os.path.join(app.sync_folder, self.slug)
my_comic_dir = Path(os.path.join(id_folder, "comics"))
if os.path.isdir(my_comic_dir):
print(f"{get_size(my_comic_dir)/1000000} MB")
sync_comic_list = []
for comic in tmp_comic_list:
if comic.is_sync is False:
sync_comic_list.append(comic)
if self.cb_purge_active:
for item in purge_list:
os.remove(item.local_file)
db_comic = Comic.get(Comic.Id == item.Id)
db_comic.is_sync = False
db_comic.local_file = ""
db_comic.save()
server_readinglists_screen = app.manager.get_screen(
"server_readinglists_screen"
)
server_readinglists_screen.file_sync_update(item.Id, False)
self.sync_readinglist(comic_list=sync_comic_list)
def __got_readlist_data(results):
async def __load_readinglist_scree(paginator_obj=None):
if tmp_last_comic_type == "local_file":
x_readinglists_screen = self.app.manager.get_screen(
"local_readinglists_screen"
)
else:
x_readinglists_screen = self.app.manager.get_screen(
"server_readinglists_screen"
)
x_readinglists_screen.list_loaded = False
x_readinglists_screen.setup_screen()
x_readinglists_screen.page_number = tmp_last_pag_pagnum
x_readinglists_screen.loading_done = False
self.call_collect(
set_mode,
x_readinglists_screen,
readinglist_name,
readinglist_Id,
)
tmp_last_comic_id = self.app.config.get("Saved", "last_comic_id")
tmp_last_comic_type = self.app.config.get(
"Saved", "last_comic_type"
)
tmp_last_pag_pagnum = int(
self.app.config.get("Saved", "last_pag_pagnum")
)
if tmp_last_comic_id == "":
return
else:
query = ReadingList.select().where(
ReadingList.slug == readinglist_Id
)
if query.exists():
Logger.info(f"{readinglist_name} already in Database")
set_mode = "From DataBase"
mode = ""
if tmp_last_comic_type == "local_file":
mode = "local_file"
self.new_readinglist = ComicReadingList(
name=self.readinglist_name,
data="db_data",
slug=self.readinglist_Id,
mode=mode,
)
# self.new_readinglist.comics_write()
max_books_page = int(
self.app.config.get("General", "max_books_page")
)
new_readinglist_reversed = self.new_readinglist.comics
paginator_obj = Paginator(
new_readinglist_reversed, max_books_page
)
for x in range(1, paginator_obj.num_pages()):
this_page = paginator_obj.page(x)
for comic in this_page.object_list:
if tmp_last_comic_id == comic.Id:
tmp_last_pag_pagnum = this_page.number
asynckivy.start(
__load_readinglist_scree(paginator_obj=paginator_obj)
)
if (
self.open_last_comic_startup == 1
and not self.app.app_started
):
for comic in self.new_readinglist.comics:
if comic.slug == tmp_last_comic_id:
self.open_comic(
tmp_last_comic_id=tmp_last_comic_id,
tmp_last_comic_type=tmp_last_comic_type,
paginator_obj=paginator_obj,
comic=comic,
tmp_last_pag_pagnum=tmp_last_pag_pagnum,
)
else:
grid = self.ids["main_grid"]
grid.cols = 1
grid.clear_widgets()
for comic in self.new_readinglist.comics:
if comic.slug == tmp_last_comic_id:
c = ReadingListComicImage(comic_obj=comic)
c.readinglist_obj = self.new_readinglist
c.paginator_obj = paginator_obj
x = self.app.comic_thumb_width
y = self.app.comic_thumb_height
if tmp_last_comic_type == "local_file":
if comic.local_file == "":
return
import os
id_folder = os.path.join(
self.app.sync_folder,
self.new_readinglist.slug,
)
my_thumb_dir = os.path.join(
id_folder, "thumb"
)
thumb_name = f"{comic.Id}.jpg"
t_file = os.path.join(
my_thumb_dir, thumb_name
)
c_image_source = t_file
else:
round_y = round(dp(y))
part_url = f"/Comics/{comic.Id}/Pages/0?"
part_api = "&apiKey={}&height={}".format(
self.api_key, round_y
)
c_image_source = "{}{}{}".format(
self.app.api_url, part_url, part_api
)
c.source = c_image_source
c.PageCount = comic.PageCount
c.pag_pagenum = tmp_last_pag_pagnum
if tmp_last_comic_type == "local_file":
c.view_mode = "Sync"
strtxt = f"{comic.Series} #{comic.Number}"
tmp_color = get_hex_from_color((1, 1, 1, 1))
c.text = f"[color={tmp_color}]{strtxt}[/color]"
grid.add_widget(c)
tmp_txt = f"Last Comic Load from \
{self.new_readinglist.name}"
self.ids.last_comic_label.text = tmp_txt
else:
Logger.info(
f"{readinglist_name} \
not in Database This could be a problems"
)
set_mode = "From Server"