package com.vci.client.oq.ui.qtimport;

import java.awt.Color;
import java.awt.event.MouseEvent;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import javax.swing.JTable;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreeNode;
import javax.swing.tree.TreePath;
import javax.swing.tree.TreeSelectionModel;

import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;

import com.vci.corba.omd.btm.BtmItem;
import com.vci.corba.omd.qtm.QTD;
import com.vci.corba.omd.qtm.QTInfo;
import com.vci.client.LogonApplication;
import com.vci.client.common.providers.ServiceProvider;
import com.vci.client.omd.btm.ui.BtmClient;
import com.vci.client.omd.provider.BtmProvider;
import com.vci.client.oq.QTClient;
import com.vci.client.oq.QTDClient;
import com.vci.client.oq.ui.export.QTExportBTMNode;
import com.vci.client.oq.ui.export.QTExportData;
import com.vci.client.oq.ui.export.QTExportQTNode;
import com.vci.client.portal.NewNewUI.Export.ExportTreeCellRenderer;
import com.vci.client.portal.NewNewUI.Export.VCIImportTree;
import com.vci.client.ui.swing.CheckBoxLabel;
import com.vci.client.ui.swing.VCIOptionPane;
import com.vci.client.ui.tree.CheckBoxTreeCellRenderer;
import com.vci.client.ui.tree.CheckBoxTreeManager;
import com.vci.corba.common.VCIError;

public class QTImportTree extends VCIImportTree {

	private static final long serialVersionUID = 1L;
	private CheckBoxTreeManager treeManager = null;
	// private BtmItem[] btmArray = null;
	// private QTInfo[] qts = null;
	private List<BtmItem> btmItemNew = new ArrayList<BtmItem>();
	private List<QTInfo> qTWrapperNew = new ArrayList<QTInfo>();
	private QTExportData qtExportData = null;
	HSSFWorkbook readworkbook;
	// private QTExportData qtExportDataNewData= null;
	private Map<String/* 类型名称 */, QTD[]/* 查询模板定义 */> norepQTDs = new HashMap<String, QTD[]>();

	public QTImportTree(DefaultTreeModel treeModel) {
		super(treeModel);
		// TODO Auto-generated constructor stub
	}

	public QTImportTree() {
		super(new DefaultTreeModel(new DefaultMutableTreeNode("业务类型")));
		this.setCellRenderer(new ExportTreeCellRenderer());
	}

	/**
	 * 
	 */
	public void init() {
		this.getSelectionModel().setSelectionMode(
				TreeSelectionModel.SINGLE_TREE_SELECTION);
		// 刷新分类树
		// this.getPathForRow(0).
		// initTree(this.getPathForRow(0));
		if (treeManager == null) {
			treeManager = new CheckBoxTreeManager(this);
		}
	}

