legacyworkdatamanager.java

Eclipse RCP下编写的工作管理软件代码

package net.sf.util.persistence;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import net.sf.pim.model.psp.Work;
import net.sf.pim.model.psp.WorkList;
import net.sf.util.ConfigHelper;
import net.sf.util.StringUtil;

import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.NodeList;

/**
 * 数据描述层的功能实现
 */
public class LegacyWorkDataManager implements IDataManager {
	public LegacyWorkDataManager(Class dataClass) {
		// 不处理，默认为WorkList
	}

	/**
	 * 从NamedNodeMap中构造此对象
	 */
	private static Work instance(NamedNodeMap map) {
		Work work = new Work();
		try{
			work.setRq(StringUtil.decodeXml((map.getNamedItem("rq")).getNodeValue()));
			work.setWid(StringUtil.decodeXml((map.getNamedItem("wid")).getNodeValue()));
			work.setKssj(StringUtil.decodeXml((map.getNamedItem("kssj")).getNodeValue()));
			work.setJssj(StringUtil.decodeXml((map.getNamedItem("jssj")).getNodeValue()));
			work.setDdsj(StringUtil.decodeXml((map.getNamedItem("ddsj")).getNodeValue()));
			work.setGzsj(StringUtil.decodeXml((map.getNamedItem("gzsj")).getNodeValue()));
			work.setGzsm(StringUtil.decodeXml((map.getNamedItem("gzsm")).getNodeValue()));
			work.setBz(StringUtil.decodeXml((map.getNamedItem("bz")).getNodeValue()));
			work.setGzfl(StringUtil.decodeXml((map.getNamedItem("gzfl")).getNodeValue()));
			work.setXmz(StringUtil.decodeXml((map.getNamedItem("xmz")).getNodeValue()));
			work.setPlan(StringUtil.decodeXml((map.getNamedItem("plan")).getNodeValue()));
		}catch(Exception ex){
//			ex.printStackTrace();
		}
		return work;
	}

	// 导出工作
	public static boolean exportWork(WorkList workList, String fname) {
		boolean bRet = false;
		if (workList == null)
			return bRet;
		// 文件头和尾
		String head = "<?xml version=\"1.0\" encoding=\"gbk\"?>\n<?xml-stylesheet type=\"text/xsl\" href=\"mywork.xsl\" ?>\n<worklist ry=\""
				+ ConfigHelper.getRy() + "\" bm=\"" + ConfigHelper.getBm() + "\">\n";
		String tail = "</worklist>";
		try {
			FileWriter fo = new FileWriter(fname, false);
			fo.write(head);
			fo.write(workList.toXml());
			fo.write(tail);
			fo.close();
			bRet = true;
		} catch (Exception ex) {
			ex.printStackTrace();
		}
		return bRet;
	}

	// 导入工作
	public static List importWork(String[] fnames) {
		List al = new ArrayList();
		for (int i = 0; i < fnames.length; i++) {
			al.add(getWorkFromXml(fnames[i]));
		}
		return al;
	}

	// 依文件取工作记录
	public static WorkList getWorkFromXml(String fname) {
		ArrayList al = new ArrayList();
		String memo = "";
		Document doc = null;
		try {
			// 取DOM对象
			DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
			DocumentBuilder db = dbf.newDocumentBuilder();
			File file = new File(fname);
			doc = db.parse(file);
			// 遍历构造所需对象
			NodeList list = doc.getElementsByTagName("work");
			for (int i = 0; i < list.getLength(); i++) {
				// 取WORK元素
				al.add(instance(list.item(i).getAttributes()));
			}
			NodeList memoList = doc.getElementsByTagName("memo");
			if (memoList.getLength() == 1) {
				memo = StringUtil.decodeXml(memoList.item(0).getAttributes().getNamedItem("text").getNodeValue());
			}
		} catch (FileNotFoundException fe) {
			System.out.println("not found:" + fname);
		} catch (Exception ex) {
			ex.printStackTrace();
		}
		WorkList wl = new WorkList();
		wl.setWorks((Work[]) al.toArray(new Work[0]));
		wl.setMemo(memo);
		return wl;
	}

