diff --git a/data/interfaces/default/config.html b/data/interfaces/default/config.html
index a1313d58..24f090ea 100644
--- a/data/interfaces/default/config.html
+++ b/data/interfaces/default/config.html
@@ -311,6 +311,7 @@
Black Hole
Transmission
uTorrent (Beta)
+ Deluge (Beta)
+
+
+
@@ -2003,6 +2050,26 @@
}
});
+ if ($("#telegram").is(":checked"))
+ {
+ $("#telegramoptions").show();
+ }
+ else
+ {
+ $("#telegramoptions").hide();
+ }
+
+ $("#telegram").click(function(){
+ if ($("#telegram").is(":checked"))
+ {
+ $("#telegramoptions").slideDown();
+ }
+ else
+ {
+ $("#telegramoptions").slideUp();
+ }
+ });
+
if ($("#osx_notify").is(":checked"))
{
$("#osx_notify_options").show();
@@ -2159,19 +2226,25 @@
if ($("#torrent_downloader_blackhole").is(":checked"))
{
- $("#transmission_options,#utorrent_options").hide();
+ $("#transmission_options,#utorrent_options,#deluge_options").hide();
$("#torrent_blackhole_options").show();
}
if ($("#torrent_downloader_transmission").is(":checked"))
{
- $("#torrent_blackhole_options,#utorrent_options").hide();
+ $("#torrent_blackhole_options,#utorrent_options,#deluge_options").hide();
$("#transmission_options").show();
}
if ($("#torrent_downloader_utorrent").is(":checked"))
{
- $("#torrent_blackhole_options,#transmission_options").hide();
+ $("#torrent_blackhole_options,#transmission_options,#deluge_options").hide();
$("#utorrent_options").show();
}
+ if ($("#torrent_downloader_deluge").is(":checked"))
+ {
+ $("#torrent_blackhole_options,#transmission_options,#utorrent_options").hide();
+ $("#deluge_options").show();
+ }
+
$('input[type=radio]').change(function(){
if ($("#preferred_bitrate").is(":checked"))
@@ -2208,15 +2281,19 @@
}
if ($("#torrent_downloader_blackhole").is(":checked"))
{
- $("#transmission_options,#utorrent_options").fadeOut("fast", function() { $("#torrent_blackhole_options").fadeIn() });
+ $("#transmission_options,#utorrent_options,#deluge_options").fadeOut("fast", function() { $("#torrent_blackhole_options").fadeIn() });
}
if ($("#torrent_downloader_transmission").is(":checked"))
{
- $("#torrent_blackhole_options,#utorrent_options").fadeOut("fast", function() { $("#transmission_options").fadeIn() });
+ $("#torrent_blackhole_options,#utorrent_options,#deluge_options").fadeOut("fast", function() { $("#transmission_options").fadeIn() });
}
if ($("#torrent_downloader_utorrent").is(":checked"))
{
- $("#torrent_blackhole_options,#transmission_options").fadeOut("fast", function() { $("#utorrent_options").fadeIn() });
+ $("#torrent_blackhole_options,#transmission_options,#deluge_options").fadeOut("fast", function() { $("#utorrent_options").fadeIn() });
+ }
+ if ($("#torrent_downloader_deluge").is(":checked"))
+ {
+ $("#torrent_blackhole_options,#utorrent_options,#transmission_options").fadeOut("fast", function() { $("#deluge_options").fadeIn() });
}
});
diff --git a/headphones/config.py b/headphones/config.py
index 8362b934..c63ae170 100644
--- a/headphones/config.py
+++ b/headphones/config.py
@@ -53,6 +53,12 @@ _CONFIG_DEFINITIONS = {
'CUSTOMSLEEP': (int, 'General', 1),
'CUSTOMUSER': (str, 'General', ''),
'DELETE_LOSSLESS_FILES': (int, 'General', 1),
+ 'DELUGE_HOST': (str, 'Deluge', ''),
+ 'DELUGE_PASSWORD': (str, 'Deluge', ''),
+ 'DELUGE_USERNAME': (str, 'Deluge', ''),
+ 'DELUGE_LABEL': (str, 'Deluge', ''),
+ 'DELUGE_DONE_DIRECTORY': (str, 'Deluge', ''),
+ 'DELUGE_PAUSED': (int, 'Deluge', 0),
'DESTINATION_DIR': (str, 'General', ''),
'DETECT_BITRATE': (int, 'General', 0),
'DO_NOT_PROCESS_UNMATCHED': (int, 'General', 0),
@@ -234,6 +240,10 @@ _CONFIG_DEFINITIONS = {
'SUBSONIC_PASSWORD': (str, 'Subsonic', ''),
'SUBSONIC_USERNAME': (str, 'Subsonic', ''),
'SYNOINDEX_ENABLED': (int, 'Synoindex', 0),
+ 'TELEGRAM_TOKEN': (str, 'Telegram', ''),
+ 'TELEGRAM_USERID': (str, 'Telegram', ''),
+ 'TELEGRAM_ENABLED': (int, 'Telegram', 0),
+ 'TELEGRAM_ONSNATCH': (int, 'Telegram', 0),
'TORRENTBLACKHOLE_DIR': (str, 'General', ''),
'TORRENT_DOWNLOADER': (int, 'General', 0),
'TORRENT_REMOVAL_INTERVAL': (int, 'General', 720),
diff --git a/headphones/deluge.py b/headphones/deluge.py
new file mode 100644
index 00000000..06e95db5
--- /dev/null
+++ b/headphones/deluge.py
@@ -0,0 +1,397 @@
+# This file is part of Headphones.
+#
+# Headphones is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Headphones is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Headphones. If not, see .
+
+# Parts of this file are a part of SickRage.
+# Author: echel0n
+# URL: http://www.github.com/sickragetv/sickrage/
+#
+# Adapted for Headphones by
+#
+# SickRage is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SickRage is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SickRage. If not, see .
+
+from __future__ import unicode_literals
+
+from headphones import logger, request
+
+import time
+import re
+import os
+import json
+import base64
+import urlparse
+import headphones
+import requests
+
+from base64 import b64encode
+
+delugeweb_auth = {}
+delugeweb_url = ''
+
+def add_torrent(link, data=None):
+ try:
+ result = {}
+ retid = False
+ if link.endswith('.torrent') or data:
+ # .torrent? for torcache links
+ # or '.torrent?' in link
+ if data:
+ metainfo = str(base64.b64encode(data))
+ # before I found out HP handles the downloads
+ #elif link.startswith('http://') or link.startswith('https://'):
+ # user_agent = 'Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/47.0.1546.111 Safari/582.36'
+ # headers = { 'User-Agent': user_agent }
+ # torrentfile = ''
+ # r = requests.get(link, headers=headers)
+ # if r.status_code == 200:
+ # for chunk in r.iter_content(chunk_size=1024):
+ # if chunk: # filter out keep-alive new chunks
+ # torrent_file = torrentfile + chunk
+ # metainfo = str(base64.b64encode(torrentfile.decode('utf-8')))
+ else:
+ with open(link, 'rb') as f:
+ metainfo = str(base64.b64encode(f.read()))
+ # Extract torrent name from .torrent
+ name_length = int( re.findall( 'name([0-9]*)\:.*?\:', base64.b64encode(metainfo) )[0] )
+ name = re.findall('name[0-9]*\:(.*?)\:', base64.b64encode(metainfo) )[0][:size]
+ result = {
+ 'type' : 'torrent',
+ 'name' : name,
+ 'content' : metainfo,
+ }
+ retid = add_torrent_file(result)
+
+ elif link.startswith('magnet:'):
+ result = {
+ 'type' : 'magnet',
+ 'url' : link,
+ }
+ retid = add_torrent_uri(result)
+ else:
+ logger.error('Deluge: Unknown file type - ' + str(link))
+
+ if retid:
+ logger.info(u"Torrent sent to Deluge successfully")
+ return retid
+ else:
+ logger.info('Deluge returned status %s' % retid)
+ return False
+
+ except Exception, e:
+ logger.error( str(e) )
+
+def get_torrent_folder(result):
+
+ if not any(delugeweb_auth):
+ get_auth()
+
+ post_data = json.dumps({
+ "method": "web.get_torrent_status",
+ "params": [
+ result['hash'],
+ [ "total_done" ]
+ ],
+ "id": 22
+ })
+
+ response = requests.post(delugeweb_url, data=post_data.encode('utf-8'), cookies=delugeweb_auth)
+ result['total_done'] = json.loads(response.text)['result']['total_done']
+
+ tries = 0
+ while result['total_done'] == 0 and tries < 10:
+ tries += 1
+ time.sleep(5)
+ response = requests.post(delugeweb_url, data=post_data.encode('utf-8'), cookies=delugeweb_auth)
+ result['total_done'] = json.loads(response.text)['result']['total_done']
+
+ post_data = json.dumps({
+ "method": "web.get_torrent_status",
+ "params": [
+ result['hash'],
+ [
+ "name",
+ "save_path",
+ "total_size",
+ "num_files",
+ "message",
+ "tracker",
+ "comment"
+ ]
+ ],
+ "id": 23
+ })
+
+ response = requests.post(delugeweb_url, data=post_data.encode('utf-8'), cookies=delugeweb_auth)
+
+ result['save_path'] = json.loads(response.text)['result']['save_path']
+ result['name'] = json.loads(response.text)['result']['name']
+
+ return json.loads(response.text)['result']['name']
+
+def remove_torrent(torrentid, remove_data=False):
+ '''
+ todo
+ '''
+ return
+
+def get_auth():
+
+ global delugeweb_auth, delugeweb_url
+ delugeweb_auth = {}
+
+ delugeweb_host = headphones.CONFIG.DELUGE_HOST
+ delugeweb_username = headphones.CONFIG.DELUGE_USERNAME
+ delugeweb_password = headphones.CONFIG.DELUGE_PASSWORD
+
+ if not delugeweb_host.startswith('http'):
+ delugeweb_host = 'http://' + delugeweb_host
+
+ if delugeweb_host.endswith('/'):
+ delugeweb_host = delugeweb_host[:-1]
+
+ delugeweb_url = delugeweb_host + '/json'
+
+ post_data = json.dumps({"method": "auth.login",
+ "params": [delugeweb_password],
+ "id": 1})
+ try:
+ response = requests.post(delugeweb_url, data=post_data.encode('utf-8'), cookies=delugeweb_auth )
+ # , verify=TORRENT_VERIFY_CERT)
+ except Exception:
+ return None
+
+ auth = json.loads(response.text)["result"]
+ delugeweb_auth = response.cookies
+
+ post_data = json.dumps({"method": "web.connected",
+ "params": [],
+ "id": 10})
+ try:
+ response = requests.post(delugeweb_url, data=post_data.encode('utf-8'), cookies=delugeweb_auth )
+ # , verify=TORRENT_VERIFY_CERT)
+ except Exception:
+ return None
+
+ connected = json.loads(response.text)['result']
+
+ if not connected:
+ post_data = json.dumps({"method": "web.get_delugeweb_hosts",
+ "params": [],
+ "id": 11})
+ try:
+ response = requests.post(delugeweb_url, data=post_data.encode('utf-8'), cookies=delugeweb_auth )
+ # , verify=TORRENT_VERIFY_CERT)
+ except Exception:
+ return None
+
+ delugeweb_hosts = json.loads(response.text)['result']
+ if len(delugeweb_hosts) == 0:
+ logger.error('Deluge: WebUI does not contain daemons')
+ return None
+
+ post_data = json.dumps({"method": "web.connect",
+ "params": [delugeweb_hosts[0][0]],
+ "id": 11})
+
+ try:
+ response = requests.post(delugeweb_url, data=post_data.encode('utf-8'), cookies=delugeweb_auth )
+ # , verify=TORRENT_VERIFY_CERT)
+ except Exception:
+ return None
+
+ post_data = json.dumps({"method": "web.connected",
+ "params": [],
+ "id": 10})
+
+ try:
+ response = requests.post(delugeweb_url, data=post_data.encode('utf-8'), cookies=delugeweb_auth )
+ # , verify=TORRENT_VERIFY_CERT)
+ except Exception:
+ return None
+
+ connected = json.loads(response.text)['result']
+
+ if not connected:
+ logger.error('Deluge: WebUI could not connect to daemon')
+ return None
+
+ return auth
+
+def add_torrent_uri(result):
+
+ if not any(delugeweb_auth):
+ get_auth()
+
+ post_data = json.dumps({"method": "core.add_torrent_magnet",
+ "params": [result['url'], {}],
+ "id": 2})
+
+ '''
+ # This method doesn't return hash
+ post_data = json.dumps({
+ "method": "web.add_torrents",
+ "params": [
+ [
+ {
+ "path": result['url'],
+ "options": {
+ "add_paused": headphones.CONFIG.DELUGE_PAUSED,
+ #"download_location": headphones.CONFIG.DOWNLOAD_TORRENT_DIR,
+ #"move_completed": true,
+ #"move_completed_path": headphones.CONFIG.DELUGE_DONE_DIRECTORY,
+ }
+ }
+ ]
+ ],
+ "id": 2
+ })
+ '''
+
+ response = requests.post(delugeweb_url, data=post_data.encode('utf-8'), cookies=delugeweb_auth)
+
+ result['hash'] = json.loads(response.text)['result']
+
+ return json.loads(response.text)['result']
+
+def add_torrent_file(result):
+
+ if not any(delugeweb_auth):
+ get_auth()
+
+ post_data = json.dumps({"method": "core.add_torrent_file",
+ "params": [result['name'] + '.torrent', b64encode(result['content']), {}],
+ "id": 2})
+
+ response = requests.post(delugeweb_url, data=post_data.encode('utf-8'), cookies=delugeweb_auth)
+
+ result['hash'] = json.loads(response.text)['result']
+
+ return json.loads(response.text)['result']
+
+def set_torrent_label(result):
+
+ label = headphones.CONFIG.DELUGE_LABEL
+
+ if not any(delugeweb_auth):
+ get_auth()
+
+ if ' ' in label:
+ logger.error('Deluge: Invalid label. Label must not contain a space - replacing with underscores')
+ label = label.replace(' ', '_')
+ if label:
+ # check if label already exists and create it if not
+ post_data = json.dumps({"method": 'label.get_labels',
+ "params": [],
+ "id": 3})
+ response = requests.post(delugeweb_url, data=post_data.encode('utf-8'), cookies=delugeweb_auth)
+ labels = json.loads(response.text)['result']
+
+ if labels is not None:
+ if label not in labels:
+ logger.debug('Deluge: ' + label + " label does not exist in Deluge we must add it")
+ post_data = json.dumps({"method": 'label.add',
+ "params": [label],
+ "id": 4})
+ response = requests.post(delugeweb_url, data=post_data.encode('utf-8'), cookies=delugeweb_auth)
+ logger.debug('Deluge: ' + label + " label added to Deluge")
+
+ # add label to torrent
+ post_data = json.dumps({"method": 'label.set_torrent',
+ "params": [result['hash'], label],
+ "id": 5})
+ response = requests.post(delugeweb_url, data=post_data.encode('utf-8'), cookies=delugeweb_auth)
+ logger.debug('Deluge: ' + label + " label added to torrent")
+ else:
+ logger.debug('Deluge: ' + "label plugin not detected")
+ return False
+
+ return not json.loads(response.text)['error']
+
+def set_torrent_ratio(result):
+
+ if not any(delugeweb_auth):
+ get_auth()
+
+ ratio = None
+ if result['ratio']:
+ ratio = result['ratio']
+
+ if ratio:
+ post_data = json.dumps({"method": "core.set_torrent_stop_at_ratio",
+ "params": [result['hash'], True],
+ "id": 5})
+ response = requests.post(delugeweb_url, data=post_data.encode('utf-8'), cookies=delugeweb_auth)
+ post_data = json.dumps({"method": "core.set_torrent_stop_ratio",
+ "params": [result['hash'], float(ratio)],
+ "id": 6})
+ response = requests.post(delugeweb_url, data=post_data.encode('utf-8'), cookies=delugeweb_auth)
+
+ return not json.loads(response.text)['error']
+
+ return True
+
+def set_torrent_path(result):
+
+ if not any(delugeweb_auth):
+ get_auth()
+
+ if headphones.CONFIG.DELUGE_DONE_DIRECTORY or headphones.CONFIG.DOWNLOAD_TORRENT_DIR:
+ post_data = json.dumps({"method": "core.set_torrent_move_completed",
+ "params": [result['hash'], True],
+ "id": 7})
+ response = requests.post(delugeweb_url, data=post_data.encode('utf-8'), cookies=delugeweb_auth)
+
+ if headphones.CONFIG.DELUGE_DONE_DIRECTORY:
+ move_to = headphones.CONFIG.DELUGE_DONE_DIRECTORY
+ else:
+ move_to = headphones.CONFIG.DOWNLOAD_TORRENT_DIR
+
+ if not os.path.exists(move_to):
+ logger.debug("Deluge: " + move_to + " directory doesn't exist, let's create it")
+ os.makedirs(move_to)
+ post_data = json.dumps({"method": "core.set_torrent_move_completed_path",
+ "params": [result['hash'], move_to],
+ "id": 8})
+ response = requests.post(delugeweb_url, data=post_data.encode('utf-8'), cookies=delugeweb_auth)
+
+ return not json.loads(response.text)['error']
+
+ return True
+
+def set_torrent_pause(result):
+
+ if not any(delugeweb_auth):
+ get_auth()
+
+ if headphones.CONFIG.DELUGE_PAUSED:
+ post_data = json.dumps({"method": "core.pause_torrent",
+ "params": [[ result['hash'] ]],
+ "id": 9})
+ response = requests.post(delugeweb_url, data=post_data.encode('utf-8'), cookies=delugeweb_auth)
+
+ return not json.loads(response.text)['error']
+
+ return True
+
diff --git a/headphones/notifiers.py b/headphones/notifiers.py
index 540107a7..2a9a0362 100644
--- a/headphones/notifiers.py
+++ b/headphones/notifiers.py
@@ -856,3 +856,36 @@ class Email(object):
except Exception, e:
logger.warn('Error sending Email: %s' % e)
return False
+
+
+class TELEGRAM(object):
+
+ def notify(self, message, status):
+ if not headphones.CONFIG.TELEGRAM_ENABLED:
+ return
+
+ import requests
+
+ TELEGRAM_API = "https://api.telegram.org/bot%s/%s"
+
+ # Get configuration data
+ token = headphones.CONFIG.TELEGRAM_TOKEN
+ userid = headphones.CONFIG.TELEGRAM_USERID
+
+ # Construct message
+ payload = {'chat_id': userid, 'text': status + ': ' + message }
+
+ # Send message to user using Telegram's Bot API
+ try:
+ response = requests.post(TELEGRAM_API % (token, "sendMessage"), data=payload)
+ except Exception, e:
+ logger.info(u'Telegram notify failed: ' + str(e) )
+
+ # Error logging
+ sent_successfuly = True
+ if not response.status_code == 200:
+ logger.info(u'Could not send notification to TelegramBot (token=%s). Response: [%s]', (token, response.text))
+ sent_successfuly = False
+
+ logger.info(u"Telegram notifications sent.")
+ return sent_successfuly
diff --git a/headphones/postprocessor.py b/headphones/postprocessor.py
index 432ab796..c386e6e8 100755
--- a/headphones/postprocessor.py
+++ b/headphones/postprocessor.py
@@ -27,7 +27,7 @@ from beets import autotag
from beets import config as beetsconfig
from beets.mediafile import MediaFile, FileTypeError, UnreadableFileError
from beetsplug import lyrics as beetslyrics
-from headphones import notifiers, utorrent, transmission
+from headphones import notifiers, utorrent, transmission, deluge
from headphones import db, albumart, librarysync
from headphones import logger, helpers, request, mb, music_encoder
@@ -46,7 +46,10 @@ def checkFolder():
if album['Kind'] == 'nzb':
download_dir = headphones.CONFIG.DOWNLOAD_DIR
else:
- download_dir = headphones.CONFIG.DOWNLOAD_TORRENT_DIR
+ if headphones.CONFIG.DELUGE_DONE_DIRECTORY:
+ download_dir = headphones.CONFIG.DELUGE_DONE_DIRECTORY
+ else:
+ download_dir = headphones.CONFIG.DOWNLOAD_TORRENT_DIR
album_path = os.path.join(download_dir, album['FolderName']).encode(
headphones.SYS_ENCODING, 'replace')
@@ -532,6 +535,11 @@ def doPostProcessing(albumid, albumpath, release, tracks, downloaded_track_list,
pushbullet = notifiers.PUSHBULLET()
pushbullet.notify(pushmessage, statusmessage)
+ if headphones.CONFIG.TELEGRAM_ENABLED:
+ logger.info(u"Telegram request")
+ telegram = notifiers.TELEGRAM()
+ telegram.notify(pushmessage, statusmessage)
+
if headphones.CONFIG.TWITTER_ENABLED:
logger.info(u"Sending Twitter notification")
twitter = notifiers.TwitterNotifier()
diff --git a/headphones/searcher.py b/headphones/searcher.py
index 91489a23..2d3e1e8b 100644
--- a/headphones/searcher.py
+++ b/headphones/searcher.py
@@ -33,7 +33,7 @@ from pygazelle import format as gazelleformat
import headphones
from headphones.common import USER_AGENT
from headphones import logger, db, helpers, classes, sab, nzbget, request
-from headphones import utorrent, transmission, notifiers, rutracker
+from headphones import utorrent, transmission, notifiers, rutracker, deluge
from bencode import bencode, bdecode
@@ -851,7 +851,7 @@ def send_to_downloader(data, bestqual, album):
else:
logger.error("Cannot save magnet link in blackhole. " \
"Please switch your torrent downloader to " \
- "Transmission or uTorrent, or allow Headphones " \
+ "Transmission, uTorrent or Deluge, or allow Headphones " \
"to open or convert magnet links")
return
else:
@@ -889,6 +889,54 @@ def send_to_downloader(data, bestqual, album):
if seed_ratio is not None:
transmission.setSeedRatio(torrentid, seed_ratio)
+ elif headphones.CONFIG.TORRENT_DOWNLOADER == 3: # Deluge
+ logger.info("Sending torrent to Deluge")
+
+ try:
+ # Add torrent
+ if bestqual[3] == 'rutracker.org':
+ torrentid = deluge.add_torrent('', data)
+ else:
+ torrentid = deluge.add_torrent(bestqual[2])
+
+ if not torrentid:
+ logger.error("Error sending torrent to Deluge. Are you sure it's running? Maybe the torrent already exists?")
+ return
+
+ # This isn't really necessary for an "Add Paused" mode,
+ # but it's a bit different than the built-in "Add Paused"
+ # because it pauses the torrent a moment after it has already been added.
+ # May be useful in the future
+ if headphones.CONFIG.DELUGE_PAUSED:
+ deluge.set_torrent_pause({'hash': torrentid})
+
+ # Set Label
+ if headphones.CONFIG.DELUGE_LABEL:
+ deluge.set_torrent_label({'hash': torrentid})
+
+ # Set Seed Ratio
+ seed_ratio = get_seed_ratio(bestqual[3])
+ if seed_ratio is not None:
+ deluge.set_torrent_ratio({'hash': torrentid, 'ratio': seed_ratio})
+
+ # Set move-to directory
+ if headphones.CONFIG.DELUGE_DONE_DIRECTORY:
+ deluge.set_torrent_path({'hash': torrentid})
+
+ # I only just realized this function is useless...
+ folder_name = deluge.get_torrent_folder({'hash': torrentid})
+ if folder_name:
+ logger.info('Torrent folder name: %s' % folder_name)
+ else:
+ logger.error('Torrent folder name could not be determined')
+ return
+
+ except Exception as e:
+ #exc_type, exc_obj, exc_tb = sys.exc_info()
+ #fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
+ #print(exc_type, fname, exc_tb.tb_lineno)
+ logger.error( str(e) )
+
else: # if headphones.CONFIG.TORRENT_DOWNLOADER == 2:
logger.info("Sending torrent to uTorrent")
@@ -960,6 +1008,10 @@ def send_to_downloader(data, bestqual, album):
logger.info(u"Sending PushBullet notification")
pushbullet = notifiers.PUSHBULLET()
pushbullet.notify(name, "Download started")
+ if headphones.CONFIG.TELEGRAM_ENABLED and headphones.CONFIG.TELEGRAM_ONSNATCH:
+ logger.info(u"Sending Telegram notification")
+ telegram = notifiers.TELEGRAM()
+ telegram.notify(name, "Download started")
if headphones.CONFIG.TWITTER_ENABLED and headphones.CONFIG.TWITTER_ONSNATCH:
logger.info(u"Sending Twitter notification")
twitter = notifiers.TwitterNotifier()
diff --git a/headphones/webserve.py b/headphones/webserve.py
index 561dea0e..a25e007f 100644
--- a/headphones/webserve.py
+++ b/headphones/webserve.py
@@ -1156,6 +1156,12 @@ class WebInterface(object):
"transmission_host": headphones.CONFIG.TRANSMISSION_HOST,
"transmission_username": headphones.CONFIG.TRANSMISSION_USERNAME,
"transmission_password": headphones.CONFIG.TRANSMISSION_PASSWORD,
+ "deluge_host": headphones.CONFIG.DELUGE_HOST,
+ "deluge_username": headphones.CONFIG.DELUGE_USERNAME,
+ "deluge_password": headphones.CONFIG.DELUGE_PASSWORD,
+ "deluge_label": headphones.CONFIG.DELUGE_LABEL,
+ "deluge_done_directory": headphones.CONFIG.DELUGE_DONE_DIRECTORY,
+ "deluge_paused": checked(headphones.CONFIG.DELUGE_PAUSED),
"utorrent_host": headphones.CONFIG.UTORRENT_HOST,
"utorrent_username": headphones.CONFIG.UTORRENT_USERNAME,
"utorrent_password": headphones.CONFIG.UTORRENT_PASSWORD,
@@ -1166,6 +1172,7 @@ class WebInterface(object):
"torrent_downloader_blackhole": radio(headphones.CONFIG.TORRENT_DOWNLOADER, 0),
"torrent_downloader_transmission": radio(headphones.CONFIG.TORRENT_DOWNLOADER, 1),
"torrent_downloader_utorrent": radio(headphones.CONFIG.TORRENT_DOWNLOADER, 2),
+ "torrent_downloader_deluge": radio(headphones.CONFIG.TORRENT_DOWNLOADER, 3),
"download_dir": headphones.CONFIG.DOWNLOAD_DIR,
"use_blackhole": checked(headphones.CONFIG.BLACKHOLE),
"blackhole_dir": headphones.CONFIG.BLACKHOLE_DIR,
@@ -1324,6 +1331,10 @@ class WebInterface(object):
"pushbullet_onsnatch": checked(headphones.CONFIG.PUSHBULLET_ONSNATCH),
"pushbullet_apikey": headphones.CONFIG.PUSHBULLET_APIKEY,
"pushbullet_deviceid": headphones.CONFIG.PUSHBULLET_DEVICEID,
+ "telegram_enabled": checked(headphones.CONFIG.TELEGRAM_ENABLED),
+ "telegram_onsnatch": checked(headphones.CONFIG.TELEGRAM_ONSNATCH),
+ "telegram_token": headphones.CONFIG.TELEGRAM_TOKEN,
+ "telegram_userid": headphones.CONFIG.TELEGRAM_USERID,
"subsonic_enabled": checked(headphones.CONFIG.SUBSONIC_ENABLED),
"subsonic_host": headphones.CONFIG.SUBSONIC_HOST,
"subsonic_username": headphones.CONFIG.SUBSONIC_USERNAME,
@@ -1420,10 +1431,11 @@ class WebInterface(object):
"synoindex_enabled", "pushover_enabled",
"pushover_onsnatch", "pushbullet_enabled", "pushbullet_onsnatch", "subsonic_enabled",
"twitter_enabled", "twitter_onsnatch",
+ "telegram_enabled", "telegram_onsnatch",
"osx_notify_enabled", "osx_notify_onsnatch", "boxcar_enabled", "boxcar_onsnatch",
"songkick_enabled", "songkick_filter_enabled",
"mpc_enabled", "email_enabled", "email_ssl", "email_tls", "email_onsnatch",
- "customauth", "idtag"
+ "customauth", "idtag", "deluge_paused"
]
for checked_config in checked_configs:
if checked_config not in kwargs:
@@ -1673,6 +1685,11 @@ class WebInterface(object):
pushbullet = notifiers.PUSHBULLET()
pushbullet.notify("it works!", "Test message")
+ @cherrypy.expose
+ def testTelegram(self):
+ logger.info("Testing Telegram notifications")
+ telegram = notifiers.TELEGRAM()
+ telegram.notify("it works!", "lazers pew pew")
class Artwork(object):
@cherrypy.expose