	@Override
	public void initTree(String filePath) {
		// TODO Auto-generated method stub
		this.getSelectionModel().setSelectionMode(
				TreeSelectionModel.SINGLE_TREE_SELECTION);
		btmItemNew.clear();
		qTWrapperNew.clear();
		norepQTDs.clear();
		qtExportData = null;
		if (filePath != null && !filePath.equals("")) {
			try {
//				ObjectInputStream obj = new ObjectInputStream(
//						new FileInputStream(filePath));
				FileInputStream in = new FileInputStream(new File(filePath));
				QTExportData qdata = new QTExportData();
				readworkbook = new HSSFWorkbook(in);
				HSSFSheet sheet_QTD = readworkbook.getSheet("QTD");
				Map<String/*类型名称*/, QTD[]/*查询模板定义*/> allQTDs = new HashMap<String, QTD[]>();
				QTD[] qtArray = new QTD[sheet_QTD.getLastRowNum()];
				String qt_key = null;
				for (int i = 0; i < sheet_QTD.getLastRowNum(); i++) {
					HSSFRow readrow = sheet_QTD.getRow(i);
					if(readrow==null){
						break;
					}
					QTD qt = new QTD();
					HSSFCell cell = readrow.getCell(0);
					qt_key = cell.getStringCellValue();
					cell = readrow.getCell(1);
					qt.btmName=cell.getStringCellValue();
					cell = readrow.getCell(2);
					qt.createTime= Long.valueOf(cell.getStringCellValue());
					cell = readrow.getCell(3);
					qt.creator=cell.getStringCellValue();
					cell = readrow.getCell(4);
					qt.linkTypeName=cell.getStringCellValue();
					cell = readrow.getCell(5);
					qt.name=cell.getStringCellValue();
					cell = readrow.getCell(6);
					String abNamesArrays = cell.getStringCellValue();
					qt.abNames = abNamesArrays.split(abNamesArrays);
					qtArray[i]=qt;
				}
				allQTDs.put(qt_key, qtArray);
				
				HSSFSheet sheet_QTWrapper= readworkbook.getSheet("QTInfo");
				Map<String/*查询模板名称*/, QTInfo/*查询模板对象*/> allSelectedQTs = new HashMap<String, QTInfo>();
				for(int i=0;i<=sheet_QTWrapper.getLastRowNum();i++){
					HSSFRow readrow = sheet_QTWrapper.getRow(i);
					if(readrow==null){
						break;
					}
					QTInfo qtw = new QTInfo();
					HSSFCell cell = readrow.getCell(0);
					String key = cell.getStringCellValue();
					cell = readrow.getCell(1);
					qtw.btmName = cell.getStringCellValue();
					cell = readrow.getCell(2);
					qtw.createTime = Long.valueOf(cell.getStringCellValue());
					cell = readrow.getCell(3);
					qtw.creator = cell.getStringCellValue();
					cell = readrow.getCell(4);
					qtw.qtName = cell.getStringCellValue();
					cell = readrow.getCell(5);
					qtw.qtText = cell.getStringCellValue();
					cell = readrow.getCell(6);
					double numericCellValue = cell.getNumericCellValue();
					qtw.levelFlag = (short) numericCellValue;
					cell = readrow.getCell(7);
					qtw.qtUIText = cell.getStringCellValue();	
					allSelectedQTs.put(key, qtw);
				}
				qdata.setAllQTs(allSelectedQTs);
				
				HSSFSheet sheet_SelectedBtmAttrs= readworkbook.getSheet("SelectedBtmAttrs");
				Map<String/*类型名称*/,String[]/*类型所属属性*/> selectedBtmAttrs = new HashMap<String, String[]>();
				String btmAttrs_key = null;
				for(int i=0;i<=sheet_SelectedBtmAttrs.getLastRowNum();i++){
					HSSFRow readrow = sheet_SelectedBtmAttrs.getRow(i);
					if(readrow==null){
						break;
					}
					HSSFCell cell = readrow.getCell(0);
					btmAttrs_key = cell.getStringCellValue();
					cell = readrow.getCell(1);
					String stArrays = cell.getStringCellValue();
					String[] split = stArrays.split("#");
					selectedBtmAttrs.put(btmAttrs_key, split);
				}
				qdata.setSelectedBtmAttrs(selectedBtmAttrs);
				
				
				HSSFSheet sheet_SelectedBtmItems= readworkbook.getSheet("SelectedBtmItems");
				Map<String/*类型名称*/, BtmItem/*类型对象*/> selectedBtmItems = new HashMap<String, BtmItem>();
				String btmItem_key = null;
				for(int i=0;i<=sheet_SelectedBtmItems.getLastRowNum();i++){
					HSSFRow readrow = sheet_SelectedBtmItems.getRow(i);
					if(readrow==null){
						break;
					}
					HSSFCell cell = readrow.getCell(0);
					btmItem_key = cell.getStringCellValue();
					BtmItem item = new BtmItem();
					cell = readrow.getCell(1);
					item.createTime=Long.valueOf(cell.getStringCellValue());
					cell = readrow.getCell(2);
					item.creator=cell.getStringCellValue();
					cell = readrow.getCell(3);
					item.delimiter=cell.getStringCellValue();
					cell = readrow.getCell(4);
					item.description=cell.getStringCellValue();
					cell = readrow.getCell(5);
					item.fName=cell.getStringCellValue();
					cell = readrow.getCell(6);
					item.imageName=cell.getStringCellValue();
					cell = readrow.getCell(7);
					item.implClass=cell.getStringCellValue();
					cell = readrow.getCell(8);
					item.isAbstract = cell.getBooleanCellValue();//boolean
					cell = readrow.getCell(9);
					item.label=cell.getStringCellValue();
					cell = readrow.getCell(10);
					item.lifeCycle=cell.getStringCellValue();
					cell = readrow.getCell(11);
					item.modifier=cell.getStringCellValue();
					cell = readrow.getCell(12);
					item.modifyTime=Long.valueOf(cell.getStringCellValue());
					cell = readrow.getCell(13);
					item.name=cell.getStringCellValue();
					cell = readrow.getCell(14);
					item.oid = cell.getStringCellValue();
					cell = readrow.getCell(15);
					item.revInput=cell.getBooleanCellValue();
					cell = readrow.getCell(16);
					item.revRuleName=cell.getStringCellValue();
					cell = readrow.getCell(17);
					item.shape=cell.getStringCellValue();
					cell = readrow.getCell(18);
					item.ts=Long.valueOf(cell.getStringCellValue());
					cell = readrow.getCell(19);
					item.revLevel = (short)cell.getNumericCellValue();
					cell = readrow.getCell(20);
					item.verRuleName=(short)cell.getNumericCellValue();
					cell = readrow.getCell(21);
					String apname =cell.getStringCellValue();
					item.apNameArray = apname.split("#");
					cell = readrow.getCell(22);
					String lfCles =cell.getStringCellValue();
					item.lifeCycles=lfCles.split("#");
					selectedBtmItems.put(btmItem_key, item);
				}
				qdata.setSelectedBtmItems(selectedBtmItems);
//				this.qtExportData = (QTExportData) obj.readObject();
				this.qtExportData = qdata;
			} catch (Exception e) {
				VCIOptionPane
						.showMessage(LogonApplication.frame, "导入对象未获取成功！！");				
				e.printStackTrace();
			}
		}
		if(qtExportData == null){
			this.setModel(new DefaultTreeModel(new DefaultMutableTreeNode("业务类型")));
		}else{
			addImportData();
			BtmItem[] btmArray = (BtmItem[]) btmItemNew
					.toArray(new BtmItem[btmItemNew.size()]);
			QTInfo[] qts = (QTInfo[]) qTWrapperNew
					.toArray(new QTInfo[qTWrapperNew.size()]);
			this.setModel(new DefaultTreeModel(new DefaultMutableTreeNode("业务类型")));
			DefaultTreeModel dtml = (DefaultTreeModel) this.getModel();
			DefaultMutableTreeNode node = (DefaultMutableTreeNode) this
					.getPathForRow(0).getLastPathComponent();
			addExportTreeNode(dtml, node, btmArray, qts);
			// 展开所有树节点
			TreeNode rootNode = (TreeNode) this.getModel().getRoot();
			TreePath rootPath = new TreePath(rootNode);
			this.expandAllTreeNode(rootPath, true);			
		}
		//this.expandPath(rootPath);
		if (treeManager == null) {
			treeManager = new CheckBoxTreeManager(this){
				 public void mouseClicked(MouseEvent me){
	               //覆盖点击选择事件			
				 }
			};
		}else{
			TreePath[] paths = treeManager.getSelectionModel().getSelectionPaths();
			if(paths != null)
			treeManager.getSelectionModel().removeSelectionPaths(paths);
		}
		treeManager.getSelectionModel().setSelectionPath(new TreePath(this.getModel().getRoot()));
		
		CheckBoxTreeCellRenderer render = 	(CheckBoxTreeCellRenderer)this.getCellRenderer();
	    this.updateUI();
		for (int i = 0; i < render.getComponentCount(); i++) {
			if( render.getComponent(i).getClass().getName().equals("com.vci.base.ui.swing.CheckBoxLabel") ){
				CheckBoxLabel label	= (CheckBoxLabel)render.getComponent(i);
				label.setEnabled(false);
			}			
		}
		// this.setVisible(false);
	}

