jabsync/start.py

#!/usr/bin/env python
# vim: set sw=4 ts=4 si et: 

import sys
import os
import string
#from qt import *
from jabber import *
import StringIO
#import time
from account import Account
from config import Config
#from re import *
from optparse import OptionParser

#from threading import *
from xml.sax import saxutils
from xml.sax import make_parser
# for prettyprint
from xml.dom.ext import *
from xml.dom.ext.reader.Sax import *

class Answer:
    def __init__(self, question, answerlist):
        self._answer = None
        while not self._answer:
            sys.stderr.write(question)
            tmp_ans = raw_input()
            if tmp_ans in (answerlist): 
                self._answer = tmp_ans
      
    def get(self):
        return self._answer;
    
    
class JabSync:
    def __init__(self):
        # init des var
        self._commonJIDs = {}
        self._commonTransports = {}
        self._configFile = None
        self._config = None
        self._accountList = None
        self._jabservers = {}

    def parseCmdLine(self):
        parser = OptionParser()
        parser.add_option(\
            "-c","--config",\
            action="store", \
            type="string", \
            dest="filename",\
            help="Use file a configuration file",\
            metavar="config")
        (options,args)=parser.parse_args()
        if options.filename:
            self._configFile=options.filename
        else:
            self._configFile=os.path.join(os.path.expanduser("~"),".jabsync")
        print "Configuration file: " + self._configFile 

    def init(self):
        self._config = Config()
        self._config.loadFromFile(self._configFile)
        self._accountList = self._config.getAccounts()
        for account in self._accountList:
            account.connect()
            agents = account.getAgents()
            self._commonTransports.update(agents)
        for transport in self._commonTransports.keys():
            print "Transport: "+transport
 
    def giveTransport(self, hostName):
        if self._jabservers.has_key(hostName):
            trans_proto = hostName
            return trans_proto
        else:
            if self._commonTransports.has_key(hostName):
                trans_proto = self._commonTransports[hostName]
                return trans_proto
            else:
                # TODO: ask user input
                is_jabber = Answer(\
                    "# ERR : is "+hostName+" a jabber server ? [y/n]\n",\
                    ["y","n"]).get()
                if is_jabber == "y": 
                    self._jabservers[hostName] = 1
                else:
                    what_tp_ans = {\
                        "a" : "aim",\
                        "i" : "icq",\
                        "r" : "irc",\
                        "g" : "gadu",\
                        "m" : "msn",\
                        "p" : "public",\
                        "v" : "private",\
                        "y" : "yahoo",\
                        "-" : "forget"}
                    what_transport = Answer(\
                        "  Select transport type :\n"+\
                        "   [a]im"+\
                        "   [i]cq"+\
                        "   i[r]c):"+\
                        "   [g]adu"+\
                        "   [m]sn"+\
                        "   [p]ublic:"+\
                        "   pri[v]ate:"+\
                        "   [y]ahoo"+\
                        "   [-] Forget JIDs using this host",\
                        what_tp_ans.keys())
                    trans_proto = what_tp_ans[what_transport.get()]
                    print "Selected : " + trans_proto
                    if trans_proto == "forget": 
                        # TODO: ajouter regles d'exclusion
                        zero = 0
                    else:
                        # TODO: ajouter transport a la config XML
                        self._commonTransports[hostName] = trans_proto
                        zero = 0 
                return self.giveTransport(hostName)

      
    def get(self):
        print "jabsync::get\n"
        #get Roster
        for account in self._accountList:
            roster = account.getRoster()
            # fusionner les roster
            jid_list = roster.getJIDs()
            for jid in jid_list:
                print "Getting... " 
                print jid
                transport = jid.getDomain()
                trans_proto = self.giveTransport(transport)
                if not self._commonJIDs.has_key(trans_proto):
                    self._commonJIDs[trans_proto]={}
                jid_name = roster.getName(jid)
                jid_groups = roster.getGroups(jid)
                if not jid_name: jid_name = jid.getNode()	
                if not self._commonJIDs[trans_proto].has_key(jid.getNode()):
                    self._commonJIDs[trans_proto][jid.getNode()] = \
                        (jid_name,jid_groups)
                print "\x1B[G <- "+jid.getNode()+" @ "+trans_proto+" = "+jid_name

  #upload rosters
    def set(self):
        for account in self._accountList:
            account.setRoster(self._commonJIDs)
  
    def stop(self):
        for account in self._accountList:
            account.disconnect()
      
if __name__ == "__main__":
    jabsync=JabSync()
    jabsync.parseCmdLine()
    jabsync.init()
    jabsync.get()
    jabsync.set()
    jabsync.stop()