package cn.net.connor.ld.plm;

import java.awt.Component;
import java.awt.Dimension;
import java.awt.GridBagConstraints;
import java.awt.Window;
import java.io.BufferedWriter;
import java.io.EOFException;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.time.Instant;
import java.time.LocalDate;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JDialog;
import javax.swing.JFileChooser;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.filechooser.FileNameExtensionFilter;
import javax.swing.filechooser.FileSystemView;

import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.ss.usermodel.WorkbookFactory;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Shell;

import com.net.connor.ld.plm.ld06.ControlBean;
import com.teamcenter.rac.aif.commands.open.OpenCommand;
import com.teamcenter.rac.aif.kernel.AIFComponentContext;
import com.teamcenter.rac.aif.kernel.InterfaceAIFComponent;
import com.teamcenter.rac.aifrcp.AIFUtility;
import com.teamcenter.rac.common.lov.view.components.LOVDisplayer;
import com.teamcenter.rac.kernel.ListOfValuesInfo;
import com.teamcenter.rac.kernel.TCComponent;
import com.teamcenter.rac.kernel.TCComponentContextList;
import com.teamcenter.rac.kernel.TCComponentDataset;
import com.teamcenter.rac.kernel.TCComponentDatasetType;
import com.teamcenter.rac.kernel.TCComponentFolder;
import com.teamcenter.rac.kernel.TCComponentForm;
import com.teamcenter.rac.kernel.TCComponentGroup;
import com.teamcenter.rac.kernel.TCComponentGroupMember;
import com.teamcenter.rac.kernel.TCComponentItem;
import com.teamcenter.rac.kernel.TCComponentItemRevision;
import com.teamcenter.rac.kernel.TCComponentItemRevisionType;
import com.teamcenter.rac.kernel.TCComponentItemType;
import com.teamcenter.rac.kernel.TCComponentListOfValues;
import com.teamcenter.rac.kernel.TCComponentListOfValuesType;
import com.teamcenter.rac.kernel.TCComponentManager;
import com.teamcenter.rac.kernel.TCComponentQuery;
import com.teamcenter.rac.kernel.TCComponentQueryType;
import com.teamcenter.rac.kernel.TCComponentRole;
import com.teamcenter.rac.kernel.TCComponentSchedule;
import com.teamcenter.rac.kernel.TCComponentScheduleDeliverable;
import com.teamcenter.rac.kernel.TCComponentTCCalendar;
import com.teamcenter.rac.kernel.TCComponentTaskDeliverable;
import com.teamcenter.rac.kernel.TCComponentType;
import com.teamcenter.rac.kernel.TCComponentUser;
import com.teamcenter.rac.kernel.TCException;
import com.teamcenter.rac.kernel.TCProperty;
import com.teamcenter.rac.kernel.TCPropertyDescriptor;
import com.teamcenter.rac.kernel.TCSession;
import com.teamcenter.rac.kernel.TCTextService;
import com.teamcenter.rac.kernel.TCUserService;
import com.teamcenter.rac.schedule.calendar.TCCalendar;
import com.teamcenter.rac.schedule.componentutils.CalendarHelper;
import com.teamcenter.rac.ui.common.RACUIUtil;
import com.teamcenter.rac.util.MessageBox;
import com.teamcenter.rac.util.Registry;
import com.teamcenter.rac.util.UIUtilities;
import com.teamcenter.services.rac.core.DataManagementService;
import com.teamcenter.services.rac.core.LOVService;
import com.teamcenter.services.rac.core._2006_03.DataManagement.Relationship;
import com.teamcenter.services.rac.core._2007_01.DataManagement.WhereReferencedInfo;
import com.teamcenter.services.rac.core._2007_01.DataManagement.WhereReferencedOutput;
import com.teamcenter.services.rac.core._2007_01.DataManagement.WhereReferencedResponse;
import com.teamcenter.services.rac.core._2008_06.DataManagement.CreateIn;
import com.teamcenter.services.rac.core._2008_06.DataManagement.CreateInput;
import com.teamcenter.services.rac.core._2008_06.DataManagement.CreateOut;
import com.teamcenter.services.rac.core._2008_06.DataManagement.CreateResponse;
import com.teamcenter.services.rac.core._2013_05.LOV.InitialLovData;
import com.teamcenter.services.rac.core._2013_05.LOV.LOVSearchResults;
import com.teamcenter.services.rac.core._2013_05.LOV.LOVValueRow;
import com.teamcenter.services.rac.core._2013_05.LOV.LovFilterData;
import com.teamcenter.soa.client.model.LovValue;
import com.teamcenter.soa.client.model.ServiceData;

@SuppressWarnings("deprecation")
public class KUtil {

	public static final TCSession session;
	public static final TCTextService textService;
//	public static final Registry REG = Registry.getRegistry(KUtil.class);
	public static final ZoneId zoneId = ZoneId.systemDefault();
//	public static final Registry reg = Registry.getRegistry(KUtil.class);

//	public static String getRegString(String title) {
//		String res = reg.getString(title);
//		if (KUtil.isEmpty(res)) {
//			return title;
//		}
//		return res;
//	}

	static {
		session = (TCSession) AIFUtility.getCurrentApplication().getSession();
		textService = session.getTextService();
	}