	public Map<String, QTD[]> getNorepQTDs() {
		return norepQTDs;
	}

	public void setNorepQTDs(Map<String, QTD[]> norepQTDs) {
		this.norepQTDs = norepQTDs;
	}

	// 加载树节点
	private void addExportTreeNode(DefaultTreeModel dtml,
			DefaultMutableTreeNode node, BtmItem[] allBtm, QTInfo[] qts) {
		// TODO Auto-generated method stub
		// node.removeAllChildren();
		String curBtmName = "";
		Object userObject = node.getUserObject();
		if (!(userObject instanceof String)) {
			// 业务类型对象节点
			if (userObject instanceof QTExportBTMNode) {
				BtmItem pac = ((QTExportBTMNode) userObject).getBean();
				curBtmName = pac.name; // 业务类型名称
//				for (BtmItem plac : allBtm) {
//					if (plac.fName.equals(curBtmName)) {
//						QTExportBTMNode qtExportBTMNode = new QTExportBTMNode(
//								plac);
//						if (plac.name.endsWith("@#业务类型已存在$%")) {
//							plac.name = plac.name.replace("@#业务类型已存在$%", "");
//							qtExportBTMNode.setMessage("【业务类型已存在，不导入】");
//						}
//						if (plac.name.endsWith("@#业务类型存在但属性不一致$%")) {
//							plac.name = plac.name.replace("@#业务类型存在但属性不一致$%",
//									"");
//							qtExportBTMNode.setMessage("【业务类型存在但属性不一致，不导入】");
//						}
//						if (plac.name.endsWith("@#业务类型不存在$%")) {
//							plac.name = plac.name.replace("@#业务类型不存在$%", "");
//							qtExportBTMNode.setMessage("【业务类型不存在，不导入】");
//						}
//						DefaultMutableTreeNode child = new DefaultMutableTreeNode(
//								qtExportBTMNode);
//						dtml.insertNodeInto(child, node, node.getChildCount());
//						addExportTreeNode(dtml, child, allBtm, qts);
//					}
//				}
				// 添加查询模板对象子节点
				for (QTInfo qtItem : qts) {
					if ((!curBtmName.equals(""))
							&& qtItem.btmName.equals(curBtmName)) {

						QTExportQTNode exportQTNode = new QTExportQTNode(qtItem);
						/* TreePath newChildTreePath = new TreePath(newChild); */
						if (qtItem.qtName.endsWith("@#查询模板已存在，不导入$%")) {
							qtItem.qtName = qtItem.qtName.replace(
									"@#查询模板已存在，不导入$%", "");
							exportQTNode.setMessage("【查询模板已存在，不导入】");

						}
						if (qtItem.qtName.endsWith("@#查询模板所属业务类型属性不一致，不导入$%")) {
							qtItem.qtName = qtItem.qtName.replace(
									"@#查询模板所属业务类型属性不一致，不导入$%", "");
							exportQTNode.setMessage("【查询模板所属业务类型属性不一致，不导入】");
							
						}
						if (qtItem.qtName.endsWith("@#查询模板所属业务类型不存在，不导入$%")) {
							qtItem.qtName = qtItem.qtName.replace(
									"@#查询模板所属业务类型不存在，不导入$%", "");
							exportQTNode.setMessage("【查询模板所属业务类型不存在，不导入】");
							
						}
						if (qtItem.qtName.endsWith("@#查询模板不存在，导入$%")) {
							qtItem.qtName = qtItem.qtName.replace(
									"@#查询模板不存在，导入$%", "");
							exportQTNode.setMessage("【查询模板不存在，可导入】");
							exportQTNode.setFontColor(Color.black);
						}
						DefaultMutableTreeNode newChild = new DefaultMutableTreeNode(
								exportQTNode);
						dtml.insertNodeInto(newChild, node,
								node.getChildCount());
					}
				}
			}
		} else {
			// 添加业务类型根节点
			for (BtmItem plAction : allBtm) {
//				if (plAction.fName.equals("")) {
					QTExportBTMNode qtExportBTMNode = new QTExportBTMNode(
							plAction);
					if (plAction.name.endsWith("@#业务类型已存在$%")) {
						plAction.name = plAction.name
								.replace("@#业务类型已存在$%", "");
						qtExportBTMNode.setMessage("【业务类型已存在，不导入】");
					}

					if (plAction.name.endsWith("@#业务类型存在但属性不一致$%")) {
						plAction.name = plAction.name.replace(
								"@#业务类型存在但属性不一致$%", "");
						qtExportBTMNode.setMessage("【业务类型存在但属性不一致，不导入】");
					}
					if (plAction.name.endsWith("@#业务类型不存在$%")) {
						plAction.name = plAction.name
								.replace("@#业务类型不存在$%", "");
						qtExportBTMNode.setMessage("【业务类型不存在，不导入】");
					}
					DefaultMutableTreeNode newChild = new DefaultMutableTreeNode(
							qtExportBTMNode);// , false
					dtml.insertNodeInto(newChild, node, node.getChildCount());
					addExportTreeNode(dtml, newChild, allBtm, qts);
//				}
			}
		}
		dtml.reload(node);
	}

