def get_recently_added_media(self,
server_id=None,
count='0',
media_type='',
**kwargs):
recently_added = []
for (server_name, server) in self.__dict__.items():
if isinstance(server, plexServer) and server.PLEX_SERVER_UP:
if session.allow_session_server(server.CONFIG.ID):
if server_id and int(server_id) != server.CONFIG.ID:
continue
result = server.PMSCONNECTION.get_recently_added_details(
count=count, media_type=media_type)
if 'recently_added' in result:
recently_added.append({
'server_name': server_name,
'server_id': server.CONFIG.ID,
'items': result['recently_added']
})
if server_id:
break
if recently_added:
recently_added = sorted(recently_added,
key=lambda k: k['server_name'])
return recently_added
def get_server_ids(self):
server_ids = []
for (server_name, server) in self.__dict__.items():
if isinstance(server, plexServer):
if session.allow_session_server(server.CONFIG.ID):
server_ids.append(server.CONFIG.ID)
return server_ids
def get_server_names(self):
server_names = []
for (server_name, server) in self.__dict__.items():
if isinstance(server, plexServer):
if session.allow_session_server(server.CONFIG.ID):
server_name = {
'server_id': server.CONFIG.ID,
'pms_name': server.CONFIG.PMS_NAME
}
server_names.append(server_name)
return server_names
def get_current_activity(self,
server_id=None,
session_key=None,
session_id=None,
**kwargs):
current_activity = {
'lan_bandwidth': 0,
'sessions': [],
'stream_count': 0,
'stream_count_direct_play': 0,
'stream_count_direct_stream': 0,
'stream_count_transcode': 0,
'total_bandwidth': 0,
'wan_bandwidth': 0,
'servers': []
}
for (server_name, server) in self.__dict__.items():
if isinstance(server, plexServer):
if (
server_id and int(server_id) != server.CONFIG.ID
) or not server.CONFIG.PMS_IS_ENABLED or not server.WS_CONNECTED:
continue
if session.allow_session_server(server.CONFIG.ID):
server_activity = server.get_current_activity(
session_key=session_key, **kwargs)
if server_activity:
current_activity['sessions'].extend(
server_activity['sessions'])
current_activity['lan_bandwidth'] += int(
server_activity['lan_bandwidth'])
current_activity['stream_count'] += int(
server_activity['stream_count'])
current_activity['stream_count_direct_play'] += int(
server_activity['stream_count_direct_play'])
current_activity['stream_count_direct_stream'] += int(
server_activity['stream_count_direct_stream'])
current_activity['stream_count_transcode'] += int(
server_activity['stream_count_transcode'])
current_activity['total_bandwidth'] += int(
server_activity['total_bandwidth'])
current_activity['wan_bandwidth'] += int(
server_activity['wan_bandwidth'])
current_activity['servers'].append(server_activity)
if session_key:
return next((s for s in current_activity['sessions']
if s['session_key'] == session_key), {})
if session_id:
return next((s for s in current_activity['sessions']
if s['session_id'] == session_id), {})
return current_activity
def get_server_status(self, server_id=None, session_key=None, **kwargs):
server_status = {
'data': [],
'recordsFiltered': 0,
'recordsTotal': 0,
}
for (server_name, server) in self.__dict__.items():
if isinstance(server,
plexServer) and not server.CONFIG.PMS_IS_DELETED:
if session.allow_session_server(server.CONFIG.ID):
server_status['data'].append(server.get_server_status())
server_status['recordsFiltered'] = len(server_status['data'])
server_status['recordsTotal'] = len(server_status['data'])
return server_status
def get_synced_items(self,
machine_id=None,
client_id_filter=None,
user_id_filter=None,
rating_key_filter=None,
sync_id_filter=None,
server_id_filter=None):
if isinstance(rating_key_filter, list):
rating_key_filter = [str(k) for k in rating_key_filter]
elif rating_key_filter:
rating_key_filter = [str(rating_key_filter)]
if isinstance(user_id_filter, list):
user_id_filter = [str(k) for k in user_id_filter]
elif user_id_filter:
user_id_filter = [str(user_id_filter)]
user_data = users.Users()
synced_items = []
for server in plexpy.PMS_SERVERS:
if server_id_filter and int(server_id_filter) != server.CONFIG.ID:
continue
if not session.allow_session_server(server.CONFIG.ID):
continue
machine_id = server.CONFIG.PMS_IDENTIFIER
sync_list = self.get_plextv_sync_lists(machine_id,
output_format='xml')
try:
xml_head = sync_list.getElementsByTagName('SyncList')
except Exception as e:
logger.warn(
u"Tautulli PlexTV :: Unable to parse XML for get_synced_items: %s."
% e)
return {}
for a in xml_head:
client_id = helpers.get_xml_attr(a, 'clientIdentifier')
# Filter by client_id
if client_id_filter and str(client_id_filter) != client_id:
continue
sync_list_id = helpers.get_xml_attr(a, 'id')
sync_device = a.getElementsByTagName('Device')
for device in sync_device:
device_user_id = helpers.get_xml_attr(device, 'userID')
try:
device_username = user_data.get_details(
user_id=device_user_id)['username']
device_friendly_name = user_data.get_details(
user_id=device_user_id)['friendly_name']
except:
device_username = ''
device_friendly_name = ''
device_name = helpers.get_xml_attr(device, 'name')
device_product = helpers.get_xml_attr(device, 'product')
device_product_version = helpers.get_xml_attr(
device, 'productVersion')
device_platform = helpers.get_xml_attr(device, 'platform')
device_platform_version = helpers.get_xml_attr(
device, 'platformVersion')
device_type = helpers.get_xml_attr(device, 'device')
device_model = helpers.get_xml_attr(device, 'model')
device_last_seen = helpers.get_xml_attr(
device, 'lastSeenAt')
# Filter by user_id
if user_id_filter and device_user_id not in user_id_filter:
continue
for synced in a.getElementsByTagName('SyncItems'):
sync_item = synced.getElementsByTagName('SyncItem')
for item in sync_item:
for location in item.getElementsByTagName('Location'):
clean_uri = helpers.get_xml_attr(
location, 'uri').split('%2F')
rating_key = next(
(clean_uri[(idx + 1) % len(clean_uri)]
for idx, item in enumerate(clean_uri)
if item == 'metadata'), None)
# Filter by rating_key
if rating_key_filter and rating_key not in rating_key_filter:
continue
sync_id = helpers.get_xml_attr(item, 'id')
# Filter by sync_id
if sync_id_filter and str(sync_id_filter) != sync_id:
continue
sync_version = helpers.get_xml_attr(item, 'version')
sync_root_title = helpers.get_xml_attr(
item, 'rootTitle')
sync_title = helpers.get_xml_attr(item, 'title')
sync_metadata_type = helpers.get_xml_attr(
item, 'metadataType')
sync_content_type = helpers.get_xml_attr(
item, 'contentType')
for status in item.getElementsByTagName('Status'):
status_failure_code = helpers.get_xml_attr(
status, 'failureCode')
status_failure = helpers.get_xml_attr(
status, 'failure')
status_state = helpers.get_xml_attr(
status, 'state')
status_item_count = helpers.get_xml_attr(
status, 'itemsCount')
status_item_complete_count = helpers.get_xml_attr(
status, 'itemsCompleteCount')
status_item_downloaded_count = helpers.get_xml_attr(
status, 'itemsDownloadedCount')
status_item_ready_count = helpers.get_xml_attr(
status, 'itemsReadyCount')
status_item_successful_count = helpers.get_xml_attr(
status, 'itemsSuccessfulCount')
status_total_size = helpers.get_xml_attr(
status, 'totalSize')
status_item_download_percent_complete = helpers.get_percent(
status_item_downloaded_count,
status_item_count)
for settings in item.getElementsByTagName(
'MediaSettings'):
settings_video_bitrate = helpers.get_xml_attr(
settings, 'maxVideoBitrate')
settings_video_quality = helpers.get_xml_attr(
settings, 'videoQuality')
settings_video_resolution = helpers.get_xml_attr(
settings, 'videoResolution')
settings_audio_boost = helpers.get_xml_attr(
settings, 'audioBoost')
settings_audio_bitrate = helpers.get_xml_attr(
settings, 'musicBitrate')
settings_photo_quality = helpers.get_xml_attr(
settings, 'photoQuality')
settings_photo_resolution = helpers.get_xml_attr(
settings, 'photoResolution')
sync_details = {
"device_name": helpers.sanitize(device_name),
"server_id": server.CONFIG.ID,
"server_name": server.CONFIG.PMS_NAME,
"platform": helpers.sanitize(device_platform),
"user_id": device_user_id,
"user": helpers.sanitize(device_friendly_name),
"username": helpers.sanitize(device_username),
"root_title": helpers.sanitize(sync_root_title),
"sync_title": helpers.sanitize(sync_title),
"metadata_type": sync_metadata_type,
"content_type": sync_content_type,
"rating_key": rating_key,
"state": status_state,
"item_count": status_item_count,
"item_complete_count": status_item_complete_count,
"item_downloaded_count":
status_item_downloaded_count,
"item_downloaded_percent_complete":
status_item_download_percent_complete,
"video_bitrate": settings_video_bitrate,
"audio_bitrate": settings_audio_bitrate,
"photo_quality": settings_photo_quality,
"video_quality": settings_video_quality,
"total_size": status_total_size,
"failure": status_failure,
"client_id": client_id,
"sync_id": sync_id
}
synced_items.append(sync_details)
return session.filter_session_info(synced_items, filter_key='user_id')