var _gaq = _gaq || [];
_gaq.push(['_setAccount', 'UA-XXXXX-X']);
_gaq.push(['_trackPageview']);
 
(function() {
var ga = document.createElement('script');
ga.src = ('https:' == document.location.protocol ?
    'https://ssl' : 'http://www') +
    '.google-analytics.com/ga.js';
ga.setAttribute('async', 'true');
document.documentElement.firstChild.appendChild(ga);
})();

//类名：AJAX
//创建方法：var ajaxobj=new AJAX;，如果创建失败则返回false
//属性：method  -  请求方法，字符串，POST或者GET，默认为POST
//　　　url         -  请求URL，字符串，默认为空
//　　　async     -  是否异步，true为异步，false为同步，默认为true
//　　　content -  请求的内容，如果请求方法为POST需要设定此属性，默认为空
//　　　callback  - 回调函数，即返回响应内容时调用的函数，默认为直接返回，回调函数有一个参数为XMLHttpRequest对象，即定义回调函数时要这样：function mycallback(xmlobj)
//方法：send()     -  发送请求，无参数
 
function AJAXRequest() {
	var xmlObj = false;
	var CBfunc,ObjSelf;
	ObjSelf=this;
	try { xmlObj=new XMLHttpRequest; }
	catch(e) {
		try { xmlObj=new ActiveXObject("MSXML2.XMLHTTP"); }
		catch(e2) {
			try { xmlObj=new ActiveXObject("Microsoft.XMLHTTP"); }
			catch(e3) { xmlObj=false; }
		}
	}
	if (!xmlObj) return false;
	this.method="POST";
	this.url;
	this.async=true;
	this.content="";
	this.callback=function(cbobj) {return;}
	this.send=function() {
		if(!this.method||!this.url||!this.async) return false;
		xmlObj.open (this.method, this.url, this.async);
		if(this.method=="POST") xmlObj.setRequestHeader("Content-Type","application/x-www-form-urlencoded");
		xmlObj.onreadystatechange=function() {
			if(xmlObj.readyState==4) {
				if(xmlObj.status==200) {
					ObjSelf.callback(xmlObj);
				}
			}
		}
		if(this.method=="POST") xmlObj.send(this.content);
		else xmlObj.send(null);
	}
}

function deleteLogicCompany(logicCompanyid,userid,uName,cName){
	if(confirm( "你要删除分给 '"+uName+"' 的 '"+cName+"' 吗?\n\n        删除数据后,不可恢复,请注意!!!")){
		var ajaxobj=new AJAXRequest;    // 创建AJAX对象
		ajaxobj.method="POST";   // 设置请求方式为GET
		ajaxobj.url="../reportJsp/16ds/deleLogicCompany.jsp"  // 请求的URL
		ajaxobj.content = "logicCompanyid="+logicCompanyid+"&userid="+userid
		ajaxobj.callback=function(xmlobj) {
			var value = xmlobj.responseText;//这里返回的值要看你的请求返回什么东西了.
			var isRepeat = (value == '_yes');
 
			if( !isRepeat ){
				alert('数据已经删除');
				window.location.reload();
			}else{
				alert('数据删除失败');
			}
		}
 
	ajaxobj.send();    // 发送请求
	}
}

import java.net.URL;
import java.util.HashMap;
import java.util.Map;
 
import org.apache.xmlrpc.client.XmlRpcClient;
import org.apache.xmlrpc.client.XmlRpcClientConfigImpl;
 
public class Test {
	public static void post(String title, String content)  {
		try{
			// Set up XML-RPC connection to server
                        String domain = "www.extbi.com";//你网站的域名
			XmlRpcClientConfigImpl config = new XmlRpcClientConfigImpl();
			config.setServerURL(new URL("http://"+domain+"/xmlrpc.php"));
			XmlRpcClient client = new XmlRpcClient();
			client.setConfig(config);
 
			// Set up parameters required by newPost method
			Map post = new HashMap();
			post.put("title", title);//标题
			post.put("mt_keywords", "标签,标签2,标签3");//标签
			Object[] categories = new Object[] { "服饰","数码" };//分类
			post.put("categories", categories);
			post.put("description", content);//内容
			Object[] params = new Object[] { "1", "用户名", "密码", post,
					Boolean.TRUE };
 
			// Call newPost
			String result = (String) client.execute("metaWeblog.newPost", params);
			System.out.println(" Created with blogid " + result);
		}catch (Exception e) {
			// TODO: handle exception
                       System.out.println(" UnCreated ");
		}
	}
}