	public CheckBoxTreeManager getTreeManager() {
		return treeManager;
	}

	public void setTreeManager(CheckBoxTreeManager treeManager) {
		this.treeManager = treeManager;
	}

	// 数据过滤
	private void addImportData() {
		// TODO Auto-generated method stub
		Map<String/* 类型名称 */, QTD[]/* 查询模板定义 */> allQTDs = this.qtExportData
				.getAllQTDs();
		Map<String/* 类型名称 */, BtmItem/* 类型对象 */> selectedBtmItems = this.qtExportData
				.getSelectedBtmItems();
		Map<String/* 类型名称 */, String[]/* 类型所属属性 */> selectedBtmAttrs = this.qtExportData
				.getSelectedBtmAttrs();
		Map<String/* 查询模板名称 */, QTInfo/* 查询模板对象 */> allSelectedQTs = this.qtExportData
				.getAllQTs();
		if (allQTDs.size() == 0 || allQTDs == null
				|| selectedBtmItems.size() == 0 || selectedBtmItems == null
				|| selectedBtmAttrs.size() == 0 || selectedBtmAttrs == null
				|| allSelectedQTs.size() == 0 || allSelectedQTs == null) {
			VCIOptionPane.showMessage(LogonApplication.frame, "导入的模板数据有误！！！");
			return;
		}
		Set<Entry<String, QTD[]>> pLActions = allQTDs.entrySet();
		Set<Entry<String, String[]>> pLAttrs = selectedBtmAttrs.entrySet();
		Set<Entry<String, QTInfo>> pLQts = allSelectedQTs.entrySet();
		Set<Entry<String, BtmItem>> pLBtm = selectedBtmItems.entrySet();
		for (Entry<String, QTD[]> entry : pLActions) {
			String string = entry.getKey();
			QTD[] qtds = entry.getValue();
			getPLQtIsInDB(string, qtds);
			// getPLQtBtmItem(string);
		}
		for (Entry<String, String[]> entry : pLAttrs) {
			String string = entry.getKey();
			String[] attrs = entry.getValue();
			for (Entry<String, BtmItem> entrya : pLBtm) {
				String strings = entrya.getKey();
				BtmItem btmItem = entrya.getValue();
				if(string.equals(strings)){					
					getPLQtBtmItem(string, attrs,btmItem);
				}
			}
		}
		for (Entry<String, QTInfo> entry : pLQts) {
			String string = entry.getKey();
			QTInfo qtWrapper = entry.getValue();
			getPLQtWrapper(string, qtWrapper);
		}

	}

