All working with sqlite

4 files changed, 221 insertions, 11 deletions

diff --git a/bosd.py b/bosd.py
new file mode 100644
index 0000000..4a241be
--- /dev/null
+++ b/bosd.py
@@ -0,0 +1,92 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import socket
+import weechat
+
+#### CONFIG ####
+enabled = True
+
+notify_channels = [
+    "RedpillLinpro.#python",
+    "Exile.#hin",
+    "RedpillLinpro.#adult",
+    "Exile.#pichove"
+    ]
+
+connections = [ {'sbosdd_ip': '127.0.0.1',
+                 'sbosdd_port':  9999},
+#                {'sbosdd_ip': "10.0.0.2",
+#                 'sbosdd_port':  9999}
+                ]
+################
+
+def bosd_send_xosd_message(message):
+    for conn in connections:
+        try:
+            #weechat.prnt("", message)
+            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            s.connect((conn['sbosdd_ip'], conn['sbosdd_port']))
+            s.send(message)
+            s.close()
+        except:
+            continue
+
+    return True
+
+
+def bosd_command(data, buffer, args):
+    global enabled
+    if args == 'on':
+        enabled = True
+        weechat.prnt(weechat.current_buffer(), "bosd on")
+    elif args == 'off':
+        enabled = False
+        weechat.prnt(weechat.current_buffer(), "bosd off")
+    else:
+        bosd_send_xosd_message(args)
+
+    return weechat.WEECHAT_RC_OK
+
+
+def bosd_privmsg_handler(data, signal, signal_data):
+    if not enabled:
+        return weechat.WEECHAT_RC_OK
+
+    prvmsg_dict = weechat.info_get_hashtable("irc_message_parse",
+                                  { "message": signal_data })
+
+
+    server = signal.split(",")[0]
+    
+    # channel = signal_data.split(":")[-1]
+    # my_nick = weechat.info_get("irc_nick_from_host", signal_data)
+   
+    my_nick = weechat.info_get("irc_nick", server)
+    channel = prvmsg_dict['arguments'].split(":")[0].strip()
+    nick = prvmsg_dict['nick']
+    message = ':'.join(prvmsg_dict['arguments'].split(':')[1:]).strip()
+    
+    if (my_nick in message) or ('{0}.{1}'.format(server,channel) in notify_channels):
+        template_msg = '{0} @ {1} - {2}: {3}'.format(channel, 
+                                                     server, 
+                                                     nick, 
+                                                     message)
+        bosd_send_xosd_message(template_msg)
+
+    if my_nick in channel:
+        template_msg = '{0} @ {1}: {2}'.format(nick, server, message)
+        bosd_send_xosd_message(template_msg)
+
+    #my_str = "%s - %s - %s - %s" % (my_nick, server, channel, message)
+    #weechat.prnt("", my_str)
+
+    return weechat.WEECHAT_RC_OK
+
+
+
+weechat.register('bosd', 'Simeon Simeonov', '1.0', 'GPL3', 'Socket notification script', "", "")
+weechat.hook_command("bosd", "bosd on off toggle", "<on | off>", "description...", "None", "bosd_command", "")
+weechat.hook_signal("*,irc_in2_privmsg", "bosd_privmsg_handler", "")
+
+weechat.prnt("", "bosd initiated!")
diff --git a/socket_server.py b/socket_server.py
index 7297d24..f683712 100755
--- a/socket_server.py
+++ b/socket_server.py
@@ -2,18 +2,18 @@
 # -*- coding: utf-8 -*-
 
 import SocketServer
+import os
 import sys
 
 from sqlalchemy import create_engine
 from sqlalchemy.orm import sessionmaker
 
-from bpynotify_orm import NotificationEntry
+from bpynotify_orm import NotificationEntry, notification_entry_table
 
 
 class CustomSocketServer(SocketServer.TCPServer):
 
     def __init__(self, server_address, RequestHandlerClass, session):
-        print "Done"
         SocketServer.TCPServer.__init__(self,
                                         server_address,
                                         RequestHandlerClass)
