def GET(self, disc_id: int, **kwargs): # pylint: disable=invalid-name,no-self-use
"""GET Function"""
try:
info = RipperVideoInfo.get_by_id(disc_id)
except DoesNotExist:
return self._return_data(
"Ripper",
f"Search For Disc Data - {disc_id}",
False,
error="Disc ID not in DB",
errorNumber=0,
)
info: RipperVideoInfo = RipperVideoInfo.get_by_id(disc_id)
if info.rip_data and info.rip_data != {}:
return self._return_data(
"Ripper",
f"Search For Disc Data - {disc_id}",
False,
error="Disc Rip data already Exists",
errorNumber=1,
)
data = DiscAPI.find_disctype(info.uuid, info.label)
if data:
info.rip_data = data.make_dict()
info.rip_data_downloaded = 1
info.rip_data_locked = 1
info.save()
return self._return_data("Ripper",
f"Lock Disc - {disc_id}",
True,
found=bool(data))
def POST(self, disc_id: int, **kwargs): # pylint: disable=invalid-name,no-self-use
"""POST Function"""
try:
info = RipperVideoInfo.get_by_id(disc_id)
except DoesNotExist:
return self._return_data(
"Ripper",
f"Lock Disc - {disc_id}",
False,
error="Disc ID not in DB",
errorNumber=0,
lockable=False,
)
info: RipperVideoInfo = RipperVideoInfo.get_by_id(disc_id)
if not info.rip_data or info.rip_data == {}:
return self._return_data(
"Ripper",
f"Lock Disc - {disc_id}",
False,
error="Disc Rip data not Complete",
errorNumber=1,
lockable=False,
)
info.rip_data_locked = 1
info.save()
return self._return_data("Ripper",
f"Lock Disc - {disc_id}",
True,
lockable=True)
def __run(self):
""" Loops through the standard ripper function"""
with self._pool_sema:
self.__active = True
self._get_udfInfo(
File.location(self.__filename,
CONFIG["webui"]["uploadlocation"].value))
if self.__thread_run is False:
return
if self._disc["type"] == "audiocd":
return
# self._ripper = AudioCDLinux(self.get_device(), self._thread.getName(),
# self._set_drive_status, self._thread_run)
else:
self._add_video_disc_to_database(self.__filename)
self._ripper = MakeMKV()
if self.__thread_run is False:
return
self._ripper.call(self._db_id)
self._ripper = None
if self._disc["type"] == "audiocd":
pass
else:
RipperVideoInfo.do_update({
"iso_file": ""
}).where(RipperVideoInfo.id == self._db_id).execute()
File.rm(
File.location(self.__filename,
CONFIG["webui"]["uploadlocation"].value))
def start(cls):
"""Starts the ripper"""
if cls.running or cls.enabled is False:
return
# Create folders
for location in CONFIG["ripper"]["locations"]:
File.mkdir(location.value)
# Check/Create Database Tables
RipperAudioInfo.table_setup()
RipperVideoConvertInfo.table_setup()
RipperVideoInfo.table_setup()
cls.__running = True
cls.__event_system = Thread(target=cls.__event_system_run, args=())
cls.__event_system.start()
cls.__setup_makemkv()
if CONFIG["ripper"]["drives"]["enabled"].value:
cls.__start_drives()
if CONFIG["ripper"]["iso"]["enabled"].value:
cls.__start_isos()
if CONFIG["ripper"]["converter"]["enabled"].value:
cls.__start_converters()
def discs(self) -> dict:
"""Disc list Page"""
data = []
for item in RipperVideoInfo.do_select():
data.append({
"id":
item.id,
"name":
item.rip_data.get("name", item.label),
"disc_type":
item.disc_type.upper(),
"type":
item.rip_data.get("type", ""),
"rip_data":
bool(item.rip_data),
"locked":
bool(item.rip_data_locked),
"downloaded":
bool(item.rip_data_downloaded),
"track_count":
len(item.disc_data.get("track_info", [])),
})
return {"data": data}
def disc(self, db_id: int) -> dict:
"""Disc Edit Page"""
info = RipperVideoInfo.get_or_none(RipperVideoInfo.id == db_id)
if info is None:
raise cherrypy.HTTPError(status=404)
disc_data = lower_keys(info.disc_data)
return_dict = {
"db_id": db_id,
"disc_name": disc_data["disc_info"]["name"],
"disc_language": disc_data["disc_info"]["metadatalanguagename"],
"iso_file": info.iso_file,
"uuid": info.uuid.upper(),
"label": info.label,
"disc_type": info.disc_type.upper(),
"disc_data": disc_data,
"rip_data_locked": bool(info.rip_data_locked),
"data_disc_types_and_icons": DiscType.TYPESANDICONS,
}
if not info.rip_data or info.rip_data == {}:
return return_dict
rip_data = make_disc_type(info.rip_data)
return_dict["disc_items"] = rip_data.html_create_data(
bool(info.rip_data_locked))
return_dict["rip_data"] = rip_data.html_show_data(
bool(info.rip_data_locked))
return return_dict
def call(self, db_id: int) -> List[int]:
"""run the makemkv backup function MUST HAVE DATA IN THE DB"""
ids = []
info = RipperVideoInfo.do_select().where(RipperVideoInfo.id == db_id)
if info is None:
return ids
if info.iso_file:
self._in_file = File.location(
info.iso_file,
CONFIG["ripper"]["locations"]["iso"].value,
)
disc_rip_info: Optional[DiscType] = None
if info.rip_data is None:
disc_rip_info = DiscAPI.find_disctype(info.uuid, info.label)
if disc_rip_info is None:
info.data_disc = self.makemkv_info_from_disc()
info.save()
else:
disc_rip_info = make_disc_type(json.loads(info.rip_data))
temp_dir = File.location(f"{CONFIG['ripper']['locations']['ripping'].value}{str(db_id)}/")
if isinstance(disc_rip_info, DiscType):
self._track_data = True
for idx, track in enumerate(disc_rip_info.tracks):
if isinstance(track, VideoTrackType):
if track.track_type in CONFIG["ripper"]["videoripping"]["torip"].value:
self._makemkv_backup_from_disc(temp_dir, idx)
ids.append(
self.__pass_single_to_converter(
info.id,
idx,
temp_dir + str(idx).zfill(2) + ".mkv",
disc_rip_info.track_title(idx),
track.json(),
)
)
elif disc_rip_info is None:
self._makemkv_backup_from_disc(temp_dir)
for idx, path in enumerate(Path(temp_dir).rglob("*.mkv")):
ids.append(
self.__pass_single_to_converter(
info.id,
idx,
("/" + "/".join(path.parts[1:])),
f"{info.label}: Track {idx}",
"{}",
)
)
return ids
def POST(self, disc_id: int, **kwargs): # pylint: disable=invalid-name,no-self-use
"""POST Function"""
data = {"tracks": []}
for key, value in kwargs.items():
if "_" not in key:
continue
if key == "disc_type":
data["type"] = value
s = key.split("_")
if s[0] == "disc":
data[s[1]] = value
continue
if s[0] == "track":
if int(s[1]) > len(data["tracks"]):
data["tracks"].append({s[2]: value})
else:
data["tracks"][int(s[1]) - 1][s[2]] = value
disc = make_disc_type(data)
try:
info = RipperVideoInfo.get_by_id(disc_id)
except DoesNotExist:
return self._return_data(
"Ripper",
f"Save Disc - {disc_id}",
False,
error="Disc ID not in DB",
errorNumber=0,
lockable=False,
)
if info.rip_data_locked:
return self._return_data(
"Ripper",
f"Save Disc - {disc_id}",
False,
error="Disc ID Locked Cannot alter",
errorNumber=1,
lockable=False,
)
info.rip_data = disc.make_dict()
info.save()
return self._return_data(
"Ripper",
f"Save Disc - {disc_id}",
True,
lockable=True,
)
def _add_video_disc_to_database(self, filename: str = ""):
"""sets up the DB stuff for disc"""
info = RipperVideoInfo.get_or_none(
RipperVideoInfo.uuid == self._disc["uuid"],
RipperVideoInfo.label == self._disc["label"],
RipperVideoInfo.disc_type == self._disc["type"],
)
if isinstance(RipperVideoInfo, info):
if isinstance(filename, str) and filename != "":
info.filename = filename
info.save()
self._db_id = info.id
return
info = RipperVideoInfo()
info.uuid == self._disc["uuid"],
info.label == self._disc["label"],
info.disc_type == self._disc["type"],
info.filename == filename
info.save()
self._db_id = info.id
return
def POST(self, disc_id: int, **kwargs): # pylint: disable=invalid-name,no-self-use
"""POST Function"""
try:
info = RipperVideoInfo.get_by_id(disc_id)
except DoesNotExist:
return self._return_data(
"Ripper",
f"Upload Disc - {disc_id}",
False,
error="Disc ID not in DB",
errorNumber=0,
)
info: RipperVideoInfo = RipperVideoInfo.get_by_id(disc_id)
if not info.rip_data or info.rip_data == {}:
return self._return_data(
"Ripper",
f"Upload Disc - {disc_id}",
False,
error="Disc Rip data not Complete",
errorNumber=1,
)
if not info.rip_data_locked:
return self._return_data(
"Ripper",
f"Upload Disc - {disc_id}",
False,
error="Disc Rip data not Locked",
errorNumber=2,
)
# TODO send data to API
uploaded = False
return self._return_data("Ripper", f"Upload Disc - {disc_id}", True, uploaded=uploaded)