	private void getPLQtWrapper(String string, QTInfo qtWrapper) {
		// TODO Auto-generated method stub
		try {
			QTInfo[] qtws = ServiceProvider.getOMDService().getQTDService().getAllQTs();
			boolean islaet = true;
			for (int i = 0; i < qtws.length; i++) {
				if (string.equals(qtws[i].qtName)) {
					islaet = false;
					for (BtmItem btmItem : btmItemNew) {
						if (qtWrapper.btmName.equals(btmItem.name.substring(0,
								btmItem.name.indexOf("@")))) {
							if (btmItem.name.endsWith("@#业务类型已存在$%")) {
								qtWrapper.qtName += "@#查询模板已存在，不导入$%";
								qTWrapperNew.add(qtWrapper);
							}else if(btmItem.name.endsWith("@#业务类型存在但属性不一致$%")){
								qtWrapper.qtName += "@#查询模板所属业务类型属性不一致，不导入$%";
								qTWrapperNew.add(qtWrapper);
							}else{
								qtWrapper.qtName += "@#查询模板所属业务类型不存在，不导入$%";
								qTWrapperNew.add(qtWrapper);
							}
						}
					}
//					qtws[i].qtName += "@#查询模板已存在，不导入$%";
//					qTWrapperNew.add(qtws[i]);					
				}
			}
			if (islaet) {
				for (BtmItem btmItem : btmItemNew) {
					if (qtWrapper.btmName.equals(btmItem.name.substring(0,
							btmItem.name.indexOf("@")))) {
						if (btmItem.name.endsWith("@#业务类型已存在$%")) {
							qtWrapper.qtName += "@#查询模板不存在，导入$%";
							qTWrapperNew.add(qtWrapper);
						}else if(btmItem.name.endsWith("@#业务类型存在但属性不一致$%")){
							qtWrapper.qtName += "@#查询模板所属业务类型属性不一致，不导入$%";
							qTWrapperNew.add(qtWrapper);
						}else{
							qtWrapper.qtName += "@#查询模板所属业务类型不存在，不导入$%";
							qTWrapperNew.add(qtWrapper);
						}
					}
				}
//				qtWrapper.qtName += "@#查询模板不存在，导入$%";
//				qTWrapperNew.add(qtWrapper);
			}
		} catch (VCIError e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

	private void getPLQtBtmItem(String string, String[] attrs, BtmItem btmItem2) {
		// TODO Auto-generated method stub
		try {
			// List<BtmItem> es = new ArrayList<BtmItem>();
			BtmItem[] btmArray = BtmClient.getService().getAllBtmItem("");
			String[] strings = BtmProvider.getInstance().getAbNames(string);
			boolean b = true;
			for (int i = 0; i < btmArray.length; i++) {
				if (btmArray[i].name.equals(string)) {
					b = false;
					//if (Arrays.equals(attrs, strings)) {
					if (isEqualsArray(attrs, strings)) {
						btmArray[i].name += "@#业务类型已存在$%";
						/* this.btmArray[i] = btmArray[i]; */
						btmItemNew.add(btmArray[i]);
					} else {
						btmArray[i].name += "@#业务类型存在但属性不一致$%";
						btmItemNew.add(btmArray[i]);
					}
				}
			}	
			if(b){
				btmItem2.name += "@#业务类型不存在$%";
				btmItemNew.add(btmItem2);
			}

		} catch (VCIError e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

	//Add by liupengfei 2015-09-22
	private static boolean isEqualsArray(String[] arr1, String[] arr2) {
		if ((arr1 == null) || (arr2 == null))
			return false;
		List<Boolean> list = new ArrayList<Boolean>();
		for (int i = 0; i < arr1.length; i++) {
			for (int j = 0; j < arr2.length; j++) {
				if(arr1[i].equals(arr2[j])){
					list.add(true);
				}
			}
		}
		if(list.size()==arr1.length&&arr1.length==arr2.length){
			return true;
		}
		return false;
	}
	
	private void getPLQtIsInDB(String string, QTD[] qtds) {
		// TODO Auto-generated method stub
		try {
			QTD[] qtds2 = ServiceProvider.getOMDService().getQTDService().getBizTypeQTDs(string);
			QTD[] qtdsNewQtds = null;
			List<QTD> es = new ArrayList<QTD>();
			for (QTD qtd : qtds) {
				boolean isleat = true;
				for (int i = 0; i < qtds2.length; i++) {
					if (qtd.name.equals(qtds2[i].name)) {
						isleat = false;
						break;
					}
				}
				if (isleat) {
					es.add(qtd);
				}
			}
			if (es.size() != 0) {
				qtdsNewQtds = (QTD[]) es.toArray(new QTD[es.size()]);
				norepQTDs.put(string, qtdsNewQtds);
			}
			// qtExportDataNewData.setAllQTDs(norepQTDs);
		} catch (VCIError e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	@Override
	public boolean hasSelectImportContent() {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public void exeImport(PrintWriter logFileWriter, JTable tblExportLog) {
		// TODO Auto-generated method stub

	}

	public String getExportDataFileName(String filePath, Long currentTimes) {
		// TODO Auto-generated method stub
		return filePath + File.separator + "VCIQTMODELFILE" + currentTimes
				+ ".log";
	}

}