/**
	 * 给定一个列表url，得到本url对象的html,然后其它操作在这个基础上做
	 * @param url 
	 * @param encoding   返回html的编码方式，如GBK，UTF─8
	 * @return
	 * @throws Exception
	 */
	public String getHtml(String url, String encoding) throws Exception {
		String value = null;
		HttpClient httpclient = new DefaultHttpClient();        
        HttpGet httpget = new HttpGet(url);
 
        // 以下这条如果不加会发现无论你设置Accept-Charset为gbk还是utf-8，他都会默认返回gb2312（本例针对google.cn来说）
        httpget.setHeader("User-Agent", "Mozilla/5.0 (Windows; U; Windows NT 5.1; zh-CN; rv:1.9.1.2)");
        // 用逗号分隔显示可以同时接受多种编码
        httpget.setHeader("Accept-Language", "zh-cn,zh;q=0.5");
        httpget.setHeader("Accept-Charset", "GB2312,utf-8;q=0.7,*;q=0.7");        
        HttpResponse response = httpclient.execute(httpget);     
 
        // 判断页面返回状态判断是否进行转向抓取新链接
        int statusCode = response.getStatusLine().getStatusCode();
        if ((statusCode == HttpStatus.SC_MOVED_PERMANENTLY) ||
                (statusCode == HttpStatus.SC_MOVED_TEMPORARILY) ||
                (statusCode == HttpStatus.SC_SEE_OTHER) ||
                (statusCode == HttpStatus.SC_TEMPORARY_REDIRECT)) {
            // 此处重定向处理  此处还未验证
            String newUri = response.getLastHeader("Location").getValue();
            httpclient = new DefaultHttpClient();
            httpget = new HttpGet(newUri);
            response = httpclient.execute(httpget);
        }
 
        // Get hold of the response entity
        HttpEntity entity = response.getEntity();        
        // If the response does not enclose an entity, there is no need
        // to bother about connection release
        if (entity != null) {
            // 将源码流保存在一个byte数组当中，因为可能需要两次用到该流，
            byte[] bytes = EntityUtils.toByteArray(entity);
            // 如果头部Content-Type中包含了编码信息，那么我们可以直接在此处获取
 
            if(encoding != null && !"".equals(encoding.trim())){
            	value = new String(bytes, encoding);
            }else{
            	String charSet = EntityUtils.getContentCharSet(entity);
            	// 如果头部中没有，那么我们需要 查看页面源码，这个方法虽然不能说完全正确，因为有些粗糙的网页编码者没有在页面中写头部编码信息
	            if (charSet == null || "".equals(charSet.trim())) {
	                String regEx="(?=<meta).*?(?<=charset=[\\'|\\\"]?)([[a-z]|[A-Z]|[0-9]|-]*)";
	                Pattern p=Pattern.compile(regEx, Pattern.CASE_INSENSITIVE);
	                Matcher m=p.matcher(new String(bytes));  // 默认编码转成字符串，因为我们的匹配中无中文，所以串中可能的乱码对我们没有影响
	                boolean result=m.find();
	                if (m.groupCount() == 1) {
	                    charSet = m.group(1);
	                }
	            }
	            value = new String(bytes, charSet);
            }       
        }
 
        httpclient.getConnectionManager().shutdown();   
        return value;
    }

