def onOpen(self):
     clog.info('(onOpen) Connected to Cytube!', sys)
     self.connectedTime = time.time()
     self.lastUserlistTime = 0
     self.factory.prot = self
     self.factory.handle.cy = True
     self.initialize()

 def deferredChatRes(self, res, key):
     if not res:
         clog.info('(deferredChatRes): wrote chat to database!', sys)
         return defer.succeed(key)
     else:
         clog.err('(deferredChatRes): error writing to database!', sys)
         return defer.fail(key)

 def bulkCheckVocaDb(self, songlessMedia):
     timeNow = round(time.time(), 4)
     clog.info('(bulkCheckVocaDb)', sys)
     for i, (mType, mId) in enumerate(songlessMedia):
         # 0.5s delay between each call
         reactor.callLater(i * 0.5, vdbapi.requestSongByPv, None, mType, mId,
                           1, timeNow, 4)

 def cacheKey(self, res, nickname):
     clog.error('the key is %s:' % res[0], sys)
     assert res, 'no res at cacheKey'
     if res:
         clog.info("(cacheKey) cached %s's key %s" % (nickname, res[0]))
         self.nickdict[nickname]['keyId'] = res[0]
         return defer.succeed(res[0])

 def _cyCall_delete(self, fdict):
     uid = fdict['args'][0]['uid']
     index = self.getIndexFromUid(uid)
     deletedMedia = self.playlist.pop(index)
     clog.info('(_cyCall_delete) Removed uid %s, index %s from my playlist' %
               (uid, index), sys)
     assert uid == deletedMedia['uid'], 'Deleted media not correct!'

 def userJoined(self, user, channel):
     clog.info('%s has joined %s' % (user, channel), sys)
     if channel == self.channelName:
         self.factory.handle.ircUserCount += 1
         self.nicklist.append(user)
     elif channel == self.channelStatus:
         self.sendCyNames()

 def userLeft(self, user, channel):
     clog.info('%s has left %s' % (user, channel), sys)
     if channel == self.channelName:
         self.factory.handle.ircUserCount -= 1
         try:
             self.nicklist.remove(user)
         except(ValueError):
             clog.error('(userLeft) User %s not in nicklist' % user)

 def left(self, channel):
     clog.info('Left IRC channel: %s' % channel, sys)
     if channel == config['irc']['channel']:
         self.factory.handle.inIrcChan = False
     elif channel == config['irc']['np']:
         self.factory.handle.inIrcNp = False
     elif channel == config['irc']['status']:
         self.factory.handle.inIrcStatus = False

 def clockUser(self, res, leftUser, timeNow):
     """ Clock out a user, by updating their accessTime """
     username = leftUser['name']
     clog.info('(clockUser) Clocking out %s!' % username, sys)
     timeJoined = leftUser['timeJoined']
     timeStayed = timeNow - timeJoined
     userId = leftUser['keyId']
     return database.updateCyUser(timeNow, timeStayed, userId)

 def cleanup(self):
     """ Prepares for shutdown """
     clog.info('(cleanup) Cleaning up for shutdown!', sys)
     self.done = Deferred()
     if self.irc:
         self.ircFactory.prot.partLeave('Shutting down.')
     if self.cy:
         self.wsFactory.prot.cleanUp()
     return self.done

 def userKicked(self, kickee, channel, kicker, message):
     clog.info('%s was kicked by %s from %s: %s' %
               (kickee, kicker, channel, message))
     if channel == self.channelName:
         self.factory.handle.ircUserCount -= 1
         try:
             self.nicklist.remove(kickee)
         except(ValueError):
             clog.error('(userKiced) User %s not in nicklist' % kickee)

 def _cyCall_changeMedia(self, fdict):
     # set self.nowPlaying
     mType = fdict['args'][0]['type']
     mId = fdict['args'][0]['id']
     mTitle = fdict['args'][0]['title']
     self.nowPlaying = (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'))
     clog.info('(_cyCall_changeMedia) %s' % s, sys)

def mediaSongResult(res, mType, mId, userId, timeNow):
    clog.info("(mediaSongResult) %s" % res, syst)
    if res:
        return defer.succeed(res[0])
    else:
        dd = requestApiByPv(mType, mId, timeNow)
        method = 0
        dd.addErrback(apiError)
        dd.addCallback(database.insertMediaSongPv, mType, mId, userId, timeNow, method)
        return dd

 def joined(self, channel):
     clog.info('Joined IRC channel: %s' % channel, sys)
     self.factory.handle.irc = True
     if channel == self.channelName:
         self.factory.handle.inIrcChan = True
     elif channel == self.channelNp:
         self.factory.handle.inIrcNp = True
     elif channel == self.channelStatus:
         self.factory.handle.inIrcStatus = True
         self.sendCyNames()
     self.getNicks(channel).addCallback(self.updateNicks, channel)

 def processVocadb(self, res, mType, mId, nameLower, isReg, isCommand):
     if not res:
         d = vdbapi3.obtainSong(mType, mId, nameLower, isReg)
         if isCommand:
             clog.info('(processVocadb) we got $vocadb command', syst)
         else:
             clog.info('(processVocadb) Vocadb db query returned [] ', syst)
             d.addCallback(self.displayResults, mType, mId, nameLower, isReg)
         return d
     else:
         return self.displayResults(res, mType, mId, nameLower, isReg)

 def _importPlugins(self):
     modules = importPlugins('plugins/')
     self.triggers = {'commands':{}}
     for module in modules:
         instance = module.setup()
         for method in dir(instance):
             # commands in cytube chat
             if method.startswith('_com_'):
                 trigger = '%s' % method[5:]
                 self.triggers['commands'][trigger] = getattr(instance, method)
                 clog.info('Imported %s!' % trigger, syst)

 def flagOrDelete(self, res, cy, mType, mId, title, uid):
     if res == 'EmbedOk':
         clog.info('%s EmbedOk' % title, syst)
         database.unflagMedia(0b1, mType, mId)
     elif res in ('Status503', 'Status403', 'Status404', 'NoEmbed','NoVid'):
         clog.warning('%s: %s' % (title, res), syst)
         cy.doDeleteMedia(uid)
         cy.uncache(mId)
         msg = 'Removing non-playable media %s' % title
         database.flagMedia(0b1, mType, mId)
         cy.sendCyWhisper(msg)

 def _omit(self, cy, username, args, dir, source):
     if cy._getRank(username) < 2:
         return
     clog.info('(_com_omit) %s' % args)
     mType, mId = self._omit_args(cy, args)
     if not mType: 
         cy.doSendChat('Invalid parameters.')
     else:
         # check existence and retrieve title
         d = database.getMediaByTypeId(mType, mId)
         d.addCallback(self.cbOmit, cy, mType, mId, username, dir, source)

 def movePlaylistItems(self, beforeUid, afterUid):
     # 'before' is just the uid of the video that is going to move
     clog.info('(movePlaylistItems) move uid:%s, after uid%s' %
               (beforeUid, afterUid), sys)
     if afterUid == 'prepend':
         indexAfter = 0
     else:
         indexAfter = self.getIndexFromUid(afterUid)
     indexBefore = self.getIndexFromUid(beforeUid)
     if indexBefore > indexAfter and afterUid != 'prepend':
         indexAfter += 1
     self.playlist.insert(indexAfter, self.playlist.pop(indexBefore))

def _bulkQueryMediaSong(txn, playlist):
    clog.debug('(_queryBulkMediaSong)', sys)
    songlessMedia = []
    for media in playlist:
        sql = ('SELECT songId FROM MediaSong WHERE mediaId IS'
               ' (SELECT mediaId FROM Media WHERE type=? AND id=?)')
        txn.execute(sql, media)
        row = txn.fetchone()
        if not row:
            songlessMedia.append(media)
    clog.info(songlessMedia, sys)
    return songlessMedia