	public static void setTCPropertyValue(TCComponent item, String propertyName, Object value) {
		try {
			TCProperty tcProperty = item.getTCProperty(propertyName);
			switch (tcProperty.getPropertyType()) {
			case TCProperty.PROP_double:
				if (value instanceof Double) {
					tcProperty.setDoubleValue((double) value);
				} else {
					tcProperty.setDoubleValue(Double.parseDouble(value.toString()));
				}
				break;
			case TCProperty.PROP_int:
				if (value instanceof Integer) {
					tcProperty.setDoubleValue((int) value);
				} else {
					tcProperty.setDoubleValue(Integer.parseInt(value.toString()));
				}
				break;
			case TCProperty.PROP_string:
				tcProperty.setStringValue(value.toString());
				break;
			case TCProperty.PROP_date:
				if (value instanceof Date) {
					tcProperty.setDateValue((Date) value);
				} else {
					SimpleDateFormat sdf = new SimpleDateFormat("yyyy-M-dd HH:mm");
					tcProperty.setDateValue(sdf.parse(value.toString()));
				}
				break;
			default:
				break;
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static Object getTCPropertyValue(TCComponent item, String propertyName) {
		Object result = "";
		try {
			TCProperty tcProperty = item.getTCProperty(propertyName);
			if (tcProperty == null) {
				System.out.println("未获取属性：" + propertyName);
				return result;
			}
			switch (tcProperty.getPropertyType()) {
			case TCProperty.PROP_double:
				result = tcProperty.getDoubleValue();
				break;
			case TCProperty.PROP_int:
				result = tcProperty.getIntValue();
				break;
			case TCProperty.PROP_string:
				result = tcProperty.getStringValue();
				break;
			case TCProperty.PROP_date:
				result = tcProperty.getDateValue();
				break;
			case TCProperty.PROP_logical:
				result = tcProperty.getLogicalValue();
				break;
			default:
				break;
			}
		} catch (TCException e) {
			e.printStackTrace();
		}
		return result;
	}

	public static String getCellValue(Cell c) {
		if (c == null) {
			return "";
		}
		String value = "";
		if (c.getCellType() == CellType.NUMERIC.getCode()) {
			DecimalFormat df = new DecimalFormat("0");
			String whatYourWant = df.format(c.getNumericCellValue());
			return whatYourWant;
		}
		switch (c.getCellType()) {
		case HSSFCell.CELL_TYPE_NUMERIC:// 数字
			value = (c.getNumericCellValue() + "").split("\\.")[0];
			break;
		case HSSFCell.CELL_TYPE_STRING:// 字符串
			value = c.getStringCellValue();
			break;
		case HSSFCell.CELL_TYPE_BOOLEAN:// boolean
			value = c.getBooleanCellValue() + "";
			break;
		case HSSFCell.CELL_TYPE_FORMULA:// 公式
			value = c.getCellFormula() + "";
			break;
		case HSSFCell.CELL_TYPE_BLANK:// 空值
			value = "";
			break;
		case HSSFCell.CELL_TYPE_ERROR:
			value = "非法字符";
			break;
		default:
			value = "未知类型";
			break;
		}
		return value;
	}

	/**
	 * 用来得到真实行数
	 * 
	 * @param sheet
	 * @param flag  需要写进数据库的Excel单元格列索引，多列用逗号隔开 比如Excel有5列单元格，其中4列
	 *              需要入库，第2列不需要入库，这里flag就传 [0,2,3,4]
	 * @return
	 * @throws Exception
	 * 
	 */
	public static int findRealRows(Sheet sheet, int... flag) throws Exception {
		int row_real = 0;
		int rows = sheet.getPhysicalNumberOfRows();// 此处物理行数统计有错误,
		try {

			for (int i = 1; i < rows; i++) {
				Row row = sheet.getRow(i);
				int total = 0;
				ArrayList<Integer> blank = new ArrayList<Integer>();
				int type = -1;
				String s = null;
				for (int j : flag) {
					if (!(row.getCell(j) == null) && row.getCell(j).getCellType() < 2) {
						type = row.getCell(j).getCellType();
						row.getCell(j).setCellType(1);
					}

					if (row.getCell(j) == null || row.getCell(j).getStringCellValue().matches("^\\s+$")
							|| row.getCell(j).getCellType() > 2) {
						total++;

						if (!(row.getCell(j) == null) && row.getCell(j).getCellType() < 2) {
							row.getCell(j).setCellType(type);
						}
						blank.add(j);

					}
				}
				System.out.println(s + "我");
				// 如果4列都是空说明就该返回
				if (total == flag.length) {

					return row_real;
				} else if (total == 0) {
					row_real++;

				} else {
					String h = "";
					for (Integer b : blank) {

						h = h + "第" + (b + 1) + "列" + " ";
					}
					throw new Exception("第" + (i + 1) + "行" + h + "不能为空");
				}

			}
		} catch (NullPointerException e) {
			throw new Exception("excel格式异常,请检查excel格式有无数据缺失,无效数据行!");
		}
		return row_real;
	}

	public static Workbook getWorkbook(File file) throws Exception {
		Workbook workbook = null;
		FileInputStream in = new FileInputStream(file);
		if (file.getName().endsWith("xlsx")) {
			System.out.println("读取模板:" + file.getName());
			try {
				workbook = WorkbookFactory.create(in);
			} catch (EOFException e) {
				e.printStackTrace();
			}
//			workbook = new XSSFWorkbook(in);
		} else {
			System.out.println("格式错误");
		}
		in.close();
		return workbook;
	}

	public static void removeEnd(StringBuilder sb, int len) {
		if (sb == null || len <= 0) {
			return;
		}
		if (sb.length() >= len) {
			sb.setLength(sb.length() - len);
		}
	}

	public static TCComponent[] getComponentsByItemType(TCComponent comp, String type, String relation)
			throws TCException {
		TCComponent[] comps1 = comp.getRelatedComponents(relation);
		if (comps1 == null || comps1.length < 1) {
			return null;
		}
		ArrayList<TCComponent> list = new ArrayList<TCComponent>();
		for (TCComponent comp1 : comps1) {
			if (comp1.getType().equals(type)) {
				list.add(comp1);
			}
		}
		return list.toArray(new TCComponent[] {});
	}

	public static TCComponentContextList objectsInProject(String type, String projId) throws Exception {
		if (KUtil.isEmpty(type) || KUtil.isEmpty(projId)) {
			return null;
		}
		String queryName = "Objects in Projects";
		String[] keys = new String[] { KUtil.getText("Type"), KUtil.getText("ProjectID") };
		String[] vals = new String[] { type, projId };
		return KUtil.query(KUtil.session, queryName, keys, vals);
	}

	public static TCComponentContextList objectsInProject(String type, String projId, String name) throws Exception {
		if (KUtil.isEmpty(type) || KUtil.isEmpty(projId) || KUtil.isEmpty(name)) {
			return null;
		}
		String queryName = "Objects in Projects";
		String[] keys = new String[] { KUtil.getText("Name"), KUtil.getText("Type"), KUtil.getText("ProjectID") };
		String[] vals = new String[] { name, type, projId };
		return KUtil.query(KUtil.session, queryName, keys, vals);
	}

	public static boolean checkGMPrivilegeFromPref(String prefName) throws Exception {
		boolean validityCanEdit = false;
		String validRoles = KUtil.getPrefVal(KUtil.session, prefName);
		System.out.println(">> Check GroupMember Priv: " + validRoles);
		if (!KUtil.isEmpty(validRoles)) {
			List<String> groups = new ArrayList<String>();
			List<String> roles = new ArrayList<String>();
			String[] split = validRoles.split(":");
			for (String string : split) {
				if (string.startsWith("G.")) {
					groups.add(string.substring(2));
				} else if (string.startsWith("R.")) {
					roles.add(string.substring(2));
				}
			}
			TCComponentUser currentUser = KUtil.session.getUser();
			System.out.println(">> Current User: " + currentUser);
			TCComponentGroupMember[] gms = currentUser.getGroupMembers();
			System.out.println(">> Current GroupMembers: " + Arrays.toString(gms));
			int len = KUtil.getLen(gms);
			for (int i = 0; i < len; i++) {
				TCComponentGroupMember gm = gms[i];
				TCComponentGroup g = gm.getGroup();
				TCComponentRole r = gm.getRole();
				String gName = g.getGroupName();
				String rName = r.getRoleName();
				System.out.println((i + 1) + ". " + gName + " - " + rName);
				if (groups.contains(gName) && roles.contains(rName)) {
					validityCanEdit = true;
					// break;
				}
			}
		}
		return validityCanEdit;
	}

	public static boolean compare(String str1, String str2) {
		if (str1 == null) {
			str1 = "";
		}
		if (str2 == null) {
			str2 = "";
		}
		return str1.equals(str2);
	}

	public static boolean compare(Object str1, Object str2) {
		if (str1 == null) {
			return str2 == null;
		}
		return str1.equals(str2);
	}

	public static TCComponentItem createItem(TCComponentItemType itemType, String itemName) throws Exception {
		if (itemType == null) {
			return null;
		}
		String id = itemType.getNewID();
		String rev = itemType.getNewRev(null);
		return itemType.create(id, rev, itemType.getName(), itemName, "", null);
	}

	public static void setByPass(boolean val) {
		try {
			TCUserService userservice = session.getUserService();
			userservice.call(val ? "CONNOR_open_bypass" : "CONNOR_close_bypass", new Object[] { "" });
			System.out.println(val ? "Open Bypass" : "Close Bypass");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static TCComponentItem createItemBySOA(String itemTypeName, String revTypeName, String revMasterTypeName,
			String itemId, String revId, String name, Map<String, String> stringProps, Map<String, Calendar> dateProps)
			throws Exception {
		if (KUtil.isEmpty(itemTypeName) || KUtil.isEmpty(revTypeName) || KUtil.isEmpty(revMasterTypeName)) {
			return null;
		}
		CreateInput revMasterInput = new CreateInput();
		revMasterInput.boName = revMasterTypeName;
		if (stringProps != null) {
			revMasterInput.stringProps = stringProps;
		}
		if (dateProps != null) {
			revMasterInput.dateProps = dateProps;
		}
		CreateInput revInput = new CreateInput();
		revInput.boName = revTypeName;
		Map<String, String> revPropMap = new HashMap<>();
		if (!KUtil.isEmpty(revId)) {
			revPropMap.put("item_revision_id", revId);
		}
		revInput.stringProps = revPropMap;
		Map<String, CreateInput[]> revMasterInfoMap = new HashMap<>();
		revMasterInfoMap.put("IMAN_master_form_rev", new CreateInput[] { revMasterInput });
		revInput.compoundCreateInput = revMasterInfoMap;
		// create rev
		CreateInput itemInput = new CreateInput();
		itemInput.boName = itemTypeName;
		Map<String, String> itemPropMap = new HashMap<>();
		if (!KUtil.isEmpty(itemId)) {
			itemPropMap.put("item_id", itemId);
		}
		if (!KUtil.isEmpty(name)) {
			itemPropMap.put("object_name", name);
		}
		itemInput.stringProps = itemPropMap;
		Map<String, CreateInput[]> revInfoMap = new HashMap<>();
		revInfoMap.put("revision", new CreateInput[] { revInput });
		itemInput.compoundCreateInput = revInfoMap;
		// create info
		CreateIn cI = new CreateIn();
		cI.clientId = "CreateItem";
		cI.data = itemInput;
		// service
		DataManagementService service = DataManagementService.getService(session);
		// create
		CreateResponse resp = service.createObjects(new CreateIn[] { cI });
		throwServiceDataError(resp.serviceData);
		CreateOut[] cOs = resp.output;
		if (cOs.length > 0) {
			for (TCComponent s : cOs[0].objects) {
				if (s instanceof TCComponentItem) {
					return (TCComponentItem) s;
				}
			}
		}
		return null;
	}

	public static TCComponentFolder createFolderBySOA(String folderTypeName, String folderName) throws Exception {
		if (KUtil.isEmpty(folderTypeName)) {
			return null;
		}
		CreateInput itemInput = new CreateInput();
		itemInput.boName = folderTypeName;
		Map<String, String> itemPropMap = new HashMap<>();
		itemPropMap.put("object_name", folderName);
		itemInput.stringProps = itemPropMap;
		// create info
		CreateIn cI = new CreateIn();
		cI.clientId = "CreateFolder";
		cI.data = itemInput;
		// service
		DataManagementService service = DataManagementService.getService(session);
		// create
		CreateResponse resp = service.createObjects(new CreateIn[] { cI });
		throwServiceDataError(resp.serviceData);
		CreateOut[] cOs = resp.output;
		if (cOs.length > 0) {
			for (TCComponent s : cOs[0].objects) {
				if (s instanceof TCComponentFolder) {
					return (TCComponentFolder) s;
				}
			}
		}
		return null;
	}

	public static void throwServiceDataError(ServiceData serviceData) throws Exception {
		if (serviceData.sizeOfPartialErrors() > 0) {
			StringBuilder errInfo = new StringBuilder();
			for (int i = 0; i < serviceData.sizeOfPartialErrors(); i++) {
				for (String msg : serviceData.getPartialError(i).getMessages()) {
					errInfo.append(msg + "\n");
				}
			}
			// System.out.println(errInfo.toString());
			throw new Exception(errInfo.toString());
		}
	}

	public static void throwServiceDataError(ServiceData serviceData, String defaultErrorMsg) throws Exception {
		if (serviceData.sizeOfPartialErrors() > 0) {
			StringBuilder errInfo = new StringBuilder();
			for (int i = 0; i < serviceData.sizeOfPartialErrors(); i++) {
				for (String msg : serviceData.getPartialError(i).getMessages()) {
					errInfo.append(msg + "\n");
				}
			}
			// System.out.println(errInfo.toString());
			if (KUtil.isEmpty(errInfo.toString())) {
				throw new Exception(defaultErrorMsg);
			}
			throw new Exception(errInfo.toString());
		}
	}

	public static Date localDateToDate(LocalDate localDate) {
		if (localDate == null) {
			return null;
		}
		ZonedDateTime zdt = localDate.atStartOfDay(zoneId);
		Date date = Date.from(zdt.toInstant());
		return date;
	}

	public static LocalDate dateToLocalDate(Date date) {
		if (date == null) {
			return null;
		}
		Instant instant = date.toInstant();
		LocalDate localDate = instant.atZone(zoneId).toLocalDate();
		return localDate;
	}

	public static TCComponent stringToComponent(String uid) throws Exception {
		if (KUtil.isEmpty(uid)) {
			return null;
		}
		return session.stringToComponent(uid);
	}

	public static String getText(String str) throws Exception {
		if (KUtil.isEmpty(str)) {
			return str;
		}
		String res = textService.getTextValue(str);
		if (!KUtil.isEmpty(res)) {
			return res;
		}
		return str;
	}

	public static void sendTo(TCComponent comp, String perspectiveId) {
		if (comp == null) {
			return;
		}
		if (KUtil.isEmpty(perspectiveId)) {
			perspectiveId = "com.teamcenter.rac.ui.perspectives.navigatorPerspective";
		}
		com.teamcenter.rac.common.Activator.getDefault().openPerspective(perspectiveId);
		com.teamcenter.rac.common.Activator.getDefault().openComponents(perspectiveId, new TCComponent[] { comp });
	}

	public static void open(TCComponent comp) {
		if (comp == null) {
			return;
		}
		if (comp instanceof TCComponentScheduleDeliverable) {
			System.out.println(">> Open Schedule Deliverable: " + comp);
			try {
				comp = comp.getReferenceProperty("deliverable_inst");
				System.out.println(">> Open Schedule Deliverable Inst: " + comp);
				if (comp == null) {
					return;
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		} else if (comp instanceof TCComponentTaskDeliverable) {
			System.out.println(">> Open Task Deliverable: " + comp);
			try {
				comp = comp.getReferenceProperty("fnd0DeliverableInstance");
				System.out.println(">> Open Task Deliverable Inst: " + comp);
				if (comp == null) {
					return;
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		try {
			Registry localRegistry = Registry.getRegistry("com.teamcenter.rac.commands.open.open");
			OpenCommand localOpenCommand = (OpenCommand) localRegistry.newInstanceForEx("openCommand",
					new Object[] { AIFUtility.getActiveDesktop(), comp });
			localOpenCommand.executeModeless();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static JButton getImageBtn(String iconName) {
		ImageIcon icon = new ImageIcon(KUtil.class.getResource("/icons/" + iconName));
		JButton btn = new JButton(icon);
		btn.setPreferredSize(new Dimension(26, 26));
		btn.setContentAreaFilled(true);
		btn.setFocusPainted(false);
		btn.setBorderPainted(true);
		// btn.setCursor(new Cursor(Cursor.DEFAULT_CURSOR));
		return btn;
	}

	public static void info(Window dialog, String msg) {
		MessageBox.post(dialog, msg, "", MessageBox.INFORMATION);
	}

	public static void warn(Window dialog, String msg) {
		MessageBox.post(dialog, msg, "", MessageBox.WARNING);
	}

	public static void error(Window dialog, String msg) {
		MessageBox.post(dialog, msg, "", MessageBox.ERROR);
	}

	public static void error(Window dialog, String msg, String title) {
		MessageBox.post(dialog, msg, title, MessageBox.ERROR);
	}

	public static void showScrollDialog(Window dialog, String text, String title) {
		if (dialog == null) {
			dialog = UIUtilities.getCurrentModalDialog();
		}
		JTextArea textArea = new JTextArea(text);
		textArea.setEditable(false);
		JScrollPane scrollPane = new JScrollPane(textArea);
		textArea.setLineWrap(true);
		textArea.setWrapStyleWord(true);
		scrollPane.setPreferredSize(new Dimension(500, 300));
		JOptionPane.showMessageDialog(dialog, scrollPane, title, JOptionPane.INFORMATION_MESSAGE);
	}

	public static void showScrollDialogWithExport(Window dialog, String text, String title, String exportFileName) {
		if (dialog == null) {
			dialog = UIUtilities.getCurrentModalDialog();
		}
		JTextArea textArea = new JTextArea(text);
		textArea.setEditable(false);
		JScrollPane scrollPane = new JScrollPane(textArea);
		textArea.setLineWrap(true);
		textArea.setWrapStyleWord(true);
		scrollPane.setPreferredSize(new Dimension(500, 300));
		String yesOption = KLocale.getString("ok");
		String exportOption = KLocale.getString("export");
		int op = JOptionPane.showOptionDialog(dialog, scrollPane, title, JOptionPane.YES_NO_OPTION,
				JOptionPane.INFORMATION_MESSAGE, null, new String[] { yesOption, exportOption }, yesOption);
		if (op == 1) {
			System.out.println("Export");
			File saveFile = KUtil.chooseSaveFile(dialog, exportFileName, "txt");
			if (saveFile != null) {
				try {
					BufferedWriter writer = new BufferedWriter(new FileWriter(saveFile, false));
					writer.write(text);
					writer.flush();
					writer.close();
				} catch (Exception e) {
					e.printStackTrace();
					MessageBox.post(dialog, e);
				}
			}
		}
	}

	public static void errorSWT(Shell shell, String message, String title) {
		showDialog(shell, message, title, SWT.ICON_ERROR);
	}

	public static void showDialog(Shell shell, String message, String title, int type) {
		org.eclipse.swt.widgets.MessageBox dialog = new org.eclipse.swt.widgets.MessageBox(shell, SWT.OK | type);
		dialog.setText(title);
		dialog.setMessage(message);
		dialog.open();
	}

	public static String[] getPrefVals(TCSession session, String prefName) throws Exception {
		if (KUtil.isEmpty(prefName)) {
			return null;
		}
		return session.getPreferenceService().getStringValues(prefName);
	}

	public static String getPrefVal(TCSession session, String prefName) throws Exception {
		if (KUtil.isEmpty(prefName)) {
			return null;
		}
		return session.getPreferenceService().getStringValue(prefName);
	}

	public static String getReg(Registry reg, String name) {
		String val = reg.getString(name);
		// System.out.println("Read REG: " + name + " = " + val);
		return val;
	}

//	public static String getReg(String name) {
//		return getReg(REG, name);
//	}

	public static void newRow(JPanel panel, Component comp, GridBagConstraints s, int width) {
		newRow(panel, comp, s, width, 0);
	}

	public static void newRow(JPanel panel, Component comp, GridBagConstraints s, int width, double weightx) {
		s.weightx = weightx;
		s.gridwidth = width;
		s.gridx = 0;
		s.gridy++;
		panel.add(comp, s);
	}

	public static void newRow(JDialog panel, Component comp, GridBagConstraints s, int width) {
		s.weightx = 0;
		s.gridwidth = width;
		s.gridx = 0;
		s.gridy++;
		panel.add(comp, s);
	}

	public static void addCol(JPanel panel, Component comp, GridBagConstraints s, int width, double weightx) {
		s.gridx++;
		s.gridwidth = width;
		s.weightx = weightx;
		panel.add(comp, s);
	}

	public static TCComponentDataset getDataset(TCComponent rev, String dsType, String dsName, String rel)
			throws Exception {
		if (rev == null || KUtil.isEmpty(dsName)) {
			return null;
		}
		rev.refresh();
		TCComponent[] kids = rev.getRelatedComponents(rel);
		for (TCComponent c : kids) {
			if (c.getType().equals(dsType) && c.toString().equals(dsName)) {
				return (TCComponentDataset) c;
			}
		}
		return null;
	}

	public static List<TCComponentDataset> getDatasets(TCComponent rev, String dsType, String rel) throws Exception {
		if (rev == null) {
			return null;
		}
		rev.refresh();
		List<TCComponentDataset> res = new ArrayList<TCComponentDataset>();
		TCComponent[] kids = rev.getRelatedComponents(rel);
		for (TCComponent c : kids) {
			if (c.getType().equals(dsType)) {
				res.add((TCComponentDataset) c);
			}
		}
		return res;
	}

	public static List<TCComponent> getChildComponents(TCComponent rev, String dsType, String rel, String dsNamePrefix)
			throws Exception {
		if (rev == null) {
			return null;
		}
		rev.refresh();
		List<TCComponent> res = new ArrayList<TCComponent>();
		TCComponent[] kids = rev.getRelatedComponents(rel);
		for (TCComponent c : kids) {
			if (c.getType().equals(dsType) && c.getProperty("object_name").startsWith(dsNamePrefix)) {
				res.add(c);
			}
		}
		return res;
	}

	public static List<TCComponent> getChildComponentsContainsStr(TCComponent rev, String dsType, String rel,
			String dsNameSubStr) throws Exception {
		if (rev == null) {
			return null;
		}
		if (dsNameSubStr == null) {
			dsNameSubStr = "";
		}
		rev.refresh();
		List<TCComponent> res = new ArrayList<TCComponent>();
		TCComponent[] kids = rev.getRelatedComponents(rel);
		for (TCComponent c : kids) {
			if (c.getType().equals(dsType) && c.getProperty("object_name").contains(dsNameSubStr)) {
				res.add(c);
			}
		}
		return res;
	}

	public static List<TCComponent> getChildComponents(TCComponent rev, String dsType, String rel) throws Exception {
		if (rev == null) {
			return null;
		}
		rev.refresh();
		List<TCComponent> res = new ArrayList<TCComponent>();
		TCComponent[] kids = rev.getRelatedComponents(rel);
		for (TCComponent c : kids) {
			if (c.getType().equals(dsType)) {
				res.add(c);
			}
		}
		return res;
	}

	public static TCComponentFolder getChildFolder(TCComponentFolder folder, String cFolderName) throws Exception {
		if (folder == null || cFolderName == null) {
			return null;
		}
		AIFComponentContext[] cc = folder.getChildren();
		int len = KUtil.getLen(cc);
		for (int i = 0; i < len; i++) {
			InterfaceAIFComponent c = cc[i].getComponent();
			if ((c instanceof TCComponentFolder) && cFolderName.equals(c.getProperty("object_name"))) {
				return (TCComponentFolder) c;
			}
		}
		return null;
	}

	public static TCComponentDataset uploadFile(TCSession session, TCComponent rev, File newFile, String dsName,
			String dsTypeName, String refName, String rel) throws Exception {
		TCComponentDataset ds = getDataset(rev, dsTypeName, dsName, rel);
		if (ds == null) {
			TCComponentDatasetType dsType = (TCComponentDatasetType) session.getTypeComponent(dsTypeName);
			ds = dsType.create(dsName, "", dsTypeName);
			if (rev != null) {
				rev.add(rel, ds);
				rev.refresh();
			}
		}
		setDsFile(ds, refName, newFile);
		return ds;
	}

	public static void setDsFile(TCComponentDataset ds, String refName, File newFile) throws Exception {
		if (ds.isCheckedOut()) {
			throw new Exception(String.format(KLocale.getString("uploadfilewhencheckout.ERROR1"), ds.toString()));
		}
		String[] refs = new String[] { refName };
		String[] files = new String[] { newFile.getAbsolutePath() };
		ds.setFiles(files, refs);
		// ds.save();
		ds.refresh();
	}

	public static void setDsFile2(TCComponentDataset ds, String refName, File newFile) throws Exception {
		String[] refs = new String[] { refName };
		String[] files = new String[] { newFile.getAbsolutePath() };
		ds.setFiles(files, refs);
		// ds.save();
		ds.refresh();
	}

	public static boolean isEmpty(String str) {
		return str == null || "".equals(str.trim());
	}

	public static int inArray(int target, int[] arr) {
		int len = arr == null ? 0 : arr.length;
		for (int i = 0; i < len; i++) {
			if (target == arr[i]) {
				return i;
			}
		}
		return -1;
	}

	public static boolean inArray(String str, String arr, String splitter) {
		if (KUtil.isEmpty(arr) || KUtil.isEmpty(splitter)) {
			return false;
		}
		if (KUtil.isEmpty(str)) {
			return true;
		}
		return inArray(str, arr.split(splitter)) >= 0;
	}

	public static int inArray(String target, String[] arr) {
		int len = arr == null ? 0 : arr.length;
		for (int i = 0; i < len; i++) {
			if (target.equals(arr[i])) {
				return i;
			}
		}
		return -1;
	}

	public static int getNextColNumber(int currentIndex, int[] skipColIndex, int cols) {
		int res = currentIndex;
		for (int i = 0; i < cols; i++) {
			res++;
			if (inArray(res, skipColIndex) >= 0) {
				i--;
			}
		}
		return res;
	}

	public static <E> List<List<E>> groupList(List<E> originList, int maxCount, int gap, E gapFiller) {
		List<List<E>> res = new ArrayList<List<E>>();
		int cnt = originList == null ? 0 : originList.size();
		List<E> list = new ArrayList<E>();
		for (int i = 0; i < cnt; i++) {
			list.add(originList.get(i));
			if (i != cnt - 1) {// add gap
				for (int j = 0; j < gap; j++) {
					list.add(gapFiller);
				}
			}
		}
		cnt = list == null ? 0 : list.size();
		if (maxCount <= 0) {
			maxCount = cnt;
		}
		int pageCounter = 0;
		List<E> cList = new ArrayList<E>();
		res.add(cList);
		for (int i = 0; i < cnt; i++) {
			if (pageCounter == maxCount) {
				cList = new ArrayList<>();
				res.add(cList);
				pageCounter = 0;
			}
			if (cList != null) {
				E item = list.get(i);
				if (cList.size() == 0 && item == gapFiller) {
					continue;
				}
				cList.add(list.get(i));
				pageCounter++;
			}
		}
		list.clear();
		list = null;
		return res;
	}

	public static <E> List<List<E>> groupListWithGapAdded(List<E> list, int maxCount, E gapFiller) {
		List<List<E>> res = new ArrayList<List<E>>();
		int cnt = list == null ? 0 : list.size();
		if (maxCount <= 0) {
			maxCount = cnt;
		}
		int pageCounter = 0;
		List<E> cList = new ArrayList<E>();
		res.add(cList);
		for (int i = 0; i < cnt; i++) {
			if (pageCounter == maxCount) {
				cList = new ArrayList<>();
				res.add(cList);
				pageCounter = 0;
			}
			if (cList != null) {
				E item = list.get(i);
				if (cList.size() == 0 && item == gapFiller) {
					continue;
				}
				cList.add(list.get(i));
				pageCounter++;
			}
		}
		list.clear();
		list = null;
		return res;
	}

	public static <E> List<List<Map<String, E>>> groupList(List<Map<String, E>> originList, int maxCount, int gap,
			Map<String, E> gapFiller, String gapKey) {
		List<List<Map<String, E>>> res = new ArrayList<List<Map<String, E>>>();
		int cnt = originList == null ? 0 : originList.size();
		List<Map<String, E>> list = new ArrayList<Map<String, E>>();
		boolean addGap = false;
		for (int i = 0; i < cnt; i++) {
			Map<String, E> item = originList.get(i);
			list.add(item);
			if (i != cnt - 1) {// add gap
				Map<String, E> nextItem = originList.get(i + 1);
				addGap = KUtil.isEmpty(gapKey) || (nextItem != null && nextItem.containsKey(gapKey));
				for (int j = 0; j < gap; j++) {
					if (addGap) {
						list.add(gapFiller);
					}
				}
			}
		}
		cnt = list == null ? 0 : list.size();
		if (maxCount <= 0) {
			maxCount = cnt;
		}
		int pageCounter = 0;
		List<Map<String, E>> cList = new ArrayList<Map<String, E>>();
		res.add(cList);
		for (int i = 0; i < cnt; i++) {
			if (pageCounter == maxCount) {
				cList = new ArrayList<>();
				res.add(cList);
				pageCounter = 0;
			}
			if (cList != null) {
				Map<String, E> item = list.get(i);
				if (cList.size() == 0 && item == gapFiller) {
					continue;
				}
				cList.add(list.get(i));
				pageCounter++;
			}
		}
		list.clear();
		list = null;
		return res;
	}

	public static File getFileFromDataset(TCSession session, String dsType, String uid, String prefName)
			throws Exception {
		TCComponent comp = null;
		try {
			comp = session.stringToComponent(uid);
		} catch (Exception e) {
			e.printStackTrace();
		}
		if (comp == null) {
			throw new Exception(String.format(KLocale.getString("dsuidinpref.ERROR1"), prefName));
		}
		String type = comp.getType();
		System.out.println("Dataset: " + comp + "|Type: " + type);
		if (!dsType.equals(type)) {
			throw new Exception(String.format(KLocale.getString("dsuidinpref.ERROR1"), prefName));
		}
		TCComponentDataset tDataset = (TCComponentDataset) comp;
		return getDatasetFile(tDataset);
	}

	public static File getDatasetFile(TCComponentDataset dataset) throws Exception {
		File[] files = dataset.getFiles("", System.getenv("TEMP"));
		if (files == null || files.length == 0) {
			throw new Exception(String.format(KLocale.getString("norefindataset.ERROR1"), dataset.toString()));
		}
		System.out.println(">> Download file (" + files.length + "): " + files[0].getAbsolutePath());
		return files[0];
	}

	public static File getDatasetFile(File dir, TCComponentDataset dataset) throws Exception {
		if (dir == null || !dir.isDirectory()) {
			throw new Exception("Directory not found.");
		}
		File[] files = dataset.getFiles("", dir.getAbsolutePath());
		if (files == null || files.length == 0) {
			throw new Exception(String.format(KLocale.getString("norefindataset.ERROR1"), dataset.toString()));
		}
		System.out.println(">> Download file (" + files.length + "): " + files[0].getAbsolutePath());
		return files[0];
	}

	public static String[] getStringArrayProp(TCComponentForm form, String propName) throws Exception {
		if (form == null) {
			return null;
		}
		TCProperty prop = form.getFormTCProperty(propName);
		if (prop == null) {
			throw new java.lang.Exception(
					String.format(KLocale.getString("nopropintype.ERROR2"), form.getDisplayType(), propName));
		}
		return prop.getStringArrayValue();
	}

	public static File chooseDirectory(Component parent) {
		FileSystemView fsv = FileSystemView.getFileSystemView();
		String deskPath = fsv.getHomeDirectory().getPath();
		JFileChooser fileChooser = new JFileChooser();
		fileChooser.setCurrentDirectory(new File(deskPath));
		fileChooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
		int state = fileChooser.showOpenDialog(parent);
		if (state == 1) {
			return null;
		}
		return fileChooser.getSelectedFile();
	}

	public static boolean addReleaseStatus(TCSession session, String uid, String status) throws Exception {
		TCUserService userservice = session.getUserService();
		Object[] obj = new Object[2];
		obj[0] = uid;
		obj[1] = status;
		Object res = userservice.call("K_add_release_status", obj);
		if (res != null && res.toString().equalsIgnoreCase("true")) {
			return true;
		}
		return false;
	}

	/**
	 * 设置只读属性的值
	 * 
	 * @param session
	 * @param propName
	 * @param propValue
	 * @param comp
	 * @return
	 * @throws Exception
	 */
	public static boolean setPropValue(TCSession session, String propName, String propValue, TCComponent comp)
			throws Exception {
		TCUserService userservice = session.getUserService();
		Object[] obj = new Object[3];
		obj[0] = propName;
		obj[1] = propValue;
		obj[2] = comp;
		Object res = userservice.call("Connor_Set_Prop_Value", obj);
		if (res != null && res.toString().equalsIgnoreCase("true")) {
			return true;
		}
		return false;
	}

	public static File chooseFile(Component parent) {
		FileSystemView fsv = FileSystemView.getFileSystemView();
		String deskPath = fsv.getHomeDirectory().getPath();
		JFileChooser fileChooser = new JFileChooser();
		fileChooser.setCurrentDirectory(new File(deskPath));
		fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
		FileNameExtensionFilter filter = new FileNameExtensionFilter("*.xlsx", "xlsx");
		fileChooser.setFileFilter(filter);
		int state = fileChooser.showOpenDialog(parent);
		if (state == 1) {
			return null;
		}
		return fileChooser.getSelectedFile();
	}

	public static File chooseSaveFile(Component parent, String defaultFile) {
		FileSystemView fsv = FileSystemView.getFileSystemView();
		String deskPath = fsv.getHomeDirectory().getPath();
		JFileChooser fileChooser = new JFileChooser();
		fileChooser.setCurrentDirectory(new File(deskPath));
		fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
		FileNameExtensionFilter filter = new FileNameExtensionFilter("*.xlsx", "xlsx");
		fileChooser.setFileFilter(filter);
		fileChooser.setSelectedFile(new File(defaultFile));
		int state = fileChooser.showSaveDialog(parent);
		if (state == 1) {
			return null;
		}
		return fileChooser.getSelectedFile();
	}

	public static File chooseSaveFile(Component parent, String defaultFile, String ext) {
		FileSystemView fsv = FileSystemView.getFileSystemView();
		String deskPath = fsv.getHomeDirectory().getPath();
		JFileChooser fileChooser = new JFileChooser();
		fileChooser.setCurrentDirectory(new File(deskPath));
		fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
		if (!KUtil.isEmpty(ext)) {
			FileNameExtensionFilter filter = new FileNameExtensionFilter("*." + ext, ext);
			fileChooser.setFileFilter(filter);
		}
		fileChooser.setSelectedFile(new File(defaultFile));
		int state = fileChooser.showSaveDialog(parent);
		if (state == 1) {
			return null;
		}
		return fileChooser.getSelectedFile();
	}

	public static File getNewFile(File folder, String fileName, String ext) {
		File file = new File(folder.getAbsolutePath() + "\\" + fileName + "." + ext);
		int index = 1;
		while (file.exists()) {
			file = new File(folder.getAbsolutePath() + "\\" + fileName + "(" + (index++) + ")." + ext);
		}
		return file;
	}

	public static String getDateStr(Date date, String format) {
		String res = "";
		try {
			SimpleDateFormat sdf = new SimpleDateFormat(format);
			res = sdf.format(date);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return res;
	}

	public static TCComponentContextList query(TCSession session, String queryName, Map<String, String> fields)
			throws Exception {
		String[] keys = fields.keySet().toArray(new String[] {});
		String[] vals = fields.values().toArray(new String[] {});
		return query(session, queryName, keys, vals);
	}

	public static TCComponentContextList query(TCSession session, String queryName, String[] keys, String[] vals)
			throws Exception {
		System.out.println("Query: " + queryName);
		System.out.println("keys = " + Arrays.toString(keys));
		System.out.println("vals = " + Arrays.toString(vals));
		TCComponentQueryType queryType = (TCComponentQueryType) session.getTypeComponent("ImanQuery");
		TCComponentQuery query = (TCComponentQuery) queryType.find(queryName);
		if (query == null) {
			throw new Exception(String.format(KLocale.getString("querynotexist.ERROR1"), queryName));
		}
		queryType.clearCache();
		query.clearCache();
		query.refresh();
		return query.getExecuteResultsList(keys, vals);
	}

	public static TCComponent[] query2(TCSession session, String queryName, String[] keys, String[] vals)
			throws Exception {
		System.out.println("Query: " + queryName);
		System.out.println("keys = " + Arrays.toString(keys));
		System.out.println("vals = " + Arrays.toString(vals));
		TCComponentQueryType queryType = (TCComponentQueryType) session.getTypeComponent("ImanQuery");
		TCComponentQuery query = (TCComponentQuery) queryType.find(queryName);
		if (query == null) {
			throw new Exception(String.format(KLocale.getString("querynotexist.ERROR1"), queryName));
		}
		queryType.clearCache();
		query.clearCache();
		query.refresh();
		return query.execute(keys, vals);
	}

	public static TCComponentContextList combineContext(TCSession session, TCComponentQuery query,
			TCComponentContextList... contexts) throws Exception {
		Class<TCComponentContextList> c = TCComponentContextList.class;
		Field f1 = c.getDeclaredField("m_compUids");
		f1.setAccessible(true);
		List<String> compUids = new ArrayList<>();
		for (TCComponentContextList cc : contexts) {
			String[] u1 = (String[]) f1.get(cc);
			System.out.println(Arrays.toString(u1));
			compUids.addAll(Arrays.asList(u1));
		}
		Constructor<?> constructor = c.getDeclaredConstructor(TCComponentManager.class, TCComponent.class,
				String[].class, String[].class, String.class);
		constructor.setAccessible(true);
		TCComponentContextList res = (TCComponentContextList) constructor.newInstance(new TCComponentManager(session),
				query, compUids.toArray(new String[] {}), null, "");
		return res;
	}

	public static int getLen(Object[] arr) {
		return arr == null ? 0 : arr.length;
	}

	public static String getValueInArray(String[] arr, int index) {
		int len = arr == null ? 0 : arr.length;
		if (index >= len) {
			return "";
		}
		return arr[index];
	}

	public static String getValueInArray(String arrStr, int index, String splitter) {
		if (KUtil.isEmpty(arrStr)) {
			return "";
		}
		String[] split = arrStr.split(splitter, -1);
		int len = getLen(split);
		if (len > index && index >= 0) {
			return split[index];
		}
		return "";
	}

	public static String getTypeNames(TCSession session, Object[] types) {
		int len = types == null ? 0 : types.length;
		if (len == 0) {
			return "";
		}
		String[] names = new String[len];
		for (int i = 0; i < len; i++) {
			try {
				if ("TC_Project".equals(types[i].toString())) {
					names[i] = KLocale.getString("project");
				} else {
					names[i] = session.getTypeComponent(types[i].toString()).getDisplayTypeName();
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
			if (names[i] == null) {
				names[i] = types[i].toString();
			}
		}
		return Arrays.toString(names);
	}

	public static String getTypeName(TCSession session, String type) {
		if (KUtil.isEmpty(type)) {
			return "";
		}
		try {
			if ("TC_Project".equals(type)) {
				return KLocale.getString("project");
			} else {
				return session.getTypeComponent(type).getDisplayTypeName();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return type;
	}

	public static boolean isReleased(TCComponent comp) throws Exception {
		TCComponent[] status = comp.getReferenceListProperty("release_status_list");
		if (status == null || status.length == 0) {
			return false;
		}
		return true;
	}

	public static TCComponentUser getUserFromStr(String str) throws Exception {
		System.out.println("Search User: " + str);
		if (KUtil.isEmpty(str)) {
			return null;
		}
		int ind1 = str.lastIndexOf('(');
		int ind2 = str.lastIndexOf(')');
		TCComponentUser user = null;
		if (ind1 > 0 && ind2 > ind1) {
			String userId = str.substring(ind1 + 1, ind2);
			if (KUtil.isEmpty(userId)) {
				System.out.println("No Id between '(' and ')'");
				user = null;
			} else {
				user = queryUserById(userId);
			}
		} else {
			user = queryUserById(str);
			if (user == null) {
				user = queryUserByName(str);
			}
		}
		return user;
	}

	public static TCComponentUser queryUserById(String userId) throws Exception {
		System.out.println("Search User By Id: " + userId);
		if (KUtil.isEmpty(userId)) {
			return null;
		}
		String queryName = "Admin - Employee Information";
		String[] keys = new String[] { KUtil.getText("UserId") };
		String[] vals = new String[] { userId };
		TCComponentContextList res = KUtil.query(KUtil.session, queryName, keys, vals);
		if (res.getListCount() == 0) {
			return null;
		}
		if (res.getListCount() > 1) {
			throw new Exception(String.format(KLocale.getString("multiuserbyid.ERROR1"), userId));
		}
		return (TCComponentUser) res.get(0).getComponent();
	}

	public static TCComponentUser queryUserByName(String userName) throws Exception {
		System.out.println("Search User By Name: " + userName);
		if (KUtil.isEmpty(userName)) {
			return null;
		}
		String queryName = "Admin - Employee Information";
		String[] keys = new String[] { KUtil.getText("PersonName") };
		String[] vals = new String[] { userName };
		TCComponentContextList res = KUtil.query(KUtil.session, queryName, keys, vals);
		if (res.getListCount() == 0) {
			return null;
		}
		if (res.getListCount() > 1) {
			throw new Exception(String.format(KLocale.getString("multiuserbyname.ERROR1"), userName));
		}
		return (TCComponentUser) res.get(0).getComponent();
	}

	public static TCComponent[] getGroupMember(List<TCComponentUser> privMembers) throws Exception {
		if (privMembers == null) {
			return null;
		}
		List<TCComponent> res = new ArrayList<>();
		for (TCComponentUser user : privMembers) {
			TCComponentGroupMember[] gms = user.getGroupMembers();
			int len = KUtil.getLen(gms);
			for (int i = 0; i < len; i++) {
				TCComponentGroupMember gm = gms[i];
				if (KUtil.isEmpty(gm.toString())) {
					continue;
				}
				/*
				 * if(!gm.isActive()) { System.out.println("锟斤拷锟皆憋拷腔疃拷锟?"+gm); continue; }
				 */
				if (!res.contains(gm)) {
					System.out.println("Add Group Member: " + gm);
					res.add(gm);
				} else {
					System.out.println("Added: " + gm);
				}
			}
		}
		return res.toArray(new TCComponent[] {});
	}

	public static int compareWBS(String wbsCode, String wbsCode2) {
		if (KUtil.isEmpty(wbsCode) && KUtil.isEmpty(wbsCode2)) {
			return 0;
		}
		if (KUtil.isEmpty(wbsCode)) {
			return -1;
		}
		if (KUtil.isEmpty(wbsCode2)) {
			return 1;
		}
		String[] a = wbsCode.split("\\.");
		String[] b = wbsCode2.split("\\.");
		int lenA = a.length;
		int lenB = b.length;
		for (int i = 0; i < lenA && i < lenB; i++) {
			String aa = a[i];
			String bb = b[i];
			int ai = 0;
			int bi = 0;
			try {
				ai = Integer.parseInt(aa);
				bi = Integer.parseInt(bb);
			} catch (Exception e) {
				e.printStackTrace();
			}
			if (ai != bi) {
				return ai - bi;
			}
		}
		return lenA - lenB;
	}

	public static TCComponentListOfValues getLov(String lovName) {
		TCComponentListOfValuesType lovType;
		try {
			lovType = (TCComponentListOfValuesType) session.getTypeComponent("ListOfValues");
			TCComponentListOfValues[] lov = lovType.find(lovName);
			if (lov.length > 0)
				return lov[0];
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}

	public static String[] getDynamicLOV(String s) {
		TCComponentListOfValues lov = null;
		List<String> lovDisplayValueList = new ArrayList<>();
		lovDisplayValueList.add("");
		List<String> lovValueList = new ArrayList<>();
		lov = TCComponentListOfValuesType.findLOVByName(s);
		try {
			if ("Fnd0ListOfValuesDynamic".equals(lov.getProperty("lov_type"))) {
				LOVService lovService = LOVService.getService(RACUIUtil.getTCSession());
				InitialLovData input = new InitialLovData();
				LovFilterData filter = new LovFilterData();
				filter.sortPropertyName = "object_name";
				filter.order = 1;
				filter.numberToReturn = 100;
				filter.maxResults = 100;

				input.lov = lov;
				input.filterData = filter;
				LOVSearchResults result = lovService.getInitialLOVValues(input);
				StringBuffer sb = new StringBuffer();
				sb.append(">>");
				for (LOVValueRow row : result.lovValues) {
					Map<String, String[]> map = row.propDisplayValues;
					Map<String, String[]> realmap = row.propInternalValues;

					for (String key : map.keySet()) {
						sb.append("UID:" + row.uid + ",key:" + key + "，value:" + map.get(key)[0]);
						sb.append("\n");

						lovDisplayValueList.add(map.get(key)[0]);
						lovValueList.add(realmap.get(key)[0]);
					}
				}
			}
		} catch (TCException e) {
			e.printStackTrace();
		}
		return lovDisplayValueList.toArray(new String[lovDisplayValueList.size()]);
	}

	public static String getLovValue(TCComponentListOfValues lov, String str) throws Exception {
		return getLovValue(lov, str, true);
	}

	public static String getLovValue(TCComponentListOfValues lov, String str, boolean translate) throws Exception {
		if (lov == null || KUtil.isEmpty(str)) {
			return str;
		}
		if (translate) {
			String prefName = "LOV_TRANS_" + lov.getStringProperty(TCComponentListOfValues.PROP_LOV_NAME);
			String[] prefVals = KUtil.getPrefVals(KUtil.session, prefName);
			int len = KUtil.getLen(prefVals);
			for (int i = 0; i < len; i++) {
				String pref = prefVals[i];
				int ind = pref.indexOf('=');
				if (ind > 0) {
					String realVal = pref.substring(0, ind);
					String disVal = pref.substring(ind + 1);
					if (str.equals(realVal) || str.equals(disVal)) {
						return realVal;
					}
				}
			}
		}
		ListOfValuesInfo info = lov.getListOfValues();
		if (info == null) {
			return str;
		}
		List<LovValue> v = info.getValues();
		int size = v == null ? 0 : v.size();
		for (int i = 0; i < size; i++) {
			LovValue vv = v.get(i);
			String realValue = vv.getValue() == null ? "" : vv.getValue().toString();
			if (str.equals(realValue)) {
				return str;
			}
			String disValue = vv.getDisplayValue();
			if (str.equals(disValue)) {
				return realValue;
			}
		}
		throw new Exception(String.format(KLocale.getString("valuenotinlov.ERROR2"), lov.toString(), str));
	}

	public static String getLovDisplayableValue(TCComponentListOfValues lov, String str) throws Exception {
		if (lov == null || KUtil.isEmpty(str)) {
			return str;
		}
		ListOfValuesInfo info = lov.getListOfValues();
		if (info == null) {
			return str;
		}
		List<LovValue> v = info.getValues();
		int size = v == null ? 0 : v.size();
		for (int i = 0; i < size; i++) {
			LovValue vv = v.get(i);
			String realValue = vv.getValue() == null ? "" : vv.getValue().toString();
			if (str.equals(realValue)) {
				return vv.getDisplayValue();
			}
			String disValue = vv.getDisplayValue();
			if (str.equals(disValue)) {
				return str;
			}
		}
		throw new Exception(String.format(KLocale.getString("valuenotinlov.ERROR2"), lov.toString(), str));
	}

	public static void openFile(File file) {
		try {
			if (file != null && file.exists()) {
				Runtime.getRuntime().exec("cmd /c start /b call \"" + file.getAbsolutePath() + "\"");
			}
		} catch (Exception e) {
			e.printStackTrace();
			MessageBox.post(e);
		}
	}

	public static void importDataset(TCComponent parent, String rel, File f, String dsType, String refName)
			throws Exception {
		if (f == null || !f.exists() || KUtil.isEmpty(dsType) || KUtil.isEmpty(refName)) {
			return;
		}
		TCComponentDatasetType datasetType = (TCComponentDatasetType) session.getTypeComponent(dsType);
		TCComponentDataset dataset = datasetType.create(f.getName(), "", dsType);
		String paths[] = { f.getAbsolutePath() };
		String refs[] = { refName };
		dataset.setFiles(paths, refs);
		if (parent != null && !KUtil.isEmpty(rel)) {
			parent.add(rel, dataset);
		}
	}

	public static void initPropMap(String propConfig, String value, Map<String, String> itemPropMap,
			Map<String, String> itemMasterPropMap, Map<String, String> revPropMap, Map<String, String> revMasterPropMap)
			throws Exception {
		initPropMap(propConfig, value, itemPropMap, itemMasterPropMap, revPropMap, revMasterPropMap, null);
	}

	public static void initPropMap(String propConfig, String value, Map<String, String> itemPropMap,
			Map<String, String> itemMasterPropMap, Map<String, String> revPropMap, Map<String, String> revMasterPropMap,
			Map<String, String> bomlinePropMap) throws Exception {
		if (KUtil.isEmpty(propConfig)) {
			return;
		}
		String propFrom = null, propName = null;
		String[] split = propConfig.split("\\.");
		if (KUtil.getLen(split) == 2) {
			propFrom = split[0].trim().toUpperCase();
			propName = split[1].trim();
		}
		if (KUtil.isEmpty(propFrom) || KUtil.isEmpty(propName)) {
			return;
		}
		Map<String, String> target;
		if ("ITEM".equals(propFrom)) {
			target = itemPropMap;
			System.out.println(">> ITEM PROP: " + propName + " = " + value);
		} else if ("REV".equals(propFrom)) {
			System.out.println(">> REV PROP: " + propName + " = " + value);
			target = revPropMap;
		} else if ("ITEMMASTER".equals(propFrom)) {
			System.out.println(">> ITEMMASTER PROP: " + propName + " = " + value);
			target = itemMasterPropMap;
		} else if ("REVMASTER".equals(propFrom)) {
			System.out.println(">> REVMASTER PROP: " + propName + " = " + value);
			target = revMasterPropMap;
		} else if ("BOMLINE".equals(propFrom)) {
			System.out.println(">> BOMLINE PROP: " + propName + " = " + value);
			target = bomlinePropMap;
		} else {
			throw new Exception(String.format(KLocale.getString("proplocationnotdefined.ERROR1"), propFrom));
		}
		if (target == null) {
			return;
		}
		target.put(propName, value);
	}

	public static String getMarkedPropValue(String config, Map<String, TCComponent> markedComponents) throws Exception {
		return getMarkedPropValue(config, markedComponents, null);
	}

	public static String getMarkedPropValue(String config, Map<String, TCComponent> markedComponents,
			Map<TCComponent, List<TCComponent>> relatedComponents) throws Exception {
		if (markedComponents == null || KUtil.isEmpty(config)) {
			return "";
		}
		StringBuilder res = new StringBuilder();
		String[] propConfigSplit = config.split("\\+");
		int len = KUtil.getLen(propConfigSplit);
		for (int i = 0; i < len; i++) {
			String propConfig = propConfigSplit[i];
			String propFrom = null, propName = null;
			String defaultValue = "";
			String[] split = propConfig.split("\\.");
			if (KUtil.getLen(split) >= 2) {
				propFrom = split[0].trim().toUpperCase();
				propName = split[1].trim();
			}
			if (KUtil.getLen(split) >= 3) {
				defaultValue = split[2].trim();
			}
			if (KUtil.isEmpty(propFrom) || KUtil.isEmpty(propName)) {
				if (propConfig.contains("\\n")) {
					propConfig = propConfig.replace("\\n", "\n");
				}
				res.append(propConfig);
				continue;
			}
			if (!markedComponents.containsKey(propFrom)) {
				if (propFrom.startsWith("T")) {
					return "";
				}
				continue;
			}
			TCComponent comp = markedComponents.get(propFrom);
			// 检查表格属性 属性位置.表格属性名称-表格行属性名称[-连接符]
			int ind = propName.indexOf('-');
			if (ind > 0) {
				String tableProp = propName.substring(0, ind).trim();
				String tableRowProp = propName.substring(ind + 1).trim();
				if (!KUtil.isEmpty(tableProp) && !KUtil.isEmpty(tableRowProp)) {
					TCProperty prop = comp.getTCProperty(tableProp.trim());
					if (prop == null) {
						throw new Exception(String.format(KLocale.getString("propnotdefinedintype.ERROR2"),
								comp.getType(), propName));
					}
					String rowSplitter = "#ROW#";
					ind = tableRowProp.indexOf('-');
					if (ind > 0) {
						rowSplitter = tableRowProp.substring(ind + 1);
						tableRowProp = tableRowProp.substring(0, ind);
					}
					TCComponent[] tableRows = prop.getReferenceValueArray();
					int rowCnt = KUtil.getLen(tableRows);
					String[] value = new String[rowCnt];
					for (int j = 0; j < rowCnt; j++) {
						value[j] = tableRows[j].getPropertyDisplayableValue(tableRowProp);
					}
					res.append(String.join(rowSplitter, value));
				}
				continue;
			}
			TCProperty prop = comp.getTCProperty(propName.trim());
			if (prop == null) {
				throw new Exception(
						String.format(KLocale.getString("propnotdefinedintype.ERROR2"), comp.getType(), propName));
			}
			String value = prop.getDisplayableValue();
			if ("NAME".equalsIgnoreCase(defaultValue)) {
				value = prop.getPropertyDisplayName();
			} else if (value == null || "".equals(value)) {
				value = defaultValue;
			}
			res.append(value);
		}
		return res.toString();
	}

	public static TCComponent getLatestComponent(List<TCComponent> comps) {
		int size = comps == null ? 0 : comps.size();
		if (size == 0) {
			return null;
		}
		if (size == 1) {
			return comps.get(0);
		}
		TCComponent res = comps.get(0);
		try {
			Date maxDate = res.getDateProperty("creation_date");
			for (int i = 1; i < size; i++) {
				TCComponent temp = comps.get(i);
				Date tempDate = temp.getDateProperty("creation_date");
				if (tempDate.after(maxDate)) {
					maxDate = tempDate;
					res = temp;
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return res;
	}

	public static TCComponentType[] getComponentTypes(String itemTypeName) throws Exception {
		TCComponentItemType itemType = null;
		try {
			itemType = (TCComponentItemType) session.getTypeComponent(itemTypeName);
		} catch (Exception e) {
			e.printStackTrace();
		}
		if (itemType == null) {
			throw new Exception(String.format(KLocale.getString("typenotfound.ERROR1"), itemTypeName));
		}
		TCComponentItemRevisionType revType = itemType.getItemRevisionType();
		if (revType == null) {
			throw new Exception(String.format(KLocale.getString("typenotfound.ERROR1"), itemTypeName + "Revision"));
		}
		TCComponentType itemMasterType = null;
		try {
			itemMasterType = session.getTypeComponent(itemTypeName + "Master");
		} catch (Exception e) {
			e.printStackTrace();
		}
		if (itemMasterType == null) {
			try {
				itemMasterType = session.getTypeComponent(itemTypeName + " Master");
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		if (itemMasterType == null) {
			throw new Exception(String.format(KLocale.getString("typenotfound.ERROR1"), itemTypeName + "Master"));
		}
		TCComponentType revMasterType = null;
		try {
			revMasterType = session.getTypeComponent(revType.getTypeName() + "Master");
		} catch (Exception e) {
			e.printStackTrace();
		}
		if (revMasterType == null) {
			try {
				revMasterType = session.getTypeComponent(revType.getTypeName() + " Master");
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		if (revMasterType == null) {
			throw new Exception(
					String.format(KLocale.getString("typenotfound.ERROR1"), revType.getTypeName() + "Master"));
		}
		return new TCComponentType[] { itemType, revType, itemMasterType, revMasterType };
	}

	public static String getPropertyDisplayName(TCComponentType type, String propName) throws Exception {
		if (type == null || KUtil.isEmpty(propName)) {
			return propName;
		}
		TCPropertyDescriptor desc = type.getPropDesc(propName);
		if (desc == null) {
			throw new Exception(String.format(KLocale.getString("propnotdefinedintype.ERROR2"),
					type.getDisplayTypeName(), propName));
		}
		return desc.getDisplayName();
	}

	public static String getConfigPropValue(TCComponentItemRevision rev, String propConfigStr) throws Exception {
		if (rev == null || KUtil.isEmpty(propConfigStr)) {
			return "";
		}
		StringBuilder res = new StringBuilder();
		String[] propConfigSplit = propConfigStr.split("\\+");
		int len = KUtil.getLen(propConfigSplit);
		for (int i = 0; i < len; i++) {
			String propConfig = propConfigSplit[i];
			String propFrom = null, propName = null;
			String[] split = propConfig.split("\\.");
			if (KUtil.getLen(split) == 2) {
				propFrom = split[0].trim().toUpperCase();
				propName = split[1].trim();
			}
			if (KUtil.isEmpty(propFrom) || KUtil.isEmpty(propName)) {
				res.append(propConfig);
				continue;
			}
			TCComponent target;
			if ("ITEM".equals(propFrom)) {
				target = rev.getItem();
			} else if ("REV".equals(propFrom)) {
				target = rev;
			} else if ("ITEMMASTER".equals(propFrom)) {
				target = rev.getItem().getRelatedComponent("IMAN_master_form");
			} else if ("REVMASTER".equals(propFrom)) {
				target = rev.getRelatedComponent("IMAN_master_form_rev");
			} else {
				throw new Exception(String.format(KLocale.getString("proplocationnotdefined.ERROR1"), propFrom));
			}
			TCProperty prop = target.getTCProperty(propName.trim());
			if (prop == null) {
				throw new Exception(
						String.format(KLocale.getString("propnotdefinedintype.ERROR2"), target.getType(), propName));
			}
			res.append(prop.getStringValue());
		}
		return res.toString();
	}

	public static String getConfigPropDisplayableValue(TCComponentItemRevision rev, String propConfigStr)
			throws Exception {
		if (rev == null || KUtil.isEmpty(propConfigStr)) {
			return "";
		}
		StringBuilder res = new StringBuilder();
		String[] propConfigSplit = propConfigStr.split("\\+");
		int len = KUtil.getLen(propConfigSplit);
		for (int i = 0; i < len; i++) {
			String propConfig = propConfigSplit[i];
			String propFrom = null, propName = null;
			String[] split = propConfig.split("\\.");
			if (KUtil.getLen(split) == 2) {
				propFrom = split[0].trim().toUpperCase();
				propName = split[1].trim();
			}
			if (KUtil.isEmpty(propFrom) || KUtil.isEmpty(propName)) {
				res.append(propConfig);
				continue;
			}
			TCComponent target;
			if ("ITEM".equals(propFrom)) {
				target = rev.getItem();
			} else if ("REV".equals(propFrom)) {
				target = rev;
			} else if ("ITEMMASTER".equals(propFrom)) {
				target = rev.getItem().getRelatedComponent("IMAN_master_form");
			} else if ("REVMASTER".equals(propFrom)) {
				target = rev.getRelatedComponent("IMAN_master_form_rev");
			} else {
				throw new Exception(String.format(KLocale.getString("proplocationnotdefined.ERROR1"), propFrom));
			}
			TCProperty prop = target.getTCProperty(propName.trim());
			if (prop == null) {
				throw new Exception(
						String.format(KLocale.getString("propnotdefinedintype.ERROR2"), target.getType(), propName));
			}
			res.append(prop.getDisplayableValue());
		}
		return res.toString();
	}

	public static void removeAllParents(DataManagementService dm, TCComponent comp) throws Exception {
		comp.refresh();
		System.out.println("Remove from parent: " + comp);
		WhereReferencedResponse refResp = dm.whereReferenced(new TCComponent[] { comp }, 1);
		KUtil.throwServiceDataError(refResp.serviceData);
		int len = KUtil.getLen(refResp.output);
		List<Relationship> datas = new ArrayList<Relationship>();
		for (int i = 0; i < len; i++) {
			WhereReferencedOutput ref = refResp.output[i];
			int cnt = KUtil.getLen(ref.info);
			for (int j = 0; j < cnt; j++) {
				WhereReferencedInfo info = ref.info[j];
				Relationship data = new Relationship();
				data.primaryObject = info.referencer;
				data.secondaryObject = comp;
				data.relationType = info.relation;
				System.out.println(">> " + info.relation + " | " + info.referencer);
				datas.add(data);
			}
		}
		ServiceData resp = dm.deleteRelations(datas.toArray(new Relationship[] {}));
		KUtil.throwServiceDataError(resp);
	}

	public static TCComponent newTableRow(DataManagementService dmService, String type,
			Map<String, String> rowStringProps, Map<String, Calendar> rowDateProps) throws Exception {
		CreateIn rowIn = new CreateIn();
		CreateInput rowInput = new CreateInput();
		rowInput.boName = type;
		if (rowStringProps != null) {
			rowInput.stringProps = rowStringProps;
		}
		if (rowDateProps != null) {
			rowInput.dateProps = rowDateProps;
		}
		rowIn.data = rowInput;
		CreateResponse res = dmService.createObjects(new CreateIn[] { rowIn });
		KUtil.throwServiceDataError(res.serviceData);
		if (res.serviceData.sizeOfCreatedObjects() > 0) {
			return res.serviceData.getCreatedObject(0);
		}
		return null;
	}

	public static Date addDay(Date day, int cnt) {
		if (day == null) {
			return null;
		}
		Calendar c = Calendar.getInstance();
		c.setTime(day);
		c.add(Calendar.DATE, cnt);
		return c.getTime();
	}

	public static Date calTime(TCCalendar calendar, Date date, int minutes) {
		if (calendar == null || date == null) {
			return null;
		}
		int diff = minutes > 0 ? 1 : -1;
		if (minutes < 0) {
			minutes = -minutes;
		}
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		int counter = 0;
		while (counter < minutes) {
			counter += calendar.getMinutesOnDay(c);
			c.add(Calendar.DATE, diff);
		}
		return c.getTime();
	}

	public static int getMinutesBetween(TCCalendar calendar, Date start, Date end) {
		if (calendar == null || start == null || end == null) {
			return 0;
		}
		Calendar c = Calendar.getInstance();
		c.setTime(start);
		int res = 0;
		while (c.getTime().before(end)) {
			res += calendar.getMinutesOnDay(c);
			// System.out.println(calendar.getMinutesOnDay(c)+" > "+c.getTime());
			c.add(Calendar.DATE, 1);
		}
		return res;
	}

	public static TCComponentTCCalendar getScheduleCalendar(TCComponentSchedule schedule) throws Exception {
		if (schedule == null) {
			return null;
		}
		return CalendarHelper.getScheduleCalendar(schedule, session);
	}

	public static void dealSpecialModelValue(ArrayList<Integer> specialList, String prefName, String prop, int ind) {
		int index = 0;

		try {
			String[] prefVals = KUtil.getPrefVals(session, prefName);
			String puid = prefVals[ind];
			TCComponent component = session.stringToComponent(puid);
			if (component instanceof TCComponentForm) {

				TCComponentForm form = (TCComponentForm) component;

				TCComponent[] tables = form.getReferenceListProperty("ld6_ChangeTable");
				for (int j = 0; j < tables.length; j++) {

					String change = tables[j].getStringProperty(prop);
					System.out.println("change======================"+change);
					if (change.equals("是")) {
						System.out.println("jjj==="+j);
						specialList.add(j);
					}
				}

			}

//			
//			Set<Entry<String,ArrayList<String>>> entrySet = map.entrySet();
//			for (Entry<String, ArrayList<String>> entry : entrySet) {
//				ArrayList<String> list = entry.getValue();
//				String value = list.get(2);
//				System.out.println("当前值为：" + value);
//				if(value != null && value.equals("是")) {
//					specialList.add(index);
//				}
//				index++;
//			}	
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

	/**
	 * 得到模板的值
	 * 
	 * @param map
	 * @throws Exception
	 */
//	public static void getModelVale(LinkedHashMap<String, ArrayList<String>> map,String prefName,int index) throws Exception {
//		AbstractAIFApplication application = AIFUtility.getCurrentApplication();
//		TCSession session = (TCSession) application.getSession();
//		String[] prefVals = KUtil.getPrefVals(session, prefName);
//		String puid = prefVals[index];
//		TCComponentDataset component = (TCComponentDataset) session.stringToComponent(puid);
//		TCComponentTcFile[] tcFiles = component.getTcFiles();
//		File datasetFile = null;
//		String name = "";
//		if (tcFiles != null && tcFiles.length != 0) {
//			TCComponentTcFile tcComponentTcFile = tcFiles[0];
//			File fmsFile = tcComponentTcFile.getFmsFile();
//			name = tcComponentTcFile.getStringProperty("original_file_name");
//			datasetFile = new File(System.getenv("TEMP")+"\\"+name);
//			FileUtility.copyFile(fmsFile, datasetFile);
//			
//		}
//		XSSFWorkbook wb = new XSSFWorkbook(new FileInputStream(datasetFile));
//		XSSFSheet sheet = wb.getSheetAt(0);
//		for (int i = 1; i < sheet.getPhysicalNumberOfRows(); i++) {
//			XSSFRow row = sheet.getRow(i);
//			for (int j = 0; j < 5; j++) {
//				XSSFCell cell = row.getCell(j);
//				if(cell != null) {
//					String cellValue = KUtil.getCellValue(cell);
//					if(j == 0 && cellValue.isEmpty()) {
//						break;
//					}
//					if(j == 0 ) {		
//						if(map.containsKey(cellValue)) {
//							break;
//						}else {
//							map.put(cellValue, null);
//						}				
//					}else {
//						String key = KUtil.getCellValue(row.getCell(0));
//						ArrayList<String> arrayList = map.get(key);
//						if(arrayList != null) {
//							arrayList.add(cellValue);
//						}else {
//							ArrayList<String> list = new ArrayList<String>();
//							list.add(cellValue);
//							map.put(key, list);
//						}
//					}
//					
//				}
//			}
//		}
//		wb.close();
//		datasetFile.delete();		
//	}
	/**
	 * 得到模板的值
	 * 
	 * @param map
	 * @throws Exception
	 */
	public static void getModelVale(LinkedHashMap<String, ArrayList<String>> map, TCComponent forms,
			ArrayList<Integer> specialList, String[] propNames) throws Exception {
//		AbstractAIFApplication application = AIFUtility.getCurrentApplication();
//		TCSession session = (TCSession) application.getSession();
//		String[] prefVals = KUtil.getPrefVals(session, prefName);
//		String puid = prefVals[index];
//		TCComponent component =  session.stringToComponent(puid);
		int t = 1;
		if (forms instanceof TCComponentForm) {

			TCComponentForm form = (TCComponentForm) forms;
			TCComponent[] tables = form.getReferenceListProperty("ld6_ChangeTable");
			for (int j = 0; j < tables.length; j++) {
				ArrayList<String> tableValue = new ArrayList<String>();

				for (String propName : propNames) {
					//System.out.println("当前的属性名为：" + propName);
					String prop = tables[j].getTCProperty(propName).getDisplayableValue();
					if (propName.equals("ld6_YNChange") && prop.equals("是")) {
//						specialList.add(j);
					}
					tableValue.add(prop == null ? "" : prop.trim());
				}

				map.put(String.valueOf(t), tableValue);
//				tableValue

				t = t + 1;
			}

		}

	}

	/**
	 * 得到lov的真实值和显示值
	 * 
	 * @param lovMap
	 * @param comboBox
	 * @throws TCException
	 */
	public static void getLov(HashMap<String, String> lovMap, String lovName, JComboBox<String> comboBox)
			throws TCException {
		if (comboBox != null) {
			comboBox.addItem("");
		}
//		for (LovValue lovV : lovValueList) {
//			map.put(lovV.getDisplayValue(), lovV.getStringValue());
//			comboBox.addItem(lovV.getDisplayValue());
//			System.out.println(lovV.getDisplayValue() + "===" + lovV.getStringValue());
//		}

		TCComponentListOfValues lov = TCComponentListOfValuesType.findLOVByName(lovName);
		if ("Fnd0ListOfValuesDynamic".equals(lov.getProperty("lov_type"))) {
			System.out.println("动态lovName=" + lovName);
			LOVService lovService = LOVService.getService(RACUIUtil.getTCSession());
			InitialLovData input = new InitialLovData();
			LovFilterData filter = new LovFilterData();
			if ("LD6_TecDoc_TypeLOV".equals(lovName)) {
				filter.sortPropertyName = "fnd0StringValues"; // lov的后台值
			} else {
				filter.sortPropertyName = "object_name"; // lov的后台值
			}

			filter.order = 1;
			filter.numberToReturn = 2000;
			filter.maxResults = 2000;

			input.lov = lov;
			input.filterData = filter;
			LOVSearchResults result = lovService.getInitialLOVValues(input);
			// System.out.println("111==="+result.toString());

			for (LOVValueRow row : result.lovValues) {
				Map<String, String[]> map = row.propDisplayValues;
				Map<String, String[]> realmap = row.propInternalValues;
//				for (String key : map.keySet()) {
//					System.out.println("key=" + key + ",value=" + map.get(key)[0]);
//				}
//				for (String key : realmap.keySet()) {
//					System.out.println("key2=" + key + ",value2=" + map.get(key)[0]);
//				}
				String disval = "";
				String val = "";
				String key1 = "object_name";// 真实值 显示值第一列
				if ("LD6_TecDoc_TypeLOV".equals(lovName)) {
					key1 = "fnd0StringValues"; // lov的后台值
				}
				// String key2 = "object_desc";// 显示值第二列
				if (map.containsKey(key1)) {
					val = realmap.get(key1)[0];
					disval = map.get(key1)[0];
				}
				if (!val.equals("")) {
					lovMap.put(disval, val);
					if (comboBox != null) {
						comboBox.addItem(disval);
					}
				}

			}

		} else {
			ListOfValuesInfo info = lov.getListOfValues();
			info.getLOVDisplayValues();
			List<LovValue> lovValueList = info.getValues();
			for (LovValue lovV : lovValueList) {
				lovMap.put(lovV.getDisplayValue(), lovV.getStringValue());
				if (comboBox != null) {
					comboBox.addItem(lovV.getDisplayValue());
				}
			}
		}

	}

	public static void dealPref(String[] prefVals, InterfaceAIFComponent targetComponent,
			ArrayList<ControlBean> beanList, StringBuffer newTypeBuffer) throws Exception {
		/**
		 * LD6_PRRevision/LD6_CR|*[string]Item.item_id=;
		 * *[string]Item.object_name=;*[string]Rev.ld6_processNum=;*[string]Rev.ld6_productNum=Rev.ld6_proNum
		 */
		String type = targetComponent.getType();
		TCComponentItemRevision rev = (TCComponentItemRevision) targetComponent;
		for (String string : prefVals) {
			String[] split = string.split("\\|");
			if (split.length == 2) {
				String[] split2 = split[0].split("/");
				if (split2.length == 2 && type.equals(split2[0])) {
					// 得到更改请求对象类型
					newTypeBuffer.append(split2[1]);
					// 得到界面的控件
					String[] split3 = split[1].split(";");
					for (int i = 0; i < split3.length; i++) {
						ControlBean bean = new ControlBean();
						if (split3[i].contains("*[")) {
							bean.setIfMust(true);
						}
						String[] split4 = split3[i].split("=");
						// 判断是什么类型的数据
						if (split4[0].contains("boolean")) {
							bean.setPropType("boolean");
						} else if (split4[0].contains("date")) {
							bean.setPropType("date");
						} else if (split4[0].contains("string:")) {
							bean.setPropType("lov");
						} else if (split4[0].contains("string") && !split4[0].contains("string:")) {
							bean.setPropType("string");
						}
						if (split4.length == 2) {
							bean.setDefaultValue(getTCPropertyValue(rev, split4[1], bean));
						}
						String[] split5 = split4[0].split("]");
						if (split5.length == 2) {
							String[] split6 = split5[1].split("\\.");
							bean.setPropTo(split6[0]);
							bean.setPropRelName(split6[1]);
							bean.setPropName(split6[2]);
							if ("lov".equals(bean.getPropType())) {
								// 得到lov放入lovMap
								String[] split7 = split5[0].split(":");
								String lovName = split7[1];
								HashMap<String, String> lovMap = new LinkedHashMap<String, String>();
								// JComboBox<String> combox = new JComboBox<String>();
								try {
									String desType = newTypeBuffer.toString();
									if ("Rev".equals(bean.getPropTo())) {
										desType = desType + "Revision";
									} else if ("Form".equals(bean.getPropTo())) {
										desType = desType + "RevisionMaster";
									}
									TCComponentType localTCComponentType = session.getTypeComponent(desType);
									TCPropertyDescriptor descriptor = localTCComponentType
											.getPropertyDescriptor(bean.getPropRelName());
									LOVDisplayer combo = new LOVDisplayer(descriptor);
									getLov(lovMap, lovName, null);
									bean.setCombox(combo);
								} catch (TCException e) {
									e.printStackTrace();
								}
								bean.setLovMap(lovMap);
								// bean.setCombox(combox);
							}
						}
						beanList.add(bean);
					}
					break;
				}
			}
		}
	}

	public static String getTCPropertyValue(TCComponentItemRevision rev, String specialValue, ControlBean bean) {
		try {
			String[] split = specialValue.split("\\.");
			TCComponent center = null;
			if (split.length == 2 || split.length == 3) {
				switch (split[0]) {
				case "Rev":
					center = rev;
					break;
				case "Item":
					center = rev.getItem();
					break;
				case "Form":
					center = rev.getRelatedComponent("IMAN_master_form_rev");
					break;
				default:
					break;
				}
				String value = "";
				if ("date".equals(bean.getPropType())) {
					System.out.println("当前的属性真实名为：" + split[1]);
					SimpleDateFormat sdf = new SimpleDateFormat("yyyy-M-dd HH:mm");
					if (center.getDateProperty(split[1]) != null) {
						value = sdf.format(center.getDateProperty(split[1]));
					}
				} else {
					value = center.getStringProperty(split[1]);
				}
				if (split.length == 3) {
					bean.setPropName(split[2]);
				}
				return value;
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return "";
	}
}