def processEvent(self, xmsg, addr, _eventTime, newPeer, fromQueue):
     """ process any non-message event 
     @type xmsg: extMessageIncoming
     @type addr: unicode
     @type _eventTime: float
     @type newPeer: bool
     @type fromQueue: bool
     """
     msgData = None
     
     cmd = xmsg.getCommand()
     value = xmsg.getCommandPayload()
     
     action = PeerActions.get().getPeerAction(cmd)
     
     peerID = get_peers().getPeerID(pIP=addr)
     if action is not None:
         if peerID is None:
             getCoreLogger().error(u"Could not get peer ID for IP %s", addr)
             return
         
         try:
             msgData = action.preProcessMessageData(value)
         except:
             getCoreLogger().error("Error preprocessing data for peer action %s: %s", action.getName(), formatException())
             return
         
         if action.willIgnorePeerAction(msgData):
             getCoreLogger().debug("Ignore peer action %s.%s from peer %s (message: %s)",
                       action.getPluginName(), action.getName(),
                       peerID, value)
         
         if action.hasCategories():
             category = action.getCategoryFromMessage(msgData)
         else:
             category = None
         
         shouldProcess = PeerActions.get().shouldProcessMessage(action, category, peerID, self.getMainGUI(), msgData)
         
         getCoreLogger().debug(u"%s peer action %s.%s from peer %s%s",
                           "Accept" if shouldProcess else "Reject",
                           action.getPluginName(), action.getName(),
                           peerID, ("" if category is None else " category " + category))
         
         if not shouldProcess:
             return
     
     self.processPluginCall(addr, lambda p, ip, member_info: p.process_command(xmsg, ip, member_info, msgData), newPeer, fromQueue, action)
     #deprecated:
     self.processPluginCall(addr, lambda p, ip, member_info: p.process_event("HELO_"+cmd, value, ip, member_info, msgData), newPeer, fromQueue, action)
예제 #2
0
 def _canSendFilesToOther(self):
     peerInfo = get_peers().getPeerInfo(pID=self._otherID)
     if peerInfo is None:
         return False
     action = PeerActions.get().getPeerActionByName(u"hannesrauhe.lunchinator.file_transfer", u"Send File")
     if action is None or not action.appliesToPeer(self._otherID, peerInfo):
         return False
     return True    
예제 #3
0
 def dropEvent(self, event):
     if not self._canSendFilesToOther():
         event.ignore()
         return
     
     if event.mimeData().hasUrls() and int(event.possibleActions()) & Qt.CopyAction:
         files = []
         for url in event.mimeData().urls():
             if url.scheme() == u"file":
                 files.append(convert_string(url.toLocalFile()))
         
         if len(files) > 0:        
             action = PeerActions.get().getPeerActionByName(u"hannesrauhe.lunchinator.file_transfer", u"Send File")
             action.sendFilesToPeer(files, self._otherID)
             event.accept()
             return
     event.ignore()
예제 #4
0
def get_peer_actions():
    from lunchinator.peer_actions import PeerActions
    return PeerActions.get()
예제 #5
0
    class TestAction(PeerAction):
        def getName(self):
            return "Test Action"
        
        def getIcon(self):
            from PyQt4.QtGui import QCommonStyle, QStyle
            style = QCommonStyle()
            return style.standardIcon(QStyle.SP_MessageBoxWarning)
        
        def getMessagePrefix(self):
            return "TEST"
        
        def getPrivacyCategories(self):
            return (u"Category 1", u"Category 2")
        
        def hasCategories(self):
            return True
        
        def getCategoryFromMessage(self, _msgData):
            return u"Category 1"
    
    initializeLogger()
    w = privacy()
    testAction = TestAction()
    testAction._pluginObject = w
    testAction._pluginName = "Test Plugin"
    PeerActions.get()._peerActions["Test Plugin"] = [testAction]
    w.run_options_widget()
    PrivacySettings.get().save(notify=False) # don't notify, no deadlock
    print PrivacySettings.get()._settings