Work on rin server

Author: d_dd

cyClient.py

@@ -21,6 +21,7 @@ def __init__(self):
         self.queueMediaList = deque()
         self.canBurst = False
         self.lastQueueTime = time.time() - 20 #TODO
+        self.nowPlayingMedia = None
         ### Need to imporve this regex, it matches non-videos
         # ie https://www.youtube.com/feed/subscriptions
         self.ytUrl = re.compile(
@@ -159,16 +160,20 @@ def _cyCall_chatMsg(self, fdict):
         if msg.startswith('$'):
             command = msg.split()[0][1:]
             clog.debug('received command %s from %s' % (command, username), sys)
-            args = tuple(msg.split()[1:])
+            argsList = msg.split(' ', 1)
+            if len(argsList) == 2:
+                args = argsList[1]
+            else:
+                args = None
             thunk = getattr(self, '_com_%s' % (command,), None)
             if thunk is not None:
-                thunk(username, msg)
+                thunk(username, args)
 
-    def _com_vocadb(self, username, msg):
+    def _com_vocadb(self, username, args):
         if not vdb:
             return
         try:
-            songId = int(msg.split()[1])
+            songId = int(args)
         except IndexError:
             clog.error('(_com_vocadb) Index Error by %s' % username, sys)
             return
@@ -194,17 +199,15 @@ def parseTitle(self, command):
         shortMsg = command[:tBeg-3] + command[tEnd+1:]
         return command[tBeg:tEnd], shortMsg
 
-    def _com_add(self, username, msg):
+    def _com_add(self, username, args):
         rank = self._getRank(username)
-        clog.info('rank is %s' % rank, 'RANK')
         if not rank:
             return
         elif rank < 2:
             maxAdd = 5
         else:
             maxAdd = 20
-        clog.info(msg, sys)
-        args = msg[len('$add '):]
+        clog.info(args, sys)
         clog.info(args, 'sent to parseTitle')
         title, arguments = self.parseTitle(args)
         args = arguments.split()
@@ -255,10 +258,41 @@ def _com_add(self, username, msg):
         self.getRandMedia(args.sample, args.number, args.user, isRegistered,
                           title, args.temporary, args.next)
 
-    def _com_omit(self, username, msg):
+    def _com_omit(self, username, args):
+        rank = self._getRank(username)
+        clog.info('(_com_omit) %s' % args)
+        if rank < 2 or not self.nowPlayingMedia:
+            return
+        parsed = self._omit_args(args)
+        if not parsed:
+            self.doSendChat('Invalid parameters.')
+        elif parsed:
+            mType, mId = parsed
+            d = database.flagMedia(2, mType, mId)
+            d.addCallback(lambda res: clog.info(res, sys))
+
+    def _omit_args(self, args):
+        if not args:
+            mType, mId, mTitle = self.nowPlayingMedia
+            return mType, mId
+        elif args:
+            if ',' in args:
+                argl = args.split(',')
+            elif ' ' in args:
+                argl = args.split()
+            else:
+                return 'yt', args
+            try:
+                return argl[1], argl[0]
+            except(IndexError):
+                return False
+
+    def _com_unomit(self, username, msg):
         rank = self._getRank(username)
-        if rank < 2:
+        if rank < 2 or not self.nowPlayingMedia:
             return
+        mType, mId, mTitle = self.nowPlayingMedia
+        database.unflagMedia(2, mType, mId)
 
     def _getRank(self, username):
         try:
@@ -540,11 +574,11 @@ def dbErr(self, err):
         clog.error('(dbErr): %s' % err.value, sys)
 
     def _cyCall_changeMedia(self, fdict):
-        # set self.nowPlaying
+        # set self.nowPlayingMedia
         mType = fdict['args'][0]['type']
         mId = fdict['args'][0]['id']
         mTitle = fdict['args'][0]['title']
-        self.nowPlaying = (mType, mId, mTitle) # these are unicode
+        self.nowPlayingMedia = (mType, mId, mTitle) # these are unicode
         # everything has to be encoded to utf-8 or it errors
         s = mTitle.encode('utf-8') + ' (%s, %s)' % (mType.encode('utf-8'),
             mId.encode('utf-8'))

database.py

@@ -239,6 +239,10 @@ def addByUserAdd(nameLower, registered, words, limit):
     clog.info(binds, 'sql')
     return query(sql, binds)
 
+def getMediaById(mediaId):
+    sql = 'SELECT * FROM Media WHERE mediaId=?'
+    return query(sql, (mediaId,))
+
 dbpool = adbapi.ConnectionPool('sqlite3', 'data.db', check_same_thread=False,
                                cp_max=1) # one thread max; avoids db locks
 dbpool.runInteraction(turnOnFK)

ext/rinception.py

@@ -1,23 +1,83 @@
 """ Server for steam-bot """
 from twisted.internet import protocol, reactor
+from twisted.protocols.basic import LineReceiver
 from tools import clog
+import database
+import json
 
 sys = 'RinServer'
 
-class Messenger(protocol.Protocol):
+class LineReceiverFactory(protocol.Factory):
+    def buildProtocol(self, addr):
+        clog.info('(buildProtocol) Building protocol', sys)
+        return LineReceiver(self)
 
+class LineReceiver(LineReceiver):
+    
     def __init__(self, factory):
         self.factory = factory
 
     def connectionMade(self):
-        self.transport.write('Hi Rin!! -from Yukari\r\n')
+        #self.sendLine('Hi Rin!! -from Yukari')
         clog.info('(connectionMade) Connection established', sys)
 
-    def dataReceived(self, data): # echo
-        self.transport.write(data)
+    def lineReceived(self, line):
+        clog.info(line, sys)
+        d = checkLine(line)
+        if not d:
+            clog.error('at linerec')
+            return # if it's not a proper JSON don't reply
+        request = self.parseDict(d)
+        if request:
+            callType, args = request
+            thunk = getattr(self, '_rin_%s' % (callType,), None)
+            if thunk is not None:
+                thunk(args)
+            elif thunk is None:
+                response = {'callType': None, 'result': 'badname'}
+                self.sendLineAndLog(json.dumps(response))
+        else:
+            clog.error('no request')
 
-class MessengerFactory(protocol.Factory):
+    
+    def _rin_mediaById(self, args):
+        if 'mediaId' not in args:
+            response = {'callType': 'mediaById', 'result': 'badargs'}
+            self.sendLineAndLog(json.dumps(response))
+            return
+        mediaId = args['mediaId']
+        d = database.getMediaById(mediaId)
+        d.addCallback(self.sendOneMedia, args)
 
-    def buildProtocol(self, addr):
-        clog.info('(buildProtocol) Building protocol', sys)
-        return Messenger(self)
+    def sendOneMedia(self, res, args):
+        if res:
+            mRow = res[0]
+            mediaDict = {'mediaId': mRow[0], 'type': mRow[1], 'id': mRow[2],
+                         'dur': mRow[3], 'title': mRow[4], 'flag': mRow[5]}
+            response = {'callType': 'mediaById', 'result':'ok',
+                        'resource': mediaDict}
+        else:
+            response = {'callType': 'mediaById', 'result':'nomatch',
+                         'args': args}
+        self.sendLineAndLog(json.dumps(response))
+
+    def sendError(self, callType):
+        errorDict = {'callType':callType, 'result':'error'}
+        self.sendLineAndLog(json.dumps(errorDict))
+
+    def parseDict(self, d):
+        if 'callType' not in d or 'args' not in d:
+            return False
+        callType = d['callType']
+        args = d['args']
+        return (callType, args)
+
+    def sendLineAndLog(self, line):
+        clog.debug(line)
+        self.sendLine(line)
+
+def checkLine(line):
+    try:
+        return json.loads(line)
+    except(ValueError):
+        return False

ext/rinsight.py

@@ -2,13 +2,26 @@
 from twisted.internet import reactor
 from twisted.internet.protocol import Protocol, ClientCreator
 #from tools import clog
+import json
 
 sys = 'RinClient'
 
 
 class Prot(Protocol):
+    def connectionMade(self):
+        req = {'callType':'mediaById', 'args':{'mediaId':99}}
+        reqs = json.dumps(req) + '\r\n'
+        reactor.callLater(1, self.transport.write, reqs)
+
     def dataReceived(self, data):
+        print type(data)
         print data
+        try:
+            print json.loads(data)
+        except(ValueError):
+            print 'could not parse %s' % data
+       # reactor.callLater(1, self.transport.write,'t')
+       # reactor.callLater(1, self.transport.write,'\r\n')
 
 
 c = ClientCreator(reactor, Prot)

test_cyClientMisc.py

@@ -1,5 +1,6 @@
 import unittest
 from cyClient import CyProtocol
+from ext.rinception import Lr
 
 class TestParseAdd(unittest.TestCase):
 
@@ -25,5 +26,22 @@ def test(self):
         title = self.prot.parseTitle(command)
         self.assertEqual(title, (None, '-n 2'))
 
+class TestParseDict(unittest.TestCase):
+
+    def setUp(self):
+        self.rec = Lr(None)
+
+    def test(self):
+        requestd = {"callType":"mediaById", "args":{"mediaId":123}}
+        req = self.rec.parseDict(requestd)
+        callType, args = req
+        self.assertEqual(callType, 'mediaById')
+        self.assertEqual(args, {'mediaId':123})
+        ###
+        requestd = {"calltype":"mediaById", "args":{"mediaId":123}}
+        req = self.rec.parseDict(requestd)
+        self.assertEqual(req, False)
+
 if __name__ == '__main__':
     unittest.main()
+    #request = '{"callType":"mediaById", "args":"{"mediaId":123}}'

yukari.py

@@ -1,6 +1,6 @@
 from ircClient import IrcProtocol, IrcFactory
 from cyClient import CyProtocol, WsFactory
-from ext.rinception import Messenger, MessengerFactory
+from ext.rinception import LineReceiver, LineReceiverFactory
 from ext.apiserver import GetMedia
 from twisted.web.server import Site
 from conf import config
@@ -67,7 +67,7 @@ def ircConnect(self):
     def rinstantiate(self, port):
         """ Start server for Rin (steam-bot) """
         clog.info('(rinstantiate) Starting server for Rin', sys)
-        self.rinFactory = MessengerFactory()
+        self.rinFactory = LineReceiverFactory()
         reactor.listenTCP(18914, self.rinFactory)
 
     def recIrcMsg(self, user, channel, msg):