@@ -30,14 +30,10 @@ class MyTCPHandler(SocketServer.StreamRequestHandler):
     """
 
     def handle(self):
-        # self.request is the TCP socket connected to the client
-        ##self.data = self.request.recv(1024).strip()
-        ##print "{} wrote:".format(self.client_address[0])
-        ##print self.data
 
-        self.data = self.rfile.readline().strip()
-
-        entry = NotificationEntry(unicode(self.data))
+        self.data = self.rfile.readline().decode('utf8').strip()
+        #print(self.data)
+        entry = NotificationEntry(self.data)
         self.server.session.add(entry)
         self.server.session.commit()
 
@@ -46,14 +42,26 @@ def main():
     
     HOST, PORT = "localhost", 9999
 
+    if len(sys.argv) == 2 and sys.argv[1] == '-d':
+        try:
+            pid = os.fork()
+            if pid > 0:
+                sys.exit(0)
+        except Exception as e:
+            sys.stderr.write("Unable to daemonize. Fork error: {0}".format(e))
+            sys.exit(1)
+
     try:
+
         engine = create_engine('sqlite:///notifications.db')
         Session = sessionmaker(bind=engine) # bound session
         session = Session()
 
         server = CustomSocketServer((HOST, PORT), MyTCPHandler, session)
-        # Activate the server; this will keep running until you
-        # interrupt the program with Ctrl-C
+
+        # clean all previous entries #
+        notification_entry_table.delete(bind=engine).execute()
+
         server.serve_forever()
 
     except Exception as e:
diff --git a/web_server.py b/web_server.py
new file mode 100755
index 0000000..a8ccc7c
--- /dev/null
+++ b/web_server.py
@@ -0,0 +1,62 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import json
+import sys
+
+import cherrypy
+
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+
+from bpynotify_orm import NotificationEntry, notification_entry_table
+
+
+class WebNotifyServer(object):
+
+    def __init__(self, session):
+        self.session = session
+
+    @cherrypy.expose
+    def notifications(self):
+        query = self.session.query(NotificationEntry)\
+            .filter(NotificationEntry.viewed==False)\
+            .order_by(NotificationEntry.id)
+        entries = query.all()
+        entry_list = list()
+        for entry in entries:
+            #print(entry.message)
+            entry_list.append(entry.message)
+            entry.viewed = True
+        self.session.commit()
+        print (json.dumps(entry_list, sort_keys=True, indent=4))
+        return json.dumps(entry_list, sort_keys=True, indent=4)
+
+
+def main():
+
+    cherrypy.config.update({
+            'server.socket_host': '10.0.0.4',
+            'server.socket_port': 40004,
+
+            'server.ssl_module': 'pyopenssl',
+            'server.ssl_certificate': '/home/blackmore/gitprogs/bpynotify/cert.crt',
+            'server.ssl_private_key': '/home/blackmore/gitprogs/bpynotify/key.pem',            
+            })
+
+    try:
+        engine = create_engine('sqlite:///notifications.db')
+        Session = sessionmaker(bind=engine) # bound session
+        session = Session()
+
+        cherrypy.quickstart(WebNotifyServer(session))
+
+    except Exception as e:
+        sys.stderr.write("WebServer error: {0}".format(e))
+        sys.exit(1)
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/weechat_notify.py b/weechat_notify.py
new file mode 100755
index 0000000..f070551
--- /dev/null
+++ b/weechat_notify.py
@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import json
+import urllib2
+import sched
+import sys
+import time
+
+import pynotify
+
+POLLING_FREQUENCY = 10
+NOTIFICATION_URL = 'https://simeon.simeonov.no:40004/notifications/'
+TIMEOUT_SEC = 3
+
+def poll_notifications(scheduler):
+    """
+    """
+    try:
+        req = urllib2.Request(NOTIFICATION_URL)
+        response = urllib2.urlopen(req)
+        response_str = response.read()
+    
+        entries = json.loads(response_str)
+        for entry in entries:
+            n = pynotify.Notification('IRC', entry, 'dialog-information')
+            n.set_timeout(TIMEOUT_SEC)
+            n.show()
+
+    except Exception as e:
+        sys.stderr.write("Client error: {0}".format(e))
+        sys.exit(1)
+
+    scheduler.enter(POLLING_FREQUENCY, 1, poll_notifications, (scheduler,))
+
+
+def main():
+
+    if not pynotify.init("Weechat Notify"):
+        sys.stderr.write("There was a problem with libnotify")
+        sys.exit(1)
+
+    sc = sched.scheduler(time.time, time.sleep)
+    sc.enter(POLLING_FREQUENCY, 1, poll_notifications, (sc,))
+    sc.run()
+
+if __name__ == '__main__':
+    main()