def post(self):    
                from lxml import etree
		try:
                  self.ui.label.setText("Importing necessary modules...")
                  from wordpress_xmlrpc import Client, WordPressPost
                  status = 1  		
                except:
                  status = 0
                if(status==1):
                  from wordpress_xmlrpc.methods.posts import GetPosts, NewPost
		  from wordpress_xmlrpc.methods.users import GetUserInfo
                  self.ui.label.setText("Imported modules...")
		  data = etree.parse("config.xml")
		  user = data.find("user").text	
		  url = data.find("url").text
		  pwd = data.find("pass").text
                  self.ui.label.setText("Imported data...")
                  try:  
                    wp = Client(url+"/xmlrpc.php", user, pwd)
	            	  
                  except:
                    status = 0
                  if (status == 1):  
                    post = WordPressPost()
		    post.content = str(self.ui.BodyEdit.toPlainText())
		    post.title = str(self.ui.TitleEdit.text())
                    post.content = post.content + "<br><small><i>via QuickPress</i></small></br>"
                    post.post_status = 'publish'
		    wp.call(NewPost(post))	
                    self.ui.label.setText("Published") 
                  else:
                    self.ui.label.setText("Check Internet Connection and try again...")
                else:
		  self.ui.label.setText("module(wordpress_xmlrpc) not found, you can install manually from terminal using pip install python-wordpress-xmlrpc")                

    def load_file(self):
        fname = askopenfilename(filetypes=(("PNG Image", "*.png"),
                                           ("JPG Image", "*.jpg;*.jpeg"),
                                           ("GIF Image", "*.gif"),
                                           ("Bitmap Image", "*.bmp"),
                                           ("All Files", "*")))
        print(mimetypes.guess_type(fname)[0])
        try:
            wp = Client('https://your.wordpress.installation/xmlrpc.php', 'Username', 'password')
        except TimeoutError:
            self.status.delete(0, END)
            self.status.insert(0, 'Unable to connect to WP')
        except gaierror:
            self.status.config(state=NORMAL)
            self.status.delete(1.0, END)
            self.status.insert(1.0, 'DNS lookup failed')
            self.status.config(state=DISABLED)
            raise

        print(MyFrame.path_leaf(fname))
        data = {'name': MyFrame.path_leaf(fname), 'type': mimetypes.guess_type(fname)[0]}
        with open(fname, 'rb') as img:
            data['bits'] = xmlrpc_client.Binary(img.read())
        response = wp.call(media.UploadFile(data))
        print(response['url'])
        self.status.config(state=NORMAL)
        self.status.delete(1.0, END)
        self.status.insert(1.0, 'Link: '+response['url'])
        self.status.config(state=DISABLED)

def upload_to_wordpress(xmlrpc_url,xmlrpc_user,xmlrpc_pass,inputfile,name):
	"""upload to <xmlrpc_url> as <xmlrpc_user>, <xmlrpc_pass> the <inputfile> as <name>"""
	global path
	metadata = {
		'name': name,
		'type': mimetypes.guess_type(inputfile)[0] or 'audio/mpeg',
	}
	try:
		print xmlrpc_url,xmlrpc_user,xmlrpc_pass
		wpclient = Client(xmlrpc_url,xmlrpc_user,xmlrpc_pass)
		fh = open('/'.join([path,inputfile]))
		# Read input file and encode as base64
		with open(filename, 'rb') as fh:
			data['bits'] = xmlrpc_client.Binary(fh.read())
		response = wpclient.call(media.UploadFile(metadata))
		# Expected response:
		#	response == {
		#		'id': 6,
		#		'name': '2013.04.28_madison_whaley.mp3',
		#		'url': 'http://summitcrossing.org/wp-content/uploads/2013/04/28/2013.04.28_madison_whaley.mp3',
		#		'type': 'audio/mpeg',
		#	}
		if response['id']:
			# If upload succeeded, rename input file:
			os.rename(inputfile,name)
	except IOError as e:
		print("({})".format(e))
	return response

	def post_article(self,wpUrl,wpUserName,wpPassword,articleTitle, articleCategories, articleContent, articleTags,PhotoUrl):
		self.path=os.getcwd()+"\\00000001.jpg"
		self.articlePhotoUrl=PhotoUrl
		self.wpUrl=wpUrl
		self.wpUserName=wpUserName
		self.wpPassword=wpPassword
		#Download File
		f = open(self.path,'wb')
		f.write(urllib.urlopen(self.articlePhotoUrl).read())
		f.close()
		#Upload to WordPress
		client = Client(self.wpUrl,self.wpUserName,self.wpPassword)
		filename = self.path
		# prepare metadata
		data = {'name': 'picture.jpg','type': 'image/jpg',}
		
		# read the binary file and let the XMLRPC library encode it into base64
		with open(filename, 'rb') as img:
			data['bits'] = xmlrpc_client.Binary(img.read())
		response = client.call(media.UploadFile(data))
		attachment_id = response['id']
		#Post
		post = WordPressPost()
		post.title = articleTitle
		post.content = articleContent
		post.terms_names = { 'post_tag': articleTags,'category': articleCategories}
		post.post_status = 'publish'
		post.thumbnail = attachment_id
		post.id = client.call(posts.NewPost(post))
		print 'Post Successfully posted. Its Id is: ',post.id