/**
	 * 列表区域识别规则
	 * @param html 原始的html
	 * @param areaRegex 所提取区域的正则表达式
	 * @param area 正则表达式中需要提取的区域，取值是：AREA_LIST，AREA_TITLE等等
	 * @return
	 */
	public String getArea(String html, String areaRegex ,String area) {
		String valueHtml=null;
		String regex = areaRegex.replaceFirst(area, "([\\\\s\\\\S]*?)");
//		System.out.println(regex);
		Pattern pattern = Pattern.compile(regex,Pattern.MULTILINE); 
		Matcher matcher = pattern.matcher(html); 
		while(matcher.find()) {
			valueHtml = matcher.group(1).trim();
			break;
		} 
		return valueHtml;
	}

       //提取给定区域的文章列表地址,
       public List<String> getListUrl(String areaHtml,String regex,String withPrefix){
		return this.getListUrl(areaHtml, regex, withPrefix, false, null);
	}
 
	/**
	 * 提取给定区域的文章列表地址，主要用来提取文章内的分页用的
	 * @param areaHtml 
	 * @param regex 
	 * @param withPrefix 返回的地址是否需要加一个前缀，如21cn的新闻，提取到后是没有前缀的，得加一个
	 * @param hasOmit  提取文章内分页时，是否有分页是否有省略号，如淘宝的就有。
	 * @param pageNumRegex  提取文章内的分页正则表达式
	 * @return
	 */
	public List<String> getListUrl(String areaHtml,String regex,String withPrefix,boolean hasOmit,String pageNumRegex){
		List<String> list = new ArrayList<String>();
		regex = regex.replaceFirst(WebContent.AREA_URL, "(.*?)");
		Pattern pa = Pattern.compile(regex, Pattern.MULTILINE);
		Matcher ma = pa.matcher(areaHtml);
		while (ma.find()) {
			if(withPrefix !=null && !"".equals(withPrefix.trim())){
				list.add(withPrefix+ma.group(1).trim());
			}else{
				list.add(ma.group(1).trim());
			}
		}
 
		if(hasOmit && list.size()>1){
			String lasturl = list.get(list.size()-1);
			list.clear(); 
			regex = "(.*?)"+pageNumRegex.replaceFirst(WebContent.PAGE_URL_NUM, "(-?\\\\d+)");			
			pa = Pattern.compile(regex);
			ma = pa.matcher(lasturl);
			if(ma.find()){
				int num = Integer.parseInt(ma.group(2));
				String prefix = ma.group(1).trim();
				String baseurl = prefix+pageNumRegex;
 
				for(int i = 2; i <= num; i ++)
				list.add(baseurl.replaceFirst(WebContent.PAGE_URL_NUM, i+""));
			}			
		}
 
		return list;
	}

#office_open_xml.rb
require 'zipruby'
require 'nokogiri'
 
class OfficeOpenXml  
  def initialize(template,newdoc)
    #Store the instance variables
    @template, @newdoc = template, newdoc
  end  
 
  def parse()
    existing_xml = get_xml_from_template()
    body_node = existing_xml.root.xpath("w:body", {"w" => "http://schemas.openxmlformats.org/wordprocessingml/2006/main"}).first
    #修改文件操作
    body_node.xpath("//w:r//w:t").each do |child|
      child.content = child.content.gsub("{name}", "replace string")
    end    
 
   compress(existing_xml)
  end
 
  #解压文件
  def get_xml_from_template()
    filename = 'word/document.xml';
    #retrieve the document from the template doc
    xml = Zip::Archive.open(@template) do |zipfile|
      zipfile.fopen(filename).read
    end
    #parse the resulting file into the Nokogiri xml doc
    Nokogiri::XML.parse(xml)
  end
 
  #把修改过的文件重新生成docx
  def compress(newXML)
    #Copy the template to the new document
    FileUtils.copy(@template, @newdoc)
    #Open the zip archive
    Zip::Archive.open(@newdoc, Zip::CREATE) do |zipfile|
      #Replace the document.xml with our new xml
      zipfile.add_or_replace_buffer('word/document.xml', newXML.to_s)
    end
  end  
end

#office_controller.rb
class OfficeController < ApplicationController
 
  def index
    office = OfficeOpenXml.new("#{RAILS_ROOT}/public/template/test.docx","#{RAILS_ROOT}/public/template/test333.docx")
    render :text => office.parse()
  end  
end