	// 过滤工作列表
	private static WorkList filter(List list, String key) {
		List al = new ArrayList();
		StringBuffer sb = new StringBuffer();
		for (Iterator iter = list.iterator(); iter.hasNext();) {
			WorkList wl = (WorkList) iter.next();
			Work[] works = wl.getWorks();
			for (int i = 0; i < works.length; i++) {
				if (fit(works[i], key)) {
					al.add(works[i]);
				}
			}
			if (fit(wl.getMemo(), key) && !StringUtil.isNull(wl.getMemo())) {
				sb.append("\n").append("===").append(wl.getFirstDay()).append("===\n").append(wl.getMemo());
			}
		}
		WorkList wlRet = new WorkList();
		wlRet.setWorks((Work[]) al.toArray(new Work[al.size()]));
		if (sb.length() > 1)
			sb.deleteCharAt(0);
		wlRet.setMemo(sb.toString());
		return wlRet;
	}

	// 搜索单一memo
	private static boolean fit(String memo, String key) {
		if (key.equals(""))
			return true;
		if (memo.indexOf(key) != -1) {
			return true;
		}
		return false;
	}

	// 搜索work
	private static boolean fit(Work work, String key) {
		if (key.equals(""))
			return true;
		if (work.getGzsm().indexOf(key) != -1) {
			return true;
		}
		if (work.getBz().indexOf(key) != -1) {
			return true;
		}
		if (work.getGzfl().indexOf(key) != -1) {
			return true;
		}
		if (work.getXmz().indexOf(key) != -1) {
			return true;
		}
		if (work.getPlan().indexOf(key) != -1){
			return true;
		}
		return false;
	}

	public IData readData(Serializable id) throws DataException {
		// 打开当天的xml文件，生成相应的对象，返回结果
		String fname = ConfigHelper.getDataHome() + "data/" + id + ".xml";
		return getWorkFromXml(fname);
	}

	public List readList() throws DataException {
		return null;
	}

	public List readList(String propertyName, Object propertyValue) throws DataException {
		String[] days = (String[]) propertyValue;
		if (days.length == 2) {
			return getRangeWork(days);
		} else if (days.length == 3) {
			List list = getRangeWork(new String[] { days[0], days[1] });
			return Arrays.asList(new Object[] { filter(list, days[2]) });
		}
		return new ArrayList();
	}

	private List getRangeWork(String[] days) {
		days = StringUtil.getDayRange(days[0], days[1]);
		Arrays.sort(days);
		// 将天转化为文件
		for (int i = 0; i < days.length; i++)
			days[i] = ConfigHelper.getDataHome() + "data/" + days[i] + ".xml";
		return LegacyWorkDataManager.importWork(days);
	}

	public Serializable createData(IData data) throws DataException {
		WorkList work = (WorkList) data;
		if (work == null || work.getFirstDay().equals(""))
			return "";
		// 输出文件名
		// 确保data目录存在
		File dir = new File(ConfigHelper.getDataHome() + "data");
		if (!dir.exists() || !dir.isDirectory())
			dir.mkdirs();
		String fname = ConfigHelper.getDataHome() + "data/" + work.getFirstDay() + ".xml";
		LegacyWorkDataManager.exportWork(work, fname);
		return work.getFirstDay();
	}

	public Serializable[] createList(List list) throws DataException {
		return null;
	}

	public void updateData(IData data) throws DataException {
	}

	public void updateList(List list) throws DataException {
	}

	public void deleteData(IData data) throws DataException {
	}

	public void deleteList(List list) throws DataException {
	}

	public List readList(Serializable id) throws DataException {
		throw new DataException("未实现此方法");
	}

	public Serializable[] createList(List list, Serializable id) throws DataException {
		throw new DataException("未实现此方法");
	}
}