def test_pages(user, password):
    from wordpress_xmlrpc import WordPressPage
    client = Client('http://www.weeklyosm.eu/xmlrpc.php', user, password)
    pages = client.call(posts.GetPosts({'post_type': 'page'}, results_class=WordPressPage))
    p = pages[0]
    print(p.id)
    print(p.title)

class BlogPost:
    
    def __init__(self,user,password):
        self.wp = Client("http://dataslant.xyz/xmlrpc.php",user,password)
    
    def postDraft(self, title, body):
        '''
        Creates a draft with title and graph
        
        Currently both title and graph are just strings
        '''
        post = WordPressPost()
        post.title = title
        post.content = body
#        post,terms_names = {
#            'post_tag': ['test'],
#            'category': ['testCat']}
        self.wp.call(NewPost(post))

    def uploadJPG(self, filePath):
        data = {
            'name': filePath.split('/')[-1],
            'type': 'image/jpeg',
            }
        
        with open(filePath, 'rb') as img:
            data['bits'] = xmlrpc_client.Binary(img.read())
        response = self.wp.call(media.UploadFile(data))
        return response['id']
        

    def get_blog_subscribers(self):
        """ Gets WordPress Blog Subscribers """
        config = SafeConfigParser()
        config.read(os.path.join(os.path.dirname(__file__), 'config.ini'))
        try:
            url = config.get("wordpress", "url")
            username = config.get("wordpress", "username")
            password = config.get("wordpress", "password")
        except Error as error:
            msg = "Config section [wordpress] bad or missing: %s" % \
                  error.message
            logging.error(msg)
            raise Exception(msg)

        subs = []

        wp = Client(url, username, password)
        users = wp.call(GetUsers())
        logging.info("Found %d users." % len(users))
        for u in users:
            logging.debug("User: %s" % u.email)
            logging.debug("Roles: %s" % u.roles)
            if 'subscriber' in u.roles:
                subs.append((u.email, u.first_name))
        return subs

def PushToWeb(courses):
    if not pushToWordPress:
        return
    client = Client(url,user,pw)
    pages = GetWebPages()

    for course in courses:
        print("pushing to web", course)
        try:
            page = pages[course]
            f = open("raw/%s.html" % (course,),"r")
            page.content = f.read()
            f.close()
        except IOError as ioe:
            print("** no raw file found for",course)
            print(ioe)
            continue
        except KeyError as keyx:
            print("** no course found on blog",course)
            print(keyx)
            continue

        result = client.call(posts.EditPost(page.id, page))
        if result:
            print("Successfully updated ", page.slug)
        else:
            print("******Warning********: could not update ", page.slug)

	def media_upload():
		print 'Media Upload'
		from wordpress_xmlrpc import Client, WordPressPost
		from wordpress_xmlrpc.compat import xmlrpc_client
		from wordpress_xmlrpc.methods import media, posts

		client = Client(xmlrpc_url, username, password)
		if len(param_list[2:]) == 0:
			print "Error: Please select Uploads file"
			sys.exit(0)
		else:
			for f in param_list[2:]:
				filepath = os.path.abspath(f)
				filename = os.path.basename(filepath.strip())
				dirname = os.path.dirname(filepath.strip())
			# prepare metadata
				data = {
			        'name': filename,
			        'type': mimetypes.guess_type(filename)[0]
				}
			# read the binary file and let the XMLRPC library encode it into base64
				with open(filepath.strip(), 'rb') as img:
			       		data['bits'] = xmlrpc_client.Binary(img.read())
				response = client.call(media.UploadFile(data))
				attachment_id = response['id']
				media_info = client.call(media.GetMediaItem(attachment_id))
				media_filename = os.path.basename(media_info.link.strip())
				print '==========================\n' + 'Attachment ID : ' + attachment_id + '\nFile name : ' + media_filename + '\nFile url : ' + media_info.link

def _post_to_wp(post):
    # Keep 3rd party calls separate
    client = Client(
        url=settings.XML_RPC_URL,
        username=settings.XML_RPC_USERNAME,
        password=settings.XML_RPC_PW
    )
    return client.call(post)

def upload(pic):
    (_ , ext) = os.path.splitext(pic)
    wp_client = Client(rpc_service_url, user, password)
    data = {'name':str(uuid4()) + ext, 'type':mimetypes.guess_type(pic)[0]}
    with open(pic, 'rb') as img:
        data['bits'] = xmlrpc_client.Binary(img.read())
    rsp = wp_client.call(media.UploadFile(data))
    return rsp

