Vueify snatch-selection

medusa/classes.py

@@ -23,7 +23,7 @@
 
 from dateutil import parser
 
-from medusa import app
+from medusa import app, ws
 from medusa.common import (
     MULTI_EP_RESULT,
     Quality,
@@ -32,7 +32,6 @@
 from medusa.logger.adapters.style import BraceAdapter
 from medusa.search import SearchType
 
-
 from six import itervalues
 
 log = BraceAdapter(logging.getLogger(__name__))
@@ -204,6 +203,34 @@ def __repr__(self):
 
         return '<{0}: {1}>'.format(type(self).__name__, result)
 
+    def to_json(self):
+        """Return JSON representation."""
+        return {
+            'identifier': self.identifier,
+            'release': self.name,
+            'season': self.actual_season,
+            'episodes': self.actual_episodes,
+            'seasonPack': len(self.actual_episodes) == 0,
+            'indexer': self.series.indexer,
+            'seriesId': self.series.series_id,
+            'showSlug': self.series.identifier.slug,
+            'url': self.url,
+            'time': datetime.now().replace(microsecond=0).isoformat(),
+            'quality': self.quality,
+            'releaseGroup': self.release_group,
+            'dateAdded': datetime.now().replace(microsecond=0).isoformat(),
+            'version': self.version,
+            'seeders': self.seeders,
+            'size': self.size,
+            'leechers': self.leechers,
+            'pubdate': self.pubdate.replace(microsecond=0).isoformat() if self.pubdate else None,
+            'provider': {
+                'id': self.provider.get_id(),
+                'name': self.provider.name,
+                'imageName': self.provider.image_name()
+            }
+        }
+
     def file_name(self):
         return u'{0}.{1}'.format(self.episodes[0].pretty_name(), self.result_type)
 
@@ -213,6 +240,10 @@ def add_result_to_cache(self, cache):
             # FIXME: Added repr parsing, as that prevents the logger from throwing an exception.
             # This can happen when there are unicode decoded chars in the release name.
             log.debug('Adding item from search to cache: {release_name!r}', release_name=self.name)
+
+            # Push an update to any open Web UIs through the WebSocket
+            ws.Message('addManualSearchResult', self.to_json()).push()
+
             return cache.add_cache_entry(self, parsed_result=self.parsed_result)
 
     def _create_episode_objects(self):
@@ -279,7 +310,7 @@ def update_from_db(self):
         self.leechers = int(cached_result['leechers'])
         self.release_group = cached_result['release_group']
         self.version = int(cached_result['version'])
-        self.pubdate = cached_result['pubdate']
+        self.pubdate = parser.parse(cached_result['pubdate']) if cached_result['pubdate'] else None
         self.proper_tags = cached_result['proper_tags'].split('|') \
             if cached_result['proper_tags'] else []
         self.date = datetime.today()

medusa/generic_queue.py

@@ -2,11 +2,13 @@
 
 from __future__ import unicode_literals
 
-import datetime
 import logging
 import threading
 from builtins import object
+from datetime import datetime
 from functools import cmp_to_key
+from uuid import uuid4
+
 
 log = logging.getLogger()
 
@@ -46,7 +48,7 @@ def add_item(self, item):
         :return: item
         """
         with self.lock:
-            item.added = datetime.datetime.now()
+            item.added = datetime.utcnow()
             self.queue.append(item)
 
             return item
@@ -111,19 +113,38 @@ def __init__(self, name, action_id=0):
         self.action_id = action_id
         self.stop = threading.Event()
         self.added = None
-        self.queue_time = datetime.datetime.now()
+        self.queue_time = datetime.utcnow()
         self.start_time = None
+        self._to_json = {
+            'identifier': str(uuid4()),
+            'name': self.name,
+            'priority': self.priority,
+            'actionId': self.action_id,
+            'queueTime': str(self.queue_time),
+            'success': None
+        }
 
     def run(self):
         """Implementing classes should call this."""
         self.inProgress = True
-        self.start_time = datetime.datetime.now()
+        self.start_time = datetime.utcnow()
 
     def finish(self):
         """Implementing Classes should call this."""
         self.inProgress = False
         threading.currentThread().name = self.name
 
+    @property
+    def to_json(self):
+        """Update queue item JSON representation."""
+        self._to_json.update({
+            'inProgress': self.inProgress,
+            'startTime': str(self.start_time) if self.start_time else None,
+            'updateTime': str(datetime.utcnow()),
+            'success': self.success
+        })
+        return self._to_json
+
 
 def fifo(my_list, item, max_size=100):
     """Append item to queue and limit it to 100 items."""

medusa/indexers/config.py

@@ -146,6 +146,7 @@ def create_config_json(indexer):
 
 
 def get_indexer_config():
+    """Create a per indexer and main indexer config, used by the apiv2."""
     indexers = {
         indexerConfig[indexer]['identifier']: create_config_json(indexerConfig[indexer]) for indexer in indexerConfig
     }

medusa/providers/generic_provider.py

@@ -848,3 +848,49 @@ def __str__(self):
     def __unicode__(self):
         """Return provider name and provider type."""
         return '{provider_name} ({provider_type})'.format(provider_name=self.name, provider_type=self.provider_type)
+
+    def to_json(self):
+        """Return a json representation for a provider."""
+        from medusa.providers.torrent.torrent_provider import TorrentProvider
+        return {
+            'name': self.name,
+            'id': self.get_id(),
+            'config': {
+                'enabled': self.enabled,
+                'search': {
+                    'backlog': {
+                        'enabled': self.enable_backlog
+                    },
+                    'manual': {
+                        'enabled': self.enable_backlog
+                    },
+                    'daily': {
+                        'enabled': self.enable_backlog,
+                        'maxRecentItems': self.max_recent_items,
+                        'stopAt': self.stop_at
+                    },
+                    'fallback': self.search_fallback,
+                    'mode': self.search_mode,
+                    'separator': self.search_separator,
+                    'seasonTemplates': self.season_templates,
+                    'delay': {
+                        'enabled': self.enable_search_delay,
+                        'duration': self.search_delay
+                    }
+                }
+            },
+            'animeOnly': self.anime_only,
+            'type': self.provider_type,
+            'public': self.public,
+            'btCacheUrls': self.bt_cache_urls if isinstance(self, TorrentProvider) else [],
+            'properStrings': self.proper_strings,
+            'headers': self.headers,
+            'supportsAbsoluteNumbering': self.supports_absolute_numbering,
+            'supportsBacklog': self.supports_backlog,
+            'url': self.url,
+            'urls': self.urls,
+            'cookies': {
+                'enabled': self.enable_cookies,
+                'required': self.cookies
+            }
+        }

medusa/search/queue.py

@@ -9,7 +9,7 @@
 import time
 import traceback
 
-from medusa import app, common, failed_history, generic_queue, history, ui
+from medusa import app, common, failed_history, generic_queue, history, ui, ws
 from medusa.helpers import pretty_file_size
 from medusa.logger.adapters.style import BraceAdapter
 from medusa.search import BACKLOG_SEARCH, DAILY_SEARCH, FAILED_SEARCH, MANUAL_SEARCH, SNATCH_RESULT, SearchType
@@ -256,13 +256,22 @@ def __init__(self, scheduler_start_time, force):
         self.scheduler_start_time = scheduler_start_time
         self.force = force
 
+        self.to_json.update({
+            'success': self.success,
+            'force': self.force
+        })
+
     def run(self):
         """Run daily search thread."""
         generic_queue.QueueItem.run(self)
         self.started = True
 
         try:
             log.info('Beginning daily search for new episodes')
+
+            # Push an update to any open Web UIs through the WebSocket
+            ws.Message('QueueItemUpdate', self.to_json).push()
+
             found_results = search_for_needed_episodes(self.scheduler_start_time, force=self.force)
 
             if not found_results:
@@ -315,6 +324,9 @@ def run(self):
         if self.success is None:
             self.success = False
 
+        # Push an update to any open Web UIs through the WebSocket
+        ws.Message('QueueItemUpdate', self.to_json).push()
+
         self.finish()
 
 
@@ -345,6 +357,13 @@ def __init__(self, show, segment, manual_search_type='episode'):
         self.segment = segment
         self.manual_search_type = manual_search_type
 
+        self.to_json.update({
+            'show': self.show.to_json(),
+            'segment': [ep.to_json() for ep in self.segment],
+            'success': self.success,
+            'manualSearchType': self.manual_search_type
+        })
+
     def run(self):
         """Run manual search thread."""
         generic_queue.QueueItem.run(self)
@@ -359,6 +378,9 @@ def run(self):
                 }
             )
 
+            # Push an update to any open Web UIs through the WebSocket
+            ws.Message('QueueItemUpdate', self.to_json).push()
+
             search_result = search_providers(self.show, self.segment, forced_search=True, down_cur_quality=True,
                                              manual_search=True, manual_search_type=self.manual_search_type)
 
@@ -396,6 +418,10 @@ def run(self):
         if self.success is None:
             self.success = False
 
+        # Push an update to any open Web UIs through the WebSocket
+        msg = ws.Message('QueueItemUpdate', self.to_json)
+        msg.push()
+
         self.finish()
 
 
@@ -423,6 +449,13 @@ def __init__(self, show, segment, search_result):
         self.results = None
         self.search_result = search_result
 
+        self.to_json.update({
+            'show': self.show.to_json(),
+            'segment': [ep.to_json() for ep in self.segment],
+            'success': self.success,
+            'searchResult': self.search_result.to_json()
+        })
+
     def run(self):
         """Run manual snatch job."""
         generic_queue.QueueItem.run(self)
@@ -434,6 +467,10 @@ def run(self):
             log.info('Beginning to snatch release: {name}',
                      {'name': result.name})
 
+            # Push an update to any open Web UIs through the WebSocket
+            msg = ws.Message('QueueItemUpdate', self.to_json)
+            msg.push()
+
             if result:
                 if result.seeders not in (-1, None) and result.leechers not in (-1, None):
                     log.info(
@@ -473,6 +510,10 @@ def run(self):
         if self.success is None:
             self.success = False
 
+        # Push an update to any open Web UIs through the WebSocket
+        msg = ws.Message('QueueItemUpdate', self.to_json)
+        msg.push()
+
         self.finish()
 
 
@@ -491,6 +532,12 @@ def __init__(self, show, segment):
         self.show = show
         self.segment = segment
 
+        self.to_json.update({
+            'show': self.show.to_json(),
+            'segment': [ep.to_json() for ep in self.segment],
+            'success': self.success
+        })
+
     def run(self):
         """Run backlog search thread."""
         generic_queue.QueueItem.run(self)
@@ -500,6 +547,10 @@ def run(self):
             try:
                 log.info('Beginning backlog search for: {name}',
                          {'name': self.show.name})
+
+                # Push an update to any open Web UIs through the WebSocket
+                ws.Message('QueueItemUpdate', self.to_json).push()
+
                 search_result = search_providers(self.show, self.segment)
 
                 if search_result:
@@ -557,6 +608,9 @@ def run(self):
         if self.success is None:
             self.success = False
 
+        # Push an update to any open Web UIs through the WebSocket
+        ws.Message('QueueItemUpdate', self.to_json).push()
+
         self.finish()
 
 
@@ -576,11 +630,21 @@ def __init__(self, show, segment, down_cur_quality=False):
         self.segment = segment
         self.down_cur_quality = down_cur_quality
 
+        self.to_json.update({
+            'show': self.show.to_json(),
+            'segment': [ep.to_json() for ep in self.segment],
+            'success': self.success,
+            'downloadCurrentQuality': self.down_cur_quality
+        })
+
     def run(self):
         """Run failed thread."""
         generic_queue.QueueItem.run(self)
         self.started = True
 
+        # Push an update to any open Web UIs through the WebSocket
+        ws.Message('QueueItemUpdate', self.to_json).push()
+
         try:
             for ep_obj in self.segment:
 
@@ -657,6 +721,9 @@ def run(self):
         if self.success is None:
             self.success = False
 
+        # Push an update to any open Web UIs through the WebSocket
+        ws.Message('QueueItemUpdate', self.to_json).push()
+
         self.finish()