651 lines
27 KiB
Python
651 lines
27 KiB
Python
import os, click, re
|
|
|
|
from textual.screen import Screen
|
|
from textual.widgets import Header, Footer, Static, Button, Input, DataTable
|
|
from textual.containers import Grid
|
|
|
|
from ffx.audio_layout import AudioLayout
|
|
|
|
from .pattern_controller import PatternController
|
|
from .show_controller import ShowController
|
|
from .track_controller import TrackController
|
|
from .tag_controller import TagController
|
|
|
|
from .show_details_screen import ShowDetailsScreen
|
|
from .pattern_details_screen import PatternDetailsScreen
|
|
|
|
from ffx.track_type import TrackType
|
|
from ffx.model.track import Track
|
|
|
|
from ffx.track_disposition import TrackDisposition
|
|
from ffx.track_descriptor import TrackDescriptor
|
|
from ffx.show_descriptor import ShowDescriptor
|
|
|
|
from textual.widgets._data_table import CellDoesNotExist
|
|
|
|
from ffx.media_descriptor import MediaDescriptor
|
|
from ffx.file_properties import FileProperties
|
|
|
|
from ffx.helper import DIFF_ADDED_KEY, DIFF_CHANGED_KEY, DIFF_REMOVED_KEY
|
|
|
|
|
|
# Screen[dict[int, str, int]]
|
|
class MediaDetailsScreen(Screen):
|
|
|
|
CSS = """
|
|
|
|
Grid {
|
|
grid-size: 5 8;
|
|
grid-rows: 8 2 2 2 8 2 2 8;
|
|
grid-columns: 25 25 120 10 75;
|
|
height: 100%;
|
|
width: 100%;
|
|
padding: 1;
|
|
}
|
|
|
|
DataTable .datatable--cursor {
|
|
background: darkorange;
|
|
color: black;
|
|
}
|
|
|
|
DataTable .datatable--header {
|
|
background: steelblue;
|
|
color: white;
|
|
}
|
|
|
|
Input {
|
|
border: none;
|
|
}
|
|
Button {
|
|
border: none;
|
|
}
|
|
|
|
DataTable {
|
|
min-height: 40;
|
|
}
|
|
|
|
#toplabel {
|
|
height: 1;
|
|
}
|
|
.two {
|
|
column-span: 2;
|
|
}
|
|
.three {
|
|
column-span: 3;
|
|
}
|
|
|
|
.four {
|
|
column-span: 4;
|
|
}
|
|
.five {
|
|
column-span: 5;
|
|
}
|
|
|
|
.triple {
|
|
row-span: 3;
|
|
}
|
|
|
|
.box {
|
|
height: 100%;
|
|
border: solid green;
|
|
}
|
|
|
|
.yellow {
|
|
tint: yellow 40%;
|
|
}
|
|
|
|
#differences-table {
|
|
row-span: 8;
|
|
/* tint: magenta 40%; */
|
|
}
|
|
|
|
/* #pattern_input {
|
|
tint: red 40%;
|
|
}*/
|
|
"""
|
|
|
|
|
|
BINDINGS = [
|
|
("n", "new_pattern", "New Pattern"),
|
|
("u", "update_pattern", "Update Pattern"),
|
|
("e", "edit_pattern", "Edit Pattern"),
|
|
]
|
|
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
|
|
self.context = self.app.getContext()
|
|
self.Session = self.context['database']['session'] # convenience
|
|
|
|
self.__pc = PatternController(context = self.context)
|
|
self.__sc = ShowController(context = self.context)
|
|
self.__tc = TrackController(context = self.context)
|
|
self.__tac = TagController(context = self.context)
|
|
|
|
if not 'command' in self.context.keys() or self.context['command'] != 'inspect':
|
|
raise click.ClickException(f"MediaDetailsScreen.__init__(): Can only perform command 'inspect'")
|
|
|
|
if not 'arguments' in self.context.keys() or not 'filename' in self.context['arguments'].keys() or not self.context['arguments']['filename']:
|
|
raise click.ClickException(f"MediaDetailsScreen.__init__(): Argument 'filename' is required to be provided for command 'inspect'")
|
|
|
|
self.__mediaFilename = self.context['arguments']['filename']
|
|
|
|
if not os.path.isfile(self.__mediaFilename):
|
|
raise click.ClickException(f"MediaDetailsScreen.__init__(): Media file {self.__mediaFilename} does not exist")
|
|
|
|
self.loadProperties()
|
|
|
|
|
|
def getRowIndexFromShowId(self, showId : int) -> int:
|
|
"""Find the index of the row where the value in the specified column matches the target_value."""
|
|
|
|
for rowKey, row in self.showsTable.rows.items(): # dict[RowKey, Row]
|
|
|
|
rowData = self.showsTable.get_row(rowKey)
|
|
|
|
try:
|
|
if showId == int(rowData[0]):
|
|
return int(self.showsTable.get_row_index(rowKey))
|
|
except:
|
|
continue
|
|
|
|
return None
|
|
|
|
|
|
def loadProperties(self):
|
|
|
|
self.__mediaFileProperties = FileProperties(self.context, self.__mediaFilename)
|
|
self.__currentMediaDescriptor = self.__mediaFileProperties.getMediaDescriptor()
|
|
|
|
#HINT: This is None if the filename did not match anything in database
|
|
self.__currentPattern = self.__mediaFileProperties.getPattern()
|
|
|
|
# keine tags vorhanden
|
|
self.__targetMediaDescriptor = self.__currentPattern.getMediaDescriptor(self.context) if self.__currentPattern is not None else None
|
|
|
|
# Enumerating differences between media descriptors
|
|
# from file (=current) vs from stored in database (=target)
|
|
try:
|
|
self.__mediaDifferences = self.__targetMediaDescriptor.compare(self.__currentMediaDescriptor) if self.__currentPattern is not None else {}
|
|
except ValueError:
|
|
self.__mediaDifferences = {}
|
|
|
|
|
|
def updateDifferences(self):
|
|
|
|
self.loadProperties()
|
|
|
|
self.differencesTable.clear()
|
|
|
|
if MediaDescriptor.TAGS_KEY in self.__mediaDifferences.keys():
|
|
|
|
currentTags = self.__currentMediaDescriptor.getTags()
|
|
targetTags = self.__targetMediaDescriptor.getTags()
|
|
|
|
if DIFF_ADDED_KEY in self.__mediaDifferences[MediaDescriptor.TAGS_KEY].keys():
|
|
for addedTagKey in self.__mediaDifferences[MediaDescriptor.TAGS_KEY][DIFF_ADDED_KEY]:
|
|
row = (f"added media tag: key='{addedTagKey}' value='{targetTags[addedTagKey]}'",)
|
|
self.differencesTable.add_row(*map(str, row))
|
|
|
|
if DIFF_REMOVED_KEY in self.__mediaDifferences[MediaDescriptor.TAGS_KEY].keys():
|
|
for removedTagKey in self.__mediaDifferences[MediaDescriptor.TAGS_KEY][DIFF_REMOVED_KEY]:
|
|
row = (f"removed media tag: key='{removedTagKey}' value='{currentTags[removedTagKey]}'",)
|
|
self.differencesTable.add_row(*map(str, row))
|
|
|
|
if DIFF_CHANGED_KEY in self.__mediaDifferences[MediaDescriptor.TAGS_KEY].keys():
|
|
for changedTagKey in self.__mediaDifferences[MediaDescriptor.TAGS_KEY][DIFF_CHANGED_KEY]:
|
|
row = (f"changed media tag: key='{changedTagKey}' value='{currentTags[changedTagKey]}'->'{targetTags[changedTagKey]}'",)
|
|
self.differencesTable.add_row(*map(str, row))
|
|
|
|
if MediaDescriptor.TRACKS_KEY in self.__mediaDifferences.keys():
|
|
|
|
currentTracks = self.__currentMediaDescriptor.getAllTrackDescriptors() # 0,1,2,3
|
|
targetTracks = self.__targetMediaDescriptor.getAllTrackDescriptors() # 0 <- from DB
|
|
|
|
if DIFF_ADDED_KEY in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY].keys():
|
|
|
|
#raise click.ClickException(f"add track {self.__mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_ADDED_KEY]}")
|
|
for addedTrackIndex in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_ADDED_KEY]:
|
|
addedTrack : Track = targetTracks[addedTrackIndex]
|
|
row = (f"added {addedTrack.getType().label()} track: index={addedTrackIndex} lang={addedTrack.getLanguage().threeLetter()}",)
|
|
self.differencesTable.add_row(*map(str, row))
|
|
|
|
if DIFF_REMOVED_KEY in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY].keys():
|
|
for removedTrackIndex in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_REMOVED_KEY]:
|
|
row = (f"removed track: index={removedTrackIndex}",)
|
|
self.differencesTable.add_row(*map(str, row))
|
|
|
|
if DIFF_CHANGED_KEY in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY].keys():
|
|
for changedTrackIndex in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_CHANGED_KEY].keys():
|
|
|
|
changedTrack : Track = targetTracks[changedTrackIndex]
|
|
changedTrackDiff : dict = self.__mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_CHANGED_KEY][changedTrackIndex]
|
|
|
|
if MediaDescriptor.TAGS_KEY in changedTrackDiff.keys():
|
|
|
|
if DIFF_ADDED_KEY in changedTrackDiff[MediaDescriptor.TAGS_KEY]:
|
|
for addedTagKey in changedTrackDiff[MediaDescriptor.TAGS_KEY][DIFF_ADDED_KEY]:
|
|
addedTagValue = changedTrack.getTags()[addedTagKey]
|
|
row = (f"changed {changedTrack.getType().label()} track index={changedTrackIndex} added key={addedTagKey} value={addedTagValue}",)
|
|
self.differencesTable.add_row(*map(str, row))
|
|
|
|
if DIFF_REMOVED_KEY in changedTrackDiff[MediaDescriptor.TAGS_KEY]:
|
|
for removedTagKey in changedTrackDiff[MediaDescriptor.TAGS_KEY][DIFF_REMOVED_KEY]:
|
|
row = (f"changed {changedTrack.getType().label()} track index={changedTrackIndex} removed key={removedTagKey}",)
|
|
self.differencesTable.add_row(*map(str, row))
|
|
|
|
if TrackDescriptor.DISPOSITION_SET_KEY in changedTrackDiff.keys():
|
|
|
|
if DIFF_ADDED_KEY in changedTrackDiff[TrackDescriptor.DISPOSITION_SET_KEY]:
|
|
for addedDisposition in changedTrackDiff[TrackDescriptor.DISPOSITION_SET_KEY][DIFF_ADDED_KEY]:
|
|
row = (f"changed {changedTrack.getType().label()} track index={changedTrackIndex} added disposition={addedDisposition.label()}",)
|
|
self.differencesTable.add_row(*map(str, row))
|
|
|
|
if DIFF_REMOVED_KEY in changedTrackDiff[TrackDescriptor.DISPOSITION_SET_KEY]:
|
|
for removedDisposition in changedTrackDiff[TrackDescriptor.DISPOSITION_SET_KEY][DIFF_REMOVED_KEY]:
|
|
row = (f"changed {changedTrack.getType().label()} track index={changedTrackIndex} removed disposition={removedDisposition.label()}",)
|
|
self.differencesTable.add_row(*map(str, row))
|
|
|
|
|
|
def on_mount(self):
|
|
|
|
if self.__currentPattern is None:
|
|
row = (' ', '<New show>', ' ') # Convert each element to a string before adding
|
|
self.showsTable.add_row(*map(str, row))
|
|
|
|
for show in self.__sc.getAllShows():
|
|
row = (int(show.id), show.name, show.year) # Convert each element to a string before adding
|
|
self.showsTable.add_row(*map(str, row))
|
|
|
|
for mediaTagKey, mediaTagValue in self.__currentMediaDescriptor.getTags().items():
|
|
row = (mediaTagKey, mediaTagValue) # Convert each element to a string before adding
|
|
self.mediaTagsTable.add_row(*map(str, row))
|
|
|
|
self.updateTracks()
|
|
|
|
|
|
if self.__currentPattern is not None:
|
|
|
|
showIdentifier = self.__currentPattern.getShowId()
|
|
showRowIndex = self.getRowIndexFromShowId(showIdentifier)
|
|
if showRowIndex is not None:
|
|
self.showsTable.move_cursor(row=showRowIndex)
|
|
|
|
self.query_one("#pattern_input", Input).value = self.__currentPattern.getPattern()
|
|
|
|
self.updateDifferences()
|
|
|
|
else:
|
|
|
|
self.query_one("#pattern_input", Input).value = self.__mediaFilename
|
|
self.highlightPattern(True)
|
|
|
|
|
|
def highlightPattern(self, state : bool):
|
|
if state:
|
|
self.query_one("#pattern_input", Input).styles.background = 'red'
|
|
else:
|
|
self.query_one("#pattern_input", Input).styles.background = None
|
|
|
|
|
|
def updateTracks(self):
|
|
|
|
self.tracksTable.clear()
|
|
|
|
trackDescriptorList = self.__currentMediaDescriptor.getAllTrackDescriptors()
|
|
|
|
typeCounter = {}
|
|
|
|
for td in trackDescriptorList:
|
|
|
|
trackType = td.getType()
|
|
if not trackType in typeCounter.keys():
|
|
typeCounter[trackType] = 0
|
|
|
|
dispoSet = td.getDispositionSet()
|
|
audioLayout = td.getAudioLayout()
|
|
row = (td.getIndex(),
|
|
trackType.label(),
|
|
typeCounter[trackType],
|
|
td.getCodec().label(),
|
|
audioLayout.label() if trackType == TrackType.AUDIO
|
|
and audioLayout != AudioLayout.LAYOUT_UNDEFINED else ' ',
|
|
td.getLanguage().label(),
|
|
td.getTitle(),
|
|
'Yes' if TrackDisposition.DEFAULT in dispoSet else 'No',
|
|
'Yes' if TrackDisposition.FORCED in dispoSet else 'No')
|
|
|
|
self.tracksTable.add_row(*map(str, row))
|
|
|
|
typeCounter[trackType] += 1
|
|
|
|
|
|
def compose(self):
|
|
|
|
# Create the DataTable widget
|
|
self.showsTable = DataTable(classes="two")
|
|
|
|
# Define the columns with headers
|
|
self.column_key_show_id = self.showsTable.add_column("ID", width=10)
|
|
self.column_key_show_name = self.showsTable.add_column("Name", width=50)
|
|
self.column_key_show_year = self.showsTable.add_column("Year", width=10)
|
|
|
|
self.showsTable.cursor_type = 'row'
|
|
|
|
|
|
self.mediaTagsTable = DataTable(classes="two")
|
|
|
|
# Define the columns with headers
|
|
self.column_key_track_tag_key = self.mediaTagsTable.add_column("Key", width=50)
|
|
self.column_key_track_tag_value = self.mediaTagsTable.add_column("Value", width=100)
|
|
|
|
self.mediaTagsTable.cursor_type = 'row'
|
|
|
|
|
|
self.tracksTable = DataTable(classes="two")
|
|
|
|
# Define the columns with headers
|
|
self.column_key_track_index = self.tracksTable.add_column("Index", width=5)
|
|
self.column_key_track_type = self.tracksTable.add_column("Type", width=10)
|
|
self.column_key_track_sub_index = self.tracksTable.add_column("SubIndex", width=8)
|
|
self.column_key_track_codec = self.tracksTable.add_column("Codec", width=10)
|
|
self.column_key_track_layout = self.tracksTable.add_column("Layout", width=10)
|
|
self.column_key_track_language = self.tracksTable.add_column("Language", width=15)
|
|
self.column_key_track_title = self.tracksTable.add_column("Title", width=48)
|
|
self.column_key_track_default = self.tracksTable.add_column("Default", width=8)
|
|
self.column_key_track_forced = self.tracksTable.add_column("Forced", width=8)
|
|
|
|
self.tracksTable.cursor_type = 'row'
|
|
|
|
|
|
# Create the DataTable widget
|
|
self.differencesTable = DataTable(id='differences-table') # classes="triple"
|
|
|
|
# Define the columns with headers
|
|
self.column_key_differences = self.differencesTable.add_column("Differences (file->db)", width=70)
|
|
|
|
self.differencesTable.cursor_type = 'row'
|
|
|
|
yield Header()
|
|
|
|
with Grid():
|
|
|
|
# 1
|
|
yield Static("Show")
|
|
yield self.showsTable
|
|
yield Static(" ")
|
|
yield self.differencesTable
|
|
|
|
# 2
|
|
yield Static(" ")
|
|
yield Button("Substitute", id="pattern_button")
|
|
yield Static(" ", classes="two")
|
|
|
|
# 3
|
|
yield Static("Pattern")
|
|
yield Input(type="text", id='pattern_input', classes="two")
|
|
|
|
yield Static(" ")
|
|
|
|
# 4
|
|
yield Static(" ", classes="four")
|
|
|
|
# 5
|
|
yield Static("Media Tags")
|
|
yield self.mediaTagsTable
|
|
yield Static(" ")
|
|
|
|
# 6
|
|
yield Static(" ", classes="four")
|
|
|
|
# 7
|
|
yield Static(" ")
|
|
yield Button("Set Default", id="select_default_button")
|
|
yield Button("Set Forced", id="select_forced_button")
|
|
yield Static(" ")
|
|
# 8
|
|
yield Static("Streams")
|
|
yield self.tracksTable
|
|
yield Static(" ")
|
|
|
|
yield Footer()
|
|
|
|
|
|
def getPatternDescriptorFromInput(self):
|
|
"""Returns show id and pattern from corresponding inputs"""
|
|
patternDescriptor = {}
|
|
try:
|
|
patternDescriptor['show_id'] = self.getSelectedShowDescriptor().getId()
|
|
patternDescriptor['pattern'] = str(self.query_one("#pattern_input", Input).value)
|
|
except:
|
|
pass
|
|
return patternDescriptor
|
|
|
|
|
|
def on_button_pressed(self, event: Button.Pressed) -> None:
|
|
|
|
if event.button.id == "pattern_button":
|
|
|
|
pattern = self.query_one("#pattern_input", Input).value
|
|
|
|
patternMatch = re.search(FileProperties.SE_INDICATOR_PATTERN, pattern)
|
|
|
|
if patternMatch:
|
|
self.query_one("#pattern_input", Input).value = pattern.replace(patternMatch.group(1), FileProperties.SE_INDICATOR_PATTERN)
|
|
|
|
|
|
if event.button.id == "select_default_button":
|
|
selectedTrackDescriptor = self.getSelectedTrackDescriptor()
|
|
self.__currentMediaDescriptor.setDefaultSubTrack(selectedTrackDescriptor.getType(), selectedTrackDescriptor.getSubIndex())
|
|
self.updateTracks()
|
|
|
|
if event.button.id == "select_forced_button":
|
|
selectedTrackDescriptor = self.getSelectedTrackDescriptor()
|
|
self.__currentMediaDescriptor.setForcedSubTrack(selectedTrackDescriptor.getType(), selectedTrackDescriptor.getSubIndex())
|
|
self.updateTracks()
|
|
|
|
|
|
def getSelectedTrackDescriptor(self):
|
|
"""Returns a partial track descriptor"""
|
|
try:
|
|
|
|
# Fetch the currently selected row when 'Enter' is pressed
|
|
#selected_row_index = self.table.cursor_row
|
|
row_key, col_key = self.tracksTable.coordinate_to_cell_key(self.tracksTable.cursor_coordinate)
|
|
|
|
if row_key is not None:
|
|
selected_track_data = self.tracksTable.get_row(row_key)
|
|
|
|
kwargs = {}
|
|
kwargs[TrackDescriptor.CONTEXT_KEY] = self.context
|
|
kwargs[TrackDescriptor.INDEX_KEY] = int(selected_track_data[0])
|
|
kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.fromLabel(selected_track_data[1])
|
|
kwargs[TrackDescriptor.SUB_INDEX_KEY] = int(selected_track_data[2])
|
|
kwargs[TrackDescriptor.CODEC_NAME_KEY] = int(selected_track_data[3])
|
|
kwargs[TrackDescriptor.AUDIO_LAYOUT_KEY] = AudioLayout.fromLabel(selected_track_data[4])
|
|
|
|
return TrackDescriptor(**kwargs)
|
|
else:
|
|
return None
|
|
|
|
except CellDoesNotExist:
|
|
return None
|
|
|
|
|
|
def getSelectedShowDescriptor(self):
|
|
|
|
try:
|
|
# Fetch the currently selected row when 'Enter' is pressed
|
|
#selected_row_index = self.table.cursor_row
|
|
row_key, col_key = self.showsTable.coordinate_to_cell_key(self.showsTable.cursor_coordinate)
|
|
|
|
if row_key is not None:
|
|
selected_row_data = self.showsTable.get_row(row_key)
|
|
|
|
try:
|
|
kwargs = {}
|
|
|
|
kwargs[ShowDescriptor.ID_KEY] = int(selected_row_data[0])
|
|
kwargs[ShowDescriptor.NAME_KEY] = str(selected_row_data[1])
|
|
kwargs[ShowDescriptor.YEAR_KEY] = int(selected_row_data[2])
|
|
|
|
return ShowDescriptor(**kwargs)
|
|
|
|
except ValueError:
|
|
return None
|
|
|
|
except CellDoesNotExist:
|
|
return None
|
|
|
|
|
|
def handle_new_pattern(self, showDescriptor: ShowDescriptor):
|
|
|
|
show = (showDescriptor.getId(), showDescriptor.getName(), showDescriptor.getYear())
|
|
self.showsTable.add_row(*map(str, show))
|
|
|
|
showRowIndex = self.getRowIndexFromShowId(showDescriptor.getId())
|
|
if showRowIndex is not None:
|
|
self.showsTable.move_cursor(row=showRowIndex)
|
|
|
|
patternDescriptor = self.getPatternDescriptorFromInput()
|
|
|
|
if patternDescriptor:
|
|
patternId = self.__pc.addPattern(patternDescriptor)
|
|
if patternId:
|
|
self.highlightPattern(False)
|
|
|
|
for tagKey, tagValue in self.__currentMediaDescriptor.getTags().items():
|
|
self.__tac.updateMediaTag(patternId, tagKey, tagValue)
|
|
|
|
for trackDescriptor in self.__currentMediaDescriptor.getAllTrackDescriptors():
|
|
self.__tc.addTrack(trackDescriptor, patternId = patternId)
|
|
|
|
|
|
def action_new_pattern(self):
|
|
|
|
try:
|
|
self.__currentMediaDescriptor.checkConfiguration()
|
|
except ValueError:
|
|
return
|
|
|
|
selectedShowDescriptor = self.getSelectedShowDescriptor()
|
|
|
|
#HINT: Callback is invoked after this method has exited. As a workaround the callback is executed directly
|
|
# from here with a mock-up screen result containing the necessary part of keys to perform correctly.
|
|
if selectedShowDescriptor is None:
|
|
self.app.push_screen(ShowDetailsScreen(), self.handle_new_pattern)
|
|
else:
|
|
self.handle_new_pattern(selectedShowDescriptor)
|
|
|
|
|
|
def action_update_pattern(self):
|
|
"""When updating the database the actions must reverse the difference (eq to diff db->file)"""
|
|
|
|
if self.__currentPattern is not None:
|
|
patternDescriptor = self.getPatternDescriptorFromInput()
|
|
if (patternDescriptor
|
|
and self.__currentPattern.getPattern() != patternDescriptor['pattern']):
|
|
return self.__pc.updatePattern(self.__currentPattern.getId(), patternDescriptor)
|
|
|
|
self.loadProperties()
|
|
|
|
if MediaDescriptor.TAGS_KEY in self.__mediaDifferences.keys():
|
|
|
|
if DIFF_ADDED_KEY in self.__mediaDifferences[MediaDescriptor.TAGS_KEY].keys():
|
|
for addedTagKey in self.__mediaDifferences[MediaDescriptor.TAGS_KEY][DIFF_ADDED_KEY]:
|
|
self.__tac.deleteMediaTagByKey(self.__currentPattern.getId(), addedTagKey)
|
|
|
|
if DIFF_REMOVED_KEY in self.__mediaDifferences[MediaDescriptor.TAGS_KEY].keys():
|
|
for removedTagKey in self.__mediaDifferences[MediaDescriptor.TAGS_KEY][DIFF_REMOVED_KEY]:
|
|
currentTags = self.__currentMediaDescriptor.getTags()
|
|
self.__tac.updateMediaTag(self.__currentPattern.getId(), removedTagKey, currentTags[removedTagKey])
|
|
|
|
if DIFF_CHANGED_KEY in self.__mediaDifferences[MediaDescriptor.TAGS_KEY].keys():
|
|
for changedTagKey in self.__mediaDifferences[MediaDescriptor.TAGS_KEY][DIFF_CHANGED_KEY]:
|
|
currentTags = self.__currentMediaDescriptor.getTags()
|
|
self.__tac.updateMediaTag(self.__currentPattern.getId(), changedTagKey, currentTags[changedTagKey])
|
|
|
|
if MediaDescriptor.TRACKS_KEY in self.__mediaDifferences.keys():
|
|
|
|
if DIFF_ADDED_KEY in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY].keys():
|
|
|
|
for addedTrackIndex in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_ADDED_KEY]:
|
|
targetTracks = [t for t in self.__targetMediaDescriptor.getAllTrackDescriptors() if t.getIndex() == addedTrackIndex]
|
|
if targetTracks:
|
|
self.__tc.deleteTrack(targetTracks[0].getId()) # id
|
|
|
|
if DIFF_REMOVED_KEY in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY].keys():
|
|
for removedTrackIndex, removedTrack in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_REMOVED_KEY].items():
|
|
|
|
# Track per inspect/update hinzufügen
|
|
self.__tc.addTrack(removedTrack, patternId = self.__currentPattern.getId())
|
|
|
|
if DIFF_CHANGED_KEY in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY].keys():
|
|
|
|
# [vsTracks[tp].getIndex()] = trackDiff
|
|
for changedTrackIndex, changedTrackDiff in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_CHANGED_KEY].items():
|
|
|
|
changedTargetTracks = [t for t in self.__targetMediaDescriptor.getAllTrackDescriptors() if t.getIndex() == changedTrackIndex]
|
|
changedTargeTrackId = changedTargetTracks[0].getId() if changedTargetTracks else None
|
|
changedTargetTrackIndex = changedTargetTracks[0].getIndex() if changedTargetTracks else None
|
|
|
|
changedCurrentTracks = [t for t in self.__currentMediaDescriptor.getAllTrackDescriptors() if t.getIndex() == changedTrackIndex]
|
|
# changedCurrentTrackId #HINT: Undefined as track descriptors do not come from file with track_id
|
|
|
|
if TrackDescriptor.TAGS_KEY in changedTrackDiff.keys():
|
|
changedTrackTagsDiff = changedTrackDiff[TrackDescriptor.TAGS_KEY]
|
|
|
|
if DIFF_ADDED_KEY in changedTrackTagsDiff.keys():
|
|
for addedTrackTagKey in changedTrackTagsDiff[DIFF_ADDED_KEY]:
|
|
|
|
if changedTargetTracks:
|
|
self.__tac.deleteTrackTagByKey(changedTargeTrackId, addedTrackTagKey)
|
|
|
|
if DIFF_REMOVED_KEY in changedTrackTagsDiff.keys():
|
|
for removedTrackTagKey in changedTrackTagsDiff[DIFF_REMOVED_KEY]:
|
|
if changedCurrentTracks:
|
|
self.__tac.updateTrackTag(changedTargeTrackId, removedTrackTagKey, changedCurrentTracks[0].getTags()[removedTrackTagKey])
|
|
|
|
if DIFF_CHANGED_KEY in changedTrackTagsDiff.keys():
|
|
for changedTrackTagKey in changedTrackTagsDiff[DIFF_CHANGED_KEY]:
|
|
if changedCurrentTracks:
|
|
self.__tac.updateTrackTag(changedTargeTrackId, changedTrackTagKey, changedCurrentTracks[0].getTags()[changedTrackTagKey])
|
|
|
|
if TrackDescriptor.DISPOSITION_SET_KEY in changedTrackDiff.keys():
|
|
changedTrackDispositionDiff = changedTrackDiff[TrackDescriptor.DISPOSITION_SET_KEY]
|
|
|
|
if DIFF_ADDED_KEY in changedTrackDispositionDiff.keys():
|
|
for changedTrackAddedDisposition in changedTrackDispositionDiff[DIFF_ADDED_KEY]:
|
|
if changedTargetTrackIndex is not None:
|
|
self.__tc.setDispositionState(self.__currentPattern.getId(), changedTargetTrackIndex, changedTrackAddedDisposition, False)
|
|
|
|
if DIFF_REMOVED_KEY in changedTrackDispositionDiff.keys():
|
|
for changedTrackRemovedDisposition in changedTrackDispositionDiff[DIFF_REMOVED_KEY]:
|
|
if changedTargetTrackIndex is not None:
|
|
self.__tc.setDispositionState(self.__currentPattern.getId(), changedTargetTrackIndex, changedTrackRemovedDisposition, True)
|
|
|
|
|
|
self.updateDifferences()
|
|
|
|
|
|
|
|
def action_edit_pattern(self):
|
|
|
|
patternDescriptor = self.getPatternDescriptorFromInput()
|
|
|
|
if patternDescriptor['pattern']:
|
|
|
|
selectedPatternId = self.__pc.findPattern(patternDescriptor)
|
|
|
|
if selectedPatternId is None:
|
|
raise click.ClickException(f"MediaDetailsScreen.action_edit_pattern(): Pattern to edit has no id")
|
|
|
|
self.app.push_screen(PatternDetailsScreen(patternId = selectedPatternId, showId = self.getSelectedShowDescriptor().getId()), self.handle_edit_pattern) # <-
|
|
|
|
|
|
def handle_edit_pattern(self, screenResult):
|
|
self.query_one("#pattern_input", Input).value = screenResult['pattern']
|
|
self.updateDifferences()
|
|
|