def __init__(self):
self.loadConfiguration("twitter.ini")
self.authorizeAPI()
self.ChatManager = ChatManager()
self.replyCharacterLimit = 140
self.replySuffix = "..."
self.splitSuffixLength = len(self.replySuffix)
def run():
"""
主程序入口
:return: None
"""
print('开始运行')
chatManager = ChatManager()
print('chatManager创建成功')
chatManager.run()
def __init__(self):
if(self.__state):
self.__dict__ = self.__state
else:
self.configProvider = ConfigProvider()
self.gatesProvider = GatesProvider()
self.chatMgr = ChatManager()
class InterChatDispatcher():
__state = {}
def __init__(self):
if(self.__state):
self.__dict__ = self.__state
else:
self.configProvider = ConfigProvider()
self.gatesProvider = GatesProvider()
self.chatMgr = ChatManager()
def launch(self):
#launch irc
irc_config = self.configProvider.getConfigSection('irc');
self.irc_thread = IRCThread( irc_config['host'], irc_config['port'], irc_config['nick'], irc_config['channels'], self)
self.connexion = self.irc_thread.getConnexion()
self.irc_thread.start()
self.skype_thread = InterChatSkypeThread(self)
self.skype_thread.start()
def dispatchIRCCommand(self, nick, message, channel):
print "Message: "+message+" From " + channel
return "oui"
def dispatchMessageToChannel(self, channel, message):
channelTo = self.chatMgr.getChanelByAlias(channel)
if(channelTo['type'] == 'irc'):
self.irc_thread.writeToChannel(message, channelTo['channel'])
if(channelTo['type'] == 'skype'):
self.skype_thread.writeToChannel(message, channelTo['channel'])
def messageToChannel(self, channel, message, nick=""):
parts = message.split(" ")
if(len(parts) > 1 and self.chatMgr.getChanelByAlias(parts[1])):
channelTo = self.chatMgr.getChanelByAlias(parts[1])
body = message.replace("!tele "+parts[1],"")
rmessage = "tele from {0}@{1}: {2}".format(nick, channel, body)
if(channelTo['type'] == 'irc'):
self.irc_thread.writeToChannel(rmessage, channelTo['channel'])
elif(channelTo['type'] == 'skype'):
self.skype_thread.writeToChannel(rmessage, channelTo['channel'])
def helpToChannel(self, channel, message):
with open('config/help.txt','r') as f:
for i,l in enumerate(f):
self.dispatchMessageToChannel(channel, l)
def getChannelList(self):
return self.chatMgr.getAliases()
def dispatchMessage(self, chatname, sendername, body):
# print body
channel = self.chatMgr.getChanelById(chatname)
if( sendername in ['pdobot', 'ictelecom'] ):
return False;
for channelTo in self.chatMgr.getAliases():
channelToFull = self.chatMgr.getChanelByAlias(channelTo)
if(self.chatMgr.isListening(channelTo, channel['alias'])):
print "BINGO"
if (channelToFull['type'] == 'irc'):
message = "{0}{1}: {2}".format(sendername, channel['alias'], body)
self.irc_thread.writeToChannel(message, channelTo)
return False
def listenChatOn(self, channel1, channel2):
return self.chatMgr.turnListenOn(channel1, channel2)
def listenChatOff(self, channel1, channel2):
return self.chatMgr.turnListenOff(channel1, channel2)
self.send_error(400, message=e.message)
return
except Exception as e:
print e.message
self.send_error(400, message=e.message)
return
self.set_status(200)
self.finish()
def init_app():
"""
Initializes the Tornado web app.
Registers the used URLs.
"""
return tornado.web.Application(
[(r"/", MainHandler), (r"/login", LoginHandler),
(r"/users", UsersHandler), (r"/conversations", ConversationHandler),
(r"/conversations/create", ConversationCreateHandler),
(r"/conversations/([0-9]+)", ConcreteConversationHandler),
(r"/conversations/([0-9]+)/([0-9]+)?", ConcreteConversationHandler)],
cookie_secret="6d41bbfe48ce3d078479feb364d98ecda2206edc")
if __name__ == "__main__":
cm = ChatManager()
app = init_app()
app.listen(8888)
tornado.ioloop.IOLoop.current().start()
self.finish()
def init_app():
"""
Initializes the Tornado web app.
Registers the used URLs.
"""
return tornado.web.Application([
(r"/", MainHandler),
(r"/login", LoginHandler),
(r"/getNonce", GetNonceHandler),
(r"/users", UsersHandler),
(r"/conversations", ConversationHandler),
(r"/conversation_active_user/([0-9]+)", ConversationUserHandler),
(r"/conversations/create", ConversationCreateHandler),
(r"/conversations/([0-9]+)", ConcreteConversationHandler),
(r"/conversations/([0-9]+)/([0-9]+)?", ConcreteConversationHandler)
],
cookie_secret="6d41bbfe48ce3d078479feb364d98ecda2206edc"
)
if __name__ == "__main__":
cm = ChatManager()
cm.set_nonce()
app = init_app()
print "Server Initialized"
app.listen(8888)
tornado.ioloop.IOLoop.current().start()
#!/usr/bin/python3
import socket
import logging, Log
from ChatManager import ChatManager
if __name__ == '__main__':
Log.loginit()
logging.info("Logging started, host: " + socket.gethostname())
cm = ChatManager()
cm.run()
class TwitterBot():
def __init__(self):
self.loadConfiguration("twitter.ini")
self.authorizeAPI()
self.ChatManager = ChatManager()
self.replyCharacterLimit = 140
self.replySuffix = "..."
self.splitSuffixLength = len(self.replySuffix)
def loadConfiguration(self, filePath):
configuration = ConfigParser.ConfigParser()
configuration.read(filePath)
self.consumerKey = configuration.get('consumer', 'key')
self.consumerSecret = configuration.get('consumer', 'secret')
self.accessToken = configuration.get('accessToken', 'token')
self.accessTokenSecret = configuration.get('accessToken', 'secret')
self.accountScreenName = configuration.get('account', 'owner').lower()
self.accountUserId = configuration.get('account', 'ownerId')
def authorizeAPI(self):
self.AuthHandler = OAuthHandler(self.consumerKey, self.consumerSecret)
self.AuthHandler.set_access_token(self.accessToken,
self.accessTokenSecret)
self.twitterAPI = API(self.AuthHandler)
def createStream(self):
self.streamListener = StreamListenerOverride()
self.streamListener.setBot(self)
self.twitterStream = Stream(self.getAuthHandle(), self.streamListener)
self.twitterStream.userstream(_with='user')
def getAuthHandle(self):
return self.AuthHandler
def handleData(self, data):
print data
self.tweet = json.loads(data.strip())
self.loadTweet()
if self.tweetId != "None":
if self.isTweetCreator():
pass
else:
self.replyToTweet()
def loadTweet(self):
self.tweetId = str(self.tweet.get('id_str', None))
self.senderName = str(
self.tweet.get('user', {}).get('screen_name', None))
self.tweetText = str(self.tweet.get('text', None))
def isTweetCreator(self):
userAccountIDFromTweet = self.tweet.get('user', {}).get('id_str', '')
return userAccountIDFromTweet == self.accountUserId
def replyToTweet(self):
self.replyText = self.ChatManager.getReplyToMessage(self.tweetText)
self.tagUserInReply(self.senderName)
self.calculateReplySplitCount()
self.sendTweets()
def tagUserInReply(self, userName):
self.taggedUserText = self.getTaggedUserText(userName)
self.taggedUserTextLength = len(self.getTaggedUserText(userName))
def getTaggedUserText(self, userName):
return '@' + userName + ' '
def calculateReplySplitCount(self):
textLength = len(self.replyText)
self.tweetSplitCount = 0
while (self.tweetSplitCount * self.replyCharacterLimit) < textLength:
self.tweetSplitCount = self.tweetSplitCount + 1
if self.tweetSplitCount > 1:
textLength = textLength + len(
self.replySuffix) + self.taggedUserTextLength
else:
textLength = textLength + self.taggedUserTextLength
def sendTweets(self):
for replyTweetText in self.getTweetsList():
self.twitterAPI.update_status(status=replyTweetText,
in_reply_to_status_id=self.tweetId)
def getTweetsList(self):
tweets = []
if self.tweetSplitCount == 1:
tweets.append(self.taggedUserText + self.replyText)
else:
for index in range(0, self.tweetSplitCount):
splitNumber = index + 1
text = self.getReplySplitText(splitNumber)
tweets.append(text)
return tweets
def getReplySplitText(self, splitNumber):
splitStartIndex = self.getReplySplitStartIndex(splitNumber)
splitEndIndex = self.getReplySplitEndIndex(splitNumber)
splitReplySuffix = self.getReplySplitSuffix(splitNumber)
return self.taggedUserText + self.replyText[
splitStartIndex:splitEndIndex] + splitReplySuffix
def getReplySplitStartIndex(self, splitNumber):
textStartIndex = 0
if splitNumber > 1:
previousSplitNumber = splitNumber - 1
replyCharacterLimitIndex = self.replyCharacterLimit * previousSplitNumber
splitSuffixLengthIndex = self.splitSuffixLength * previousSplitNumber
taggedUserTextLengthIndex = self.taggedUserTextLength * previousSplitNumber
textStartIndex = replyCharacterLimitIndex - splitSuffixLengthIndex - taggedUserTextLengthIndex
return textStartIndex
def getReplySplitEndIndex(self, splitNumber):
if splitNumber == self.tweetSplitCount:
return len(self.replyText)
else:
replyCharacterLimitIndex = self.replyCharacterLimit * splitNumber
splitSuffixLengthIndex = self.splitSuffixLength * splitNumber
taggedUserTextLengthIndex = self.taggedUserTextLength * splitNumber
return replyCharacterLimitIndex - splitSuffixLengthIndex - taggedUserTextLengthIndex
def getReplySplitSuffix(self, splitNumber):
if splitNumber == self.tweetSplitCount:
return ""
else:
return self.replySuffix