def wp_post(post_type, limit):
    from wordpress_xmlrpc import Client
    from wordpress_xmlrpc.methods import posts

    wp = Client('http://www.leedsdatamill.org/xmlrpc.php', 'USERNAME', 'PASSWORD')

    published_posts = wp.call(posts.GetPosts({'post_status': 'publish', 'number': limit, 'orderby': 'post_date', 'order': 'DESC', 'post_type': post_type }))
    return published_posts

def getWordpressPosts():
    allPosts = []
    try:
        wpClient = Client(app.config.get('BLOG_URL'), app.config.get('BLOG_USER'), app.config.get('BLOG_PASSWORD'))
        allPosts = wpClient.call(posts.GetPosts({'post_status': 'publish'}))
    except (ServerConnectionError, InvalidCredentialsError) as e:
        logging.warn(e.message)
    finally:
        return allPosts

class PublishPipeline(object):
    """
    use xmlprc of wordpress to synchronize via push
    """
    @classmethod
    def from_crawler(cls, crawler):
        return cls()
    def open_spider(self, spider):
        self.client = Client(os.getenv('SCRAPY_WP_RPCURL'),
                             os.getenv('SCRAPY_WP_USERNAME'),
                             os.getenv('SCRAPY_WP_PASSWORD'))
        pass
    def close_spider(self, spider):
        pass
    def process_item(self, item, spider):
        wp_filename = item.filename('wp')
        if os.path.exists(wp_filename):
            with open(wp_filename) as fh:
                post = pickle.load(fh)
                fh.close()
                # #
                # Here one might update or fix things
                if False:
                    post.terms_names = {
                        'category': [item['source_name'].title()],
                        'post_tag': get_place_post_tag_names(item['place'])
                    }
                    self.client.call(posts.EditPost(post.id, post))
                    pass
                pass
            pass
        else:
            post = WordPressPost()
            post.title = item['headline']
            try:
                post.content = item['body']
            except KeyError:
                return None
            try:
                item['place']
            except KeyError:
                item['place'] = ""
            post.terms_names = {
                'category': [item['source_name'].title()],
                'post_tag': get_place_post_tag_names(item['place'])
            }
            post.link = item['source_url']
            post.date = item['time']
            post.post_status = 'publish'
            post.id = self.client.call(posts.NewPost(post))
            with open(wp_filename, 'wb') as fh:
                pickle.dump(post, fh)
                fh.close()
            pass
        return item
        pass
    pass

def share_on_facebook(post_ids, access_token, page_id=PAGE_ID):
	graph = facebook.GraphAPI(access_token)
	client = Client('http://domain.com/xmlrpc.php','username','password')
	for post_id in post_ids:
		post = client.call(GetPost(post_id))
		link = post.link
		path = '/'+str(page_id)+'/feed'
		post = graph.request(path=path,post_args={'link':post.link})
		print post

def getWordpressPostById(id):
    wpPost = []
    try:
        wpClient = Client(app.config.get('BLOG_URL'), app.config.get('BLOG_USER'), app.config.get('BLOG_PASSWORD'))
        wpPost = wpClient.call(posts.GetPost(id))
    except (ServerConnectionError, InvalidCredentialsError) as e:
        logging.warn(e.message)
    finally:
        return wpPost

def getWordpressCategories():
    wpCats = []
    try:
        wpClient = Client(app.config.get('BLOG_URL'), app.config.get('BLOG_USER'), app.config.get('BLOG_PASSWORD'))
        wpCats = wpClient.call(taxonomies.GetTerms('category'))
    except (ServerConnectionError, InvalidCredentialsError) as e:
        logging.warn(e.message)
    finally:
        return wpCats

def get_categories(site_id):
    '''
    获取site_id的所有category
    :param site_id:
    :return:
    '''
    site = Site.objects.get(pk=site_id)
    client = Client(site.url + '/xmlrpc.php', site.username, site.password)
    categories = client.call(taxonomies.GetTerms('category'))
    return categories

def main():
    client = Client("http://jonathanlurie.fr/xmlrpc.php", "jonathanlurie", "jo.270185")

    allPosts = client.call(posts.GetPosts())

    for p in allPosts:
        try:
            print p
        except:
            None

 def __init__(self, user, password, archive, lfrom='pt', lto='pb'):
     client = Client('http://www.weeklyosm.eu/xmlrpc.php', user, password)
     post = client.call(posts.GetPost(archive))
     tagfrom = '[:%s]' % lfrom
     tagto = '[:%s]' % lto
     post.title = post.title.replace(tagfrom, tagto)
     post.content = post.content.replace(tagfrom, tagto)
     #print(post.title)
     #print(post.content)
     client.call(posts.EditPost(post.id, post))