/*jadclipse*/// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.

package com.teamcenter.rac.kernel;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import javax.xml.parsers.ParserConfigurationException;

import org.apache.log4j.Logger;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.Platform;
import org.xml.sax.SAXException;

import com.teamcenter.rac.aif.AIFShell;
import com.teamcenter.rac.aif.kernel.AIFComponentContext;
import com.teamcenter.rac.aif.kernel.InterfaceAIFComponentOpen;
import com.teamcenter.rac.services.IDocumentManagementService;
import com.teamcenter.rac.util.FileUtility;
import com.teamcenter.rac.util.Instancer;
import com.teamcenter.rac.util.OSGIUtil;
import com.teamcenter.rac.util.Registry;
import com.teamcenter.rac.util.log.Debug;

// Referenced classes of package com.teamcenter.rac.kernel:
//            TCComponent, TCException, TCSession, AEShellManager, 
//            TCComponentDatasetType, TCRDVService, TCComponentEncapsulation, KernelPlugin, 
//            TCReservationService, TCComponentUser, TCComponentSite, TCProperty, 
//            TCComponentType, TCPreferenceService, TCComponentDatasetDefinition, TCComponentTool, 
//            ToolOperationInfo, NamedReferenceContext, TCComponentDatasetContext, AEShell, 
//            TypeInfo, InterfaceDatasetAction, PreActionShell, AliasOpenAction, 
//            AbstractDatasetOpenPreAction, TCComponentGroup, TCComponentContextList, TCComponentTcFile, 
//            TCComponentDatasetDefinitionType, TCComponentMSExcelX

public class TCComponentDataset extends TCComponent implements
		InterfaceAIFComponentOpen, Comparable {

	public TCComponentDataset() {
		System.out.println("hello TC!");
		inIcContext = false;
		paramArrayList = new ArrayList();
		isOfficeType = false;
	}

	public int compareTo(TCComponentDataset tccomponentdataset) {
		return toString().compareTo(tccomponentdataset.toString());
	}

	public String getWorkingDir() throws TCException {
		Date date = new Date();
		long l = date.getTime();
		String s = FileUtility.getExportDir();
		TCSession tcsession = getSession();
		String s1 = tcsession.getUserName();
		AEShellManager aeshellmanager = tcsession.getAEShellManager();
		int i = aeshellmanager.size();
		String s2 = (new StringBuilder("tc_")).append(s1).append("_").append(i)
				.append("_").append(l).toString();
		String s3 = (new StringBuilder(String.valueOf(s)))
				.append(File.separator).append(s2).toString();
		Assert.isTrue(
				FileUtility.isValidPathString(s3),
				(new StringBuilder(String.valueOf(Registry.getRegistry(
						TCComponentDataset.class).getString(
						FileUtility.getInvalidPathMessage())))).append(" - ")
						.append(s3).toString());
		File file = new File(s3);
		if (!file.exists() && !file.mkdir()) {
			Registry registry = getSession().getRegistry();
			throw TCComponent.handleException((new StringBuilder(String
					.valueOf(registry.getString("createDirFailed"))))
					.append(' ').append(s3).append("\n\n")
					.append(registry.getString("checkTCExportDir")).toString());
		} else {
			setCurrentWorkingDir(s3);
			return s3;
		}
	}

	public void removeWorkingDir(String s) throws TCException {
		Assert.isTrue(
				FileUtility.isValidPathString(s),
				(new StringBuilder(String.valueOf(Registry.getRegistry(
						FileUtility.class).getString(
						FileUtility.getInvalidPathMessage())))).append(" - ")
						.append(s).toString());
		File file = new File(s);
		String as[] = file.list();
		if (as != null) {
			int i = as.length;
			for (int j = 0; j < i; j++) {
				File file1 = new File(file, as[j]);
				try {
					file1.delete();
				} catch (SecurityException securityexception) {
					throw TCComponent.handleException(securityexception);
				}
			}

		}
		if (!file.delete())
			logger.debug((new StringBuilder("Unable to delete directory: "))
					.append(file.getAbsolutePath()).toString());
	}

	public TCComponent[] getNamedRefComponents(String s) throws TCException {
		return ((TCComponentDatasetType) getTypeComponent())
				.getNamedRefComponents(this, s);
	}

	public TCComponent getNamedRefComponent(String s) throws TCException {
		TCComponent atccomponent[] = ((TCComponentDatasetType) getTypeComponent())
				.getNamedRefComponents(this, s);
		return atccomponent != null && atccomponent.length >= 1 ? atccomponent[0]
				: null;
	}

	public int getHighestRevision() throws TCException {
		return ((TCComponentDatasetType) getTypeComponent())
				.getHighestRevision(this);
	}

	public File[] getFiles(String s) throws TCException {
		return ((TCComponentDatasetType) getTypeComponent()).getFiles(this, s);
	}

	public File[] getFiles(String s, String s1) throws TCException {
		return ((TCComponentDatasetType) getTypeComponent()).getFiles(this, s,
				s1);
	}

	public File getFile(String s, String s1, String s2) throws TCException {
		return ((TCComponentDatasetType) getTypeComponent()).getFile(this, s,
				s1, s2);
	}

	public File getFile(String s, String s1) throws TCException {
		return ((TCComponentDatasetType) getTypeComponent()).getFile(this, s,
				s1);
	}

	public void replaceFiles(File afile[], String as[], String as1[],
			String as2[]) throws TCException {
		((TCComponentDatasetType) getTypeComponent()).replaceFiles(this, afile,
				as, as1, as2);
	}

	public TCComponentDataset revise() throws TCException {
		return ((TCComponentDatasetType) getTypeComponent()).revise(this);
	}

	public TCComponentDataset latest() throws TCException {
		return ((TCComponentDatasetType) getTypeComponent()).latest(this);
	}

	public void setFiles(String as[], String as1[], String as2[], String as3[])
			throws TCException {
		((TCComponentDatasetType) getTypeComponent()).setFiles(this, as, as1,
				as2, as3);
	}

	public void setFiles(String as[], String as1[], String as2[], String as3[],
			int i) throws TCException {
		((TCComponentDatasetType) getTypeComponent()).setFiles(this, as, as1,
				as2, as3, i);
	}

	public TCComponentDataset setFiles(String s, String s1, String s2,
			String as[], String as1[]) throws TCException {
		return ((TCComponentDatasetType) getTypeComponent()).setFiles(s, s1,
				s2, as, as1);
	}

	public void setFiles(String as[], String as1[]) throws TCException {
		((TCComponentDatasetType) getTypeComponent()).setFiles(this, as, as1);
	}

	public void addNamedReference(TCComponent tccomponent, String s)
			throws TCException {
		((TCComponentDatasetType) getTypeComponent()).addNamedReference(this,
				tccomponent, s);
	}

	public void removeNamedReference(String s) throws TCException {
		((TCComponentDatasetType) getTypeComponent()).removeNamedReference(
				this, s);
		fireComponentChangeEvent();
	}

	public void removeFiles(String as[], String as1[]) throws TCException {
		((TCComponentDatasetType) getTypeComponent())
				.removeFiles(this, as, as1);
		fireComponentChangeEvent();
	}

	public void removeFiles(String s) throws TCException {
		((TCComponentDatasetType) getTypeComponent()).removeFiles(this, s);
		fireComponentChangeEvent();
	}

	public TCComponentDataset[] getAllVersions() throws TCException {
		return ((TCComponentDatasetType) getTypeComponent())
				.getAllVersions(this);
	}

	public TCComponentDataset getVersion0() throws TCException {
		return ((TCComponentDatasetType) getTypeComponent()).getVersion0(this);
	}

	public String[] getPrimaryFileNames(TCComponent tccomponent, int i)
			throws TCException {
		return ((TCComponentDatasetType) getTypeComponent())
				.getPrimaryFileNames(this, tccomponent, i);
	}

	public String[] getAIEPrimaryFileNames(TCComponent tccomponent, int i)
			throws TCException {
		return ((TCComponentDatasetType) getTypeComponent())
				.getPrimaryFileNames(this, tccomponent, i);
	}

	public String[] getFileNames(String s) throws TCException {
		return ((TCComponentDatasetType) getTypeComponent()).getFileNames(this,
				s);
	}

	@Override
	public void print() throws TCException, IOException {
		String s = getWorkingDir();
		reqDir = s;
		boolean flag = false;
		Assert.isTrue(
				FileUtility.isValidPathString(s),
				(new StringBuilder(String.valueOf(Registry.getRegistry(
						FileUtility.class).getString(
						FileUtility.getInvalidPathMessage())))).append(" - ")
						.append(s).toString());
		File file = new File(s);
		if (file.isDirectory()) {
			prepareToolForLaunching(null, s, flag, null, 2, 0, false);
		} else {
			TCSession tcsession = getSession();
			String s1 = tcsession.getRegistry().getString("createDirFailed");
			throw TCComponent.handleException((new StringBuilder(String
					.valueOf(s1))).append(' ').append(s).toString());
		}
	}

	public void copyGrdvTransformFiles(String s) {
		TCSession tcsession = getSession();
		try {
			String as[] = tcsession.getServerConfigInfo();
			String s1 = as[2];
			String s2 = (new StringBuilder(String.valueOf(s1))).append("//")
					.append("grdv_transform_files").toString();
			String s3 = (new StringBuilder(String.valueOf(s2))).append("//")
					.append("js").toString();
			String s4 = (new StringBuilder(String.valueOf(s2))).append("//")
					.append("css").toString();
			String s5 = (new StringBuilder(String.valueOf(s2))).append("//")
					.append("images").toString();
			String s6 = "BINARY";
			boolean flag = false;
			TCRDVService tcrdvservice = tcsession.getRDVService();
			Assert.isTrue(
					FileUtility.isValidPathString(s),
					(new StringBuilder(String.valueOf(Registry.getRegistry(
							FileUtility.class).getString(
							FileUtility.getInvalidPathMessage()))))
							.append(" - ").append(s).toString());
			File file = new File((new StringBuilder(String.valueOf(s)))
					.append("//").append("js").toString());
			if (file.mkdir()) {
				tcrdvservice.getFile(s3, "common.js", file.getAbsolutePath(),
						"common.js", s6, flag);
				tcrdvservice.getFile(s3, "dialog.js", file.getAbsolutePath(),
						"dialog.js", s6, flag);
				tcrdvservice.getFile(s3, "excel.js", file.getAbsolutePath(),
						"excel.js", s6, flag);
				tcrdvservice.getFile(s3, "filter.js", file.getAbsolutePath(),
						"filter.js", s6, flag);
				tcrdvservice.getFile(s3, "select.js", file.getAbsolutePath(),
						"select.js", s6, flag);
				tcrdvservice.getFile(s3, "select_row.js",
						file.getAbsolutePath(), "select_row.js", s6, flag);
				tcrdvservice.getFile(s3, "sortabletable.js",
						file.getAbsolutePath(), "sortabletable.js", s6, flag);
			}
			File file1 = new File((new StringBuilder(String.valueOf(s)))
					.append("//").append("css").toString());
			if (file1.mkdir()) {
				tcrdvservice.getFile(s4, "dialog.css", file1.getAbsolutePath(),
						"dialog.css", s6, flag);
				tcrdvservice.getFile(s4, "excel.css", file1.getAbsolutePath(),
						"excel.css", s6, flag);
			}
			File file2 = new File((new StringBuilder(String.valueOf(s)))
					.append("//").append("images").toString());
			if (file2.mkdir()) {
				tcrdvservice.getFile(s5, "downsimple.png",
						file2.getAbsolutePath(), "downsimple.png", s6, flag);
				tcrdvservice.getFile(s5, "upsimple.png",
						file2.getAbsolutePath(), "upsimple.png", s6, flag);
			}
		} catch (Exception exception) {
			logger.error(exception.getLocalizedMessage(), exception);
		}
	}

	public void print(TCComponent tccomponent, String s, String s1, String s2)
			throws TCException, IOException {
		boolean flag = true;
		if (s == null) {
			s = getWorkingDir();
			flag = false;
		}
		File file = new File(s);
		if (file.isDirectory()) {
			File file1 = getFile(s1, s2, s);
			prepareToolForLaunching(tccomponent, s, flag, file1.getPath(), 2,
					0, false);
		} else {
			TCSession tcsession = getSession();
			String s3 = tcsession.getRegistry().getString("createDirFailed");
			throw TCComponent.handleException((new StringBuilder(String
					.valueOf(s3))).append(' ').append(s).toString());
		}
	}

	public void openForView() throws TCException, IOException {
		boolean flag = false;
		try {
			open(flag);
		} catch (TCException tcexception) {
			throw tcexception;
		}
	}

	public void openForEdit() throws TCException, IOException {
		boolean flag = true;
		try {
			System.out.println("aaaa   aaaaaa");
			open(flag);
			System.out.println("bbbb   bbbbbb");
		} catch (TCException tcexception) {
			throw tcexception;
		}
	}

	@Override
	public void open() throws TCException, IOException {
		boolean flag = true;
		try {
			open(flag);
		} catch (TCException tcexception) {
			throw tcexception;
		}
	}

	public void open(boolean flag) throws TCException, IOException {
		if (logger.isDebugEnabled())
			logger.debug((new StringBuilder("==> "))
					.append(getClass().getName()).append(".open() [")
					.append(toString()).append("], type [").append(getType())
					.append("], url [").append(url).append("]").toString());
		boolean flag1 = false;
		boolean flag2 = false;
		boolean flag3 = false;
		if (flag)
			flag3 = isEditable();
		if (!flag2 && !flag3)
			flag1 = openWithAppLauncher(this, false);
		else
			flag1 = openWithAppLauncher(this, flag);
		if (flag1)
			return;
		flag1 = TCComponentEncapsulation.openAdvancedEncapsulation(this);
		if (!flag1 && url != null) {
			if (logger.isDebugEnabled())
				logger.debug(" startTcOffice...");
			flag1 = startTcOffice();
		}
		System.out.println("cccc cccc");
		if (!flag1)
			open(flag3, flag);
		System.out.println("ddddd   dddd");

	}

	public boolean isEditable() throws TCException {
		boolean flag = false;
		boolean flag1 = false;
		TCReservationService tcreservationservice = (TCReservationService) OSGIUtil
				.getService(KernelPlugin.getDefault(),
						TCReservationService.class);
		flag = tcreservationservice.isAutoCheckoutEnabled();
		if (logger.isDebugEnabled())
			logger.debug((new StringBuilder("TC_Auto_Checkout [")).append(flag)
					.append("]").toString());
		if (flag || tcreservationservice.isReserved(this))
			flag1 = okToModify();
		return flag1;
	}

	private boolean openWithAppLauncher(TCComponentDataset tccomponentdataset,
			boolean flag) {
		if (logger.isDebugEnabled())
			logger.debug((new StringBuilder("try to open dataset ["))
					.append(tccomponentdataset.toString())
					.append("] with app launcher").toString());
		boolean flag1 = false;
		if (!isOfficeType)
			return flag1;
		boolean flag3 = checkUseAppLauncherConfig();
		if (!flag3) {
			return flag1;
		} else {
			IDocumentManagementService idocumentmanagementservice = (IDocumentManagementService) OSGIUtil
					.getService(KernelPlugin.getDefault(),
							IDocumentManagementService.class);
			boolean flag2 = idocumentmanagementservice.openWithAppLauncher(
					tccomponentdataset, flag);
			return flag2;
		}
	}

	private boolean checkUseAppLauncherConfig() {
		TCSession tcsession = getSession();
		boolean flag = tcsession.getRegistry().getBoolean("useAppLauncher",
				false);
		return flag;
	}

	public void setOfficeType(boolean flag) {
		isOfficeType = flag;
	}

	public void open(boolean flag, boolean flag1) throws TCException,
			IOException {
		if (logger.isDebugEnabled())
			logger.debug((new StringBuilder(String
					.valueOf(getClass().getName())))
					.append(".open(reserveFlag [").append(flag).append("]) [")
					.append(toString()).append("], type [").append(getType())
					.append("]").toString());
		int i = 0;
		try {
			if (flag)
				i = reserveDataset();
			String s = getWorkingDir();
			reqDir = s;
			boolean flag2 = false;
			if (logger.isDebugEnabled())
				logger.debug((new StringBuilder("  checkedOutState "))
						.append(i).append(", workdir [").append(s).append("]")
						.toString());
			File file = new File(s);
			if (file.isDirectory()) {
				prepareToolForLaunching(null, s, flag2, null, 3, i, flag1);
			} else {
				TCSession tcsession1 = getSession();
				if (flag) {
					TCReservationService tcreservationservice1 = tcsession1
							.getReservationService();
					tcreservationservice1.cancelReservation(this);
				}
				String s1 = tcsession1.getRegistry().getString(
						"createDirFailed");
				throw TCComponent.handleException((new StringBuilder(String
						.valueOf(s1))).append(' ').append(s).toString());
			}
		} catch (TCException tcexception) {
			if (flag && i == 1) {
				TCSession tcsession = getSession();
				TCReservationService tcreservationservice = tcsession
						.getReservationService();
				tcreservationservice.cancelReservation(this);
			}
			throw tcexception;
		}
	}

	public void setUrlCookie(String s, String s1) {
		url = s;
		cookie = s1;
	}

	private boolean startTcOffice() {
		if (url == null)
			return false;
		byte byte0 = ((byte) (cookie != null ? 2 : 1));
		String as[] = new String[byte0];
		as[0] = (new StringBuilder("-url=")).append(url).toString();
		if (cookie != null)
			as[1] = (new StringBuilder("-cookie=")).append(cookie).toString();
		AIFShell aifshell = new AIFShell("");
		aifshell.setCommand(as);
		aifshell.setAction("O");
		aifshell.start();
		return true;
	}

	protected int reserveDataset() throws TCException {
		if (logger.isDebugEnabled())
			logger.debug((new StringBuilder(String
					.valueOf(getClass().getName())))
					.append(".reserveDataset():  name [").append(toString())
					.append("], type [").append(getType()).append("]")
					.toString());
		byte byte0 = 0;
		TCSession tcsession = getSession();
		TCReservationService tcreservationservice = tcsession
				.getReservationService();
		try {
			if (!tcreservationservice.isReserved(this)) {
				tcreservationservice.reserve(this, "", "", (short) 5);
				byte0 = 1;
			} else {
				TCComponent tccomponent = tcreservationservice
						.getReservation(this);
				boolean flag = false;
				boolean flag1 = false;
				TCComponentUser tccomponentuser = (TCComponentUser) tccomponent
						.getRelatedComponent("user_object");
				if (tccomponentuser == null)
					flag1 = true;
				TCComponentSite tccomponentsite = (TCComponentSite) tccomponent
						.getRelatedComponent("remote_site");
				if (tccomponentsite == null)
					flag = true;
				boolean flag2 = false;
				flag2 = tccomponent.getLogicalProperty("site_reserved");
				if (flag1) {
					if (flag2 && flag) {
						tcreservationservice.reserve(this, "", "", (short) 5);
						byte0 = 1;
					}
				} else {
					String s = tccomponentuser.getUserId();
					String s1 = tcsession.getUser().getUserId();
					if (!s1.equals(s)) {
						String s2 = tcsession.getRegistry().getString(
								"failedToOpen");
						throw TCComponent.handleException(new TCException(
								(new StringBuilder(String.valueOf(s2)))
										.append(' ').append(s).toString()));
					}
					tccomponent.clearCache("reservation_type");
					TCProperty tcproperty = tccomponent
							.getTCProperty("reservation_type");
					int i = tcproperty.getIntValue();
					if (i == 5)
						byte0 = 1;
					else if (i == 6) {
						tcreservationservice.reserve(this, "", "", (short) 5);
						byte0 = 1;
					} else {
						byte0 = 2;
					}
				}
			}
		} catch (TCException tcexception) {
			throw tcexception;
		}
		return byte0;
	}

	void prepareToolForLaunching(TCComponent tccomponent, String s,
			boolean flag, String s1, int i, int j, boolean flag1)
			throws IOException, TCException {
		if (logger.isDebugEnabled())
			logger.debug((new StringBuilder(String
					.valueOf(getClass().getName())))
					.append(".prepareToolForLaunching():  name [")
					.append(toString()).append("], type [").append(getType())
					.append("]\n").append(" selectedTool [")
					.append(tccomponent).append("], workdir [").append(s)
					.append("], userDefinedDir [").append(flag)
					.append("], primaryFileName [").append(s1)
					.append("], action [").append(getAction(i))
					.append("], reservedState [").append(j).append("]")
					.toString());
		boolean flag2 = true;
		String s2 = null;
		String s3 = null;
		String s4 = null;
		TCComponentDatasetDefinition tccomponentdatasetdefinition = getDatasetDefinitionComponent();
		TCComponentDatasetType tccomponentdatasettype = (TCComponentDatasetType) getTypeComponent();
		TCSession tcsession = getSession();
		TCPreferenceService tcpreferenceservice = tcsession
				.getPreferenceService();
		String s5 = getTypeComponent().getTypeName();
		if (tccomponent == null)
			tccomponent = getSelectedTool(tccomponentdatasettype, tcsession,
					s5, flag1 ? "_Tool" : "_Default_View_Tool");
		if (tccomponent == null) {
			if (logger.isDebugEnabled())
				logger.debug((new StringBuilder(
						"prepareToolForLaunching(): Could not find a valid tool of dataset ["))
						.append(this).append("], give up").toString());
			return;
		}
		String s6 = (new StringBuilder("TC_")).append(s5).append("_")
				.append(tccomponent.toString()).append("_searchBy").toString();

		String s7 = tcpreferenceservice.getStringValue(s6);

		System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>  0000 =" + s6
				+ " | " + s7);
		NamedReferenceContext anamedreferencecontext[] = tccomponentdatasetdefinition
				.getNamedReferenceContexts();
		if (logger.isDebugEnabled())
			logger.debug((new StringBuilder(
					"prepareToolForLaunching(): searchKey ["))
					.append(s6)
					.append("] value [")
					.append(s7)
					.append("], ")
					.append(anamedreferencecontext != null ? anamedreferencecontext.length
							: 0).append(" namedReferences").toString());
		if (anamedreferencecontext == null || anamedreferencecontext.length < 1) {
			if (logger.isDebugEnabled())
				logger.debug((new StringBuilder(
						"prepareToolForLaunching(): Could not find namedReferences of dataset ["))
						.append(this).append("], give up").toString());
			return;
		}
		NamedReferenceContext namedreferencecontext = null;
		try {
			if (s1 == null) {
				namedreferencecontext = ((TCComponentDatasetType) getTypeComponent())
						.getPrimaryNamedRefInfo(this, tccomponent, i);
				if (logger.isDebugEnabled())
					logger.debug((new StringBuilder(
							"prepareToolForLaunching(): NamedReferenceContext ["))
							.append(namedreferencecontext).append("]")
							.toString());
			} else {
				ToolOperationInfo atooloperationinfo[] = getDatasetDefinitionComponent()
						.getToolOperationRefs((TCComponentTool) tccomponent, i);
				if (logger.isDebugEnabled())
					logger.debug((new StringBuilder(
							"prepareToolForLaunching(): "))
							.append(atooloperationinfo != null ? atooloperationinfo.length
									: 0).append(" ToolOperationInfo")
							.toString());
				if (atooloperationinfo == null
						|| atooloperationinfo.length == 0) {
					logger.debug("Found no ToolOperationInfo, throw exception");
					Registry registry = Registry.getRegistry(this);
					throw TCComponent.handleException(registry
							.getString("noNamedReference"));
				}
				if (dsNamedRefs == null)
					dsNamedRefs = getDatasetDefinitionComponent()
							.getNamedReferenceContexts();
				String s8 = null;
				int k = -1;
				int l = s1.lastIndexOf(".");
				if (l > -1)
					s8 = s1.substring(l);
				for (int i1 = 0; i1 < atooloperationinfo.length && k == -1; i1++)
					if (atooloperationinfo[i1].getExportVerdict() != 0) {
						String s10 = atooloperationinfo[i1].getReference();
						for (int k1 = 0; dsNamedRefs != null
								&& k1 < dsNamedRefs.length; k1++) {
							if (!dsNamedRefs[k1].getNamedReference()
									.equals(s10))
								continue;
							String s12 = dsNamedRefs[k1].getFileTemplate();
							if (s8 != null) {
								if (s12.endsWith(s8))
									k = k1;
							} else if (s12.equals("*") || s12.equals(".*")
									|| s12.equals("*.*"))
								k = k1;
							break;
						}

					}

				if (k > -1) {
					String s9 = tccomponent.getProperty("site_classification");
					namedreferencecontext = new NamedReferenceContext(
							dsNamedRefs[k].getNamedReference(),
							dsNamedRefs[k].getFileFormat(), s8, s1, s9);
					if (logger.isDebugEnabled())
						logger.debug((new StringBuilder(
								"could not match reference, use mimetype ["))
								.append(s9).append("] of selectedtool [")
								.append(tccomponent)
								.append("], NamedReferenceContext [")
								.append(namedreferencecontext).append("]")
								.toString());
				}
			}
		} catch (TCException tcexception) {
			logger.debug(tcexception.getLocalizedMessage(), tcexception);
			throw tcexception;
		}
		ToolOperationInfo atooloperationinfo1[] = null;
		atooloperationinfo1 = tccomponentdatasetdefinition
				.getToolOperationRefs((TCComponentTool) tccomponent, i);
		if (logger.isDebugEnabled())
			logger.debug((new StringBuilder("Got "))
					.append(atooloperationinfo1 != null ? atooloperationinfo1.length
							: 0).append(" ToolOperationInfo for selectedTool[")
					.append(tccomponent).append("]").toString());
		if (atooloperationinfo1 == null || atooloperationinfo1.length < 1) {
			if (logger.isDebugEnabled())
				logger.debug((new StringBuilder(
						"prepareToolForLaunching(): Could not find ToolOperationInfo of dataset ["))
						.append(this).append("], give up").toString());
			return;
		}
		boolean flag3 = true;
		if (j == 0)
			flag3 = false;
		TCComponentDatasetContext tccomponentdatasetcontext = tccomponentdatasettype
				.getFiles(this, tccomponent, i, s, flag3);
		if (logger.isDebugEnabled())
			logger.debug((new StringBuilder("TCComponentDatasetContext ["))
					.append(tccomponentdatasetcontext).append("]").toString());
		boolean flag4 = false;
		File afile[] = tccomponentdatasetcontext.getFiles();
		if ((i == 2 || i == 9) && afile.length == 0) {
			removeWorkingDir(s);
			return;
		}
		if (namedreferencecontext == null) {
			namedreferencecontext = tccomponentdatasettype
					.getPrimaryNamedRefInfo(this, tccomponent, i);
			if (logger.isDebugEnabled())
				logger.debug((new StringBuilder("DatasetType ["))
						.append(tccomponentdatasettype)
						.append("] getPrimaryNamedRefInfo() for tool [")
						.append(tccomponent).append("] action ")
						.append(getAction(i)).append(" returns [")
						.append(namedreferencecontext).append("]").toString());
			if (namedreferencecontext == null
					|| namedreferencecontext.getNamedReference() == null) {
				namedreferencecontext = anamedreferencecontext[0];
				if (logger.isDebugEnabled())
					logger.debug((new StringBuilder(
							"    default to use the first namedref ["))
							.append(namedreferencecontext).append("]")
							.toString());
			}
		}
		s3 = namedreferencecontext.getFileName();
		s2 = namedreferencecontext.getNamedReference();
		s4 = namedreferencecontext.getMimeType();
		if (s4 == null) {
			s4 = tccomponentdatasetdefinition.getToolMimeType(tccomponent);
			if (logger.isDebugEnabled())
				logger.debug((new StringBuilder("get tool_mimetype ["))
						.append(s4).append("] from datasettype [")
						.append(tccomponentdatasetdefinition)
						.append("] for selectedtool [").append(tccomponent)
						.append("]").toString());
		}
		File file = null;
		if (afile != null && afile.length > 0) {
			if (s1 != null) {
				File afile1[];
				int i2 = (afile1 = afile).length;
				for (int l1 = 0; l1 < i2; l1++) {
					File file1 = afile1[l1];
					String s13 = file1.getName();
					if (!s13.equalsIgnoreCase(s1))
						continue;
					file = file1;
					break;
				}

			}
			if (file == null)
				file = afile[0];
			flag2 = true;
			if (logger.isDebugEnabled())
				logger.debug((new StringBuilder("Got fileToLaunch ["))
						.append(file).append("] from ").append(afile.length)
						.append(" exportedFiles").toString());
		} else {
			int j1;
			for (j1 = 0; j1 < atooloperationinfo1.length; j1++) {
				if (tccomponent != atooloperationinfo1[j1].getTool()
						|| !namedreferencecontext.getNamedReference()
								.equalsIgnoreCase(
										atooloperationinfo1[j1].getReference()))
					continue;
				flag2 = atooloperationinfo1[j1].getExportVerdict() > 0;
				break;
			}

			if (j1 >= atooloperationinfo1.length)
				return;
			if (flag2) {
				if (s3 == null)
					s3 = getProperty("object_name");
				file = new File(s, s3);
				if (!file.createNewFile())
					logger.debug((new StringBuilder("Unable to create file: "))
							.append(file.getAbsolutePath()).toString());
				flag4 = true;
				if (logger.isDebugEnabled())
					logger.debug((new StringBuilder("create fileToLaunch ["))
							.append(file)
							.append("] since no existing files to export")
							.toString());
			}
		}
		if (file != null)
			file.setWritable(flag1);
		String s11;
		if (flag2) {
			s11 = file.getPath();
		} else {
			if (s == null && s3 == null)
				s11 = null;
			else if (s == null)
				s11 = s3;
			else if (s3 == null)
				s11 = s;
			else
				s11 = (new StringBuilder(String.valueOf(s)))
						.append(File.separator).append(s3).toString();
			afile = null;
		}
		AEShell aeshell = new AEShell(tccomponentdatasetcontext, s, flag, i);
		aeshell.setExportedFiles(afile);
		TCComponentDataset atccomponentdataset[] = tccomponentdatasettype
				.getAllVersions(this);
		aeshell.setSelectedDataset(this);
		aeshell.setRev0DS(atccomponentdataset[0]);
		aeshell.setSelectedFileName(s11);
		aeshell.setSelectedMimeType(s4);
		aeshell.setSelectedNamedRef(s2);
		aeshell.setReserveOption(j);
		aeshell.setSelectedTool(tccomponent);
		aeshell.setReadOnly(!flag3);
		if (s7 != null && !s7.isEmpty())
			aeshell.setSearchBy(s7);
		AEShellManager aeshellmanager = tcsession.getAEShellManager();
		if (flag1) {
			List list = getEditableOpenFilesOfDSInSession();
			File afile2[] = aeshell.askExportedFiles();
			if (flag4) {
				afile2 = new File[1];
				afile2[0] = file;
			}
			if (afile2 != null) {
				File afile3[];
				int k2 = (afile3 = afile2).length;
				for (int j2 = 0; j2 < k2; j2++) {
					File file2 = afile3[j2];
					String s15 = file2.getName();
					Assert.isTrue(
							FileUtility.isValidPathString(s15),
							(new StringBuilder(
									String.valueOf(Registry
											.getRegistry(FileUtility.class)
											.getString(
													FileUtility
															.getInvalidPathMessage()))))
									.append(" - ").append(s15).toString());
					if (!list.contains(s15))
						continue;
					file2.setWritable(false);
					aeshell.setReadOnly(true);
					flag1 = false;
					break;
				}

			}
		}
		aeshellmanager.addShell(aeshell);
		if (flag4)
			aeshell.setNewFileCreatedTime(file);
		if (logger.isDebugEnabled())
			logger.debug("prepareToolForLaunching(): calling launchingTool()");
		String s14 = "Edit";
		if (!flag1)
			s14 = "View";
		launchingTool(aeshell, i, s14);
		System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>  6666666");
		if (Platform.getOS().equals("win32")
				&& tccomponentdatasettype.toString().equals("XMLAuditLog"))
			copyGrdvTransformFiles(s);
		System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>  7777777");
	}

	private List getEditableOpenFilesOfDSInSession() throws TCException {
		TCSession tcsession = getSession();
		AEShellManager aeshellmanager = tcsession.getAEShellManager();
		AEShell aaeshell[] = aeshellmanager.getShells();
		ArrayList arraylist = new ArrayList();
		AEShell aaeshell1[];
		int j = (aaeshell1 = aaeshell).length;
		for (int i = 0; i < j; i++) {
			AEShell aeshell = aaeshell1[i];
			File afile[] = aeshell.askExportedFiles();
			TCComponentDataset tccomponentdataset = aeshell
					.askSelectedDataset();
			if (tccomponentdataset == this)
				if (afile != null) {
					File afile1[];
					int l = (afile1 = afile).length;
					for (int k = 0; k < l; k++) {
						File file = afile1[k];
						boolean flag = file.canWrite();
						if (flag)
							arraylist.add(file.getName());
					}

				} else {
					String s = aeshell.askSelectedFileName();
					File file1 = new File(s);
					boolean flag1 = file1.canWrite();
					if (flag1)
						arraylist.add(file1.getName());
				}
		}

		return arraylist;
	}

	private TCComponent getSelectedTool(
			TCComponentDatasetType tccomponentdatasettype, TCSession tcsession,
			String s, String s1) throws TCException {
		TCComponent tccomponent = null;
		try {
			String s2 = (new StringBuilder("TC_")).append(s).append(s1)
					.toString();
			String s3 = tcsession.getPreferenceService().getStringValue(s2);
			if (logger.isDebugEnabled())
				logger.debug((new StringBuilder("use preference [")).append(s2)
						.append("] to find default tool [").append(s3)
						.append("]").toString());
			if (s3 != null && !s3.isEmpty()) {
				TCComponentType tccomponenttype = tcsession
						.getTypeComponent("Tool");
				com.teamcenter.rac.kernel.TypeInfo typeinfo = tccomponenttype
						.getTcTypes("Tool", false);
				if (typeinfo != null) {
					TCComponent tccomponent1 = typeinfo
							.getTypeComponentFromName(s3);
					if (tccomponent1 != null)
						tccomponent = tccomponent1;
				}
			}
			if (tccomponent == null)
				try {
					tccomponent = tccomponentdatasettype.getDefaultTool(this);
					if (logger.isDebugEnabled())
						logger.debug((new StringBuilder("use default tool ["))
								.append(tccomponent).append("]").toString());
				} catch (TCException tcexception1) {
					logger.info(tcexception1.getLocalizedMessage(),
							tcexception1);
					throw tcexception1;
				} catch (Exception exception1) {
					logger.error(exception1.getLocalizedMessage(), exception1);
				}
		} catch (TCException tcexception) {
			logger.info(tcexception.getLocalizedMessage(), tcexception);
			throw tcexception;
		} catch (Exception exception) {
			throw TCComponent.handleException(exception);
		}
		return tccomponent;
	}

	void launchingTool(AEShell aeshell, int i, String s) throws TCException {
		String s1 = getType();
		Registry registry = Registry.getRegistry(this);
		if (logger.isDebugEnabled())
			logger.debug((new StringBuilder("launchingTool(): AEShell ["))
					.append(aeshell).append("], action ").append(getAction(i))
					.append(" for dataset [").append(toString()).append("]")
					.toString());
		String s2 = null;
		String s4 = null;
		String s5 = aeshell.askSelectedTool().toString();
		String s6 = ((TCComponentDatasetType) getTypeComponent())
				.getDefaultTool(this).toString();
		if (s5.equals(s6))
			s4 = getApplRegKey(s1);
		if (s4 != null)
			s2 = (new StringBuilder(String.valueOf(s4))).append(
					".ACTION_OBJECT").toString();
		else
			s2 = (new StringBuilder(String.valueOf(s1))).append(
					".ACTION_OBJECT").toString();
		String as[] = registry.getStringArray(s2, null, null);
		if (as == null) {
			String s3 = (new StringBuilder(String.valueOf(getType()))).append(
					".ACTION_OBJECT").toString();
			as = registry.getStringArray(s3, null, null);
		}
		if (as != null) {
			int j = as.length;
			Object obj = null;
			for (int k = 0; k < j; k++) {
				InterfaceDatasetAction interfacedatasetaction = (InterfaceDatasetAction) Instancer
						.newInstance(as[k]);
				if (interfacedatasetaction != null) {
					int l = interfacedatasetaction.preProcess(this, aeshell, i);
					if (l < 0) {
						interfacedatasetaction = null;
						TCSession tcsession = getSession();
						AEShellManager aeshellmanager = tcsession
								.getAEShellManager();
						aeshellmanager.removeShell(aeshell);
						return;
					}
					if (l == 0)
						k = j;
				}
				interfacedatasetaction = null;
			}

		}
		TCComponent tccomponent = aeshell.askSelectedTool();
		TCComponent tccomponent1 = getDatasetDefinitionComponent()
				.getPreAction(tccomponent, i);
		String s7 = null;
		if (tccomponent1 != null)
			s7 = getDatasetDefinitionComponent().getToolMimeType(tccomponent1);
		if (tccomponent1 != null && s7 != null && !s7.isEmpty()) {
			String s8 = aeshell.askSelectedFileName();
			String s9 = aeshell.askSelectedNamedRef();
			String as1[] = getDatasetDefinitionComponent()
					.getPreActionParameters(tccomponent, i);
			String as2[] = buildInputParams(s8, as1, s9, i);
			AIFShell aifshell = new AIFShell("");
			if (as2 != null && as2.length > 0)
				aifshell.setCommand(as2);
			aifshell.setMimeType(s7);
			String s10 = tccomponent1.getStringProperty("symbol_name");
			int i1 = s10.lastIndexOf('\\');
			String s11 = "";
			if (i1 > 0)
				s11 = s10.substring(i1 + 1);
			else
				s11 = s10;
			aifshell.setApplicationName(s11);
			aifshell.addJobChangeListener(new PreActionShell(aeshell, i));
			if (i == 3 || i == 4) {
				aifshell.setAction("O");
				aifshell.setToolName(tccomponent1
						.getStringProperty("object_name"));
				aifshell.setViewOrEdit(s);
			} else if (i == 2 || i == 9)
				aifshell.setAction("P");
			String s12 = (new StringBuilder("TC_"))
					.append(getTypeComponent().getTypeName()).append("_")
					.append(tccomponent1.toString()).append("_searchBy")
					.toString();
			TCPreferenceService tcpreferenceservice = getSession()
					.getPreferenceService();
			String s13 = tcpreferenceservice.getStringValue(s12);
			if (logger.isDebugEnabled() || Debug.isOn("tool"))
				logger.info((new StringBuilder("Preference [")).append(s12)
						.append("] value [").append(s13).append("]").toString());
			if (s13 != null && !s13.isEmpty())
				aifshell.setSearchBy(s13);
			aifshell.start();
		} else {
			toolStartUp(aeshell, i, s);
		}
	}

	void toolStartUp(AEShell aeshell, int i) throws TCException {
		toolStartUp(aeshell, i, "Open");
	}

	void toolStartUp(AEShell aeshell, int i, String s) throws TCException {
		TCComponent tccomponent = aeshell.askSelectedTool();
		File afile[] = aeshell.askExportedFiles();
		String s1 = aeshell.askSelectedFileName();
		String s2 = aeshell.askSelectedNamedRef();
		String s3 = aeshell.askSelectedMimeType();
		String s4 = aeshell.askSearchBy();

		System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>  1111");
		Object obj = null;
		Registry registry = Registry.getRegistry(this);
		String as[] = getDatasetDefinitionComponent().getToolInputSwitches(
				tccomponent, i);
		paramArrayList.clear();
		if (as != null && (logger.isDebugEnabled() || Debug.isOn("tool"))) {
			StringBuilder stringbuilder = new StringBuilder();
			stringbuilder.append("  input switches: ");
			String as3[];
			int i1 = (as3 = as).length;
			for (int k = 0; k < i1; k++) {
				String s7 = as3[k];
				stringbuilder.append(s7).append(' ');
			}

			logger.info(stringbuilder);
		}
		System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>  2222222222222");
		if (i == 3 || i == 4) {
			String s6 = tccomponent.toString();
			String s8 = getApplRegKey(getType());
			if (s8 != null && s8.equals("CAE"))
				try {
					String s9 = getCurrentWorkingDir();
					if (s6.equalsIgnoreCase("MeshingTool"))
						launchPreAction(aeshell);
					paramArrayList.add("Generic_Encapsulation");
					paramArrayList.add(s9);
				} catch (Exception exception) {
					throw (TCException) exception;
				}
			String s5 = registry.getString("AliasProjectDatasetTool");
			if (s6.equals(s5))
				try {
					launchPreAction(aeshell);
					String s10 = AliasOpenAction.ouputXMLFilePath;
					String s11 = null;
					String s14 = registry.getString("AliasEncapArgs");
					if (s10 != null)
						s11 = (new StringBuilder(String.valueOf(s14)))
								.append("=")
								.append(AliasOpenAction.ouputXMLFilePath)
								.toString();
					paramArrayList.add("-e");
					paramArrayList.add(s11);
				} catch (Exception exception1) {
					throw (TCException) exception1;
				}
			String as1[] = buildInputParams(s1, as, s2, i);
			String as5[];
			int l1 = (as5 = as1).length;
			for (int k1 = 0; k1 < l1; k1++) {
				String s12 = as5[k1];
				paramArrayList.add(s12);
			}
			System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>  33333");
			if (s3 != null && s3.equals("application/ugmportal")) {
				String s13 = "";
				if (TCSession.isFourTier())
					s13 = "4-tier";
				else
					s13 = "2-tier";
				paramArrayList.add(s13);
			}
			String as2[] = (String[]) paramArrayList.toArray(new String[0]);
			AIFShell aifshell = new AIFShell("");
			try {
				if (Debug.isOn("runner")) {
					aifshell.setVerbose();
					if ((logger.isDebugEnabled() || Debug.isOn("tool"))
							&& as2 != null) {
						StringBuilder stringbuilder1 = new StringBuilder();
						stringbuilder1.append("AIFShell command: ");
						String as6[];
						int l2 = (as6 = as2).length;
						for (int j2 = 0; j2 < l2; j2++) {
							String s16 = as6[j2];
							stringbuilder1.append(s16).append(' ');
						}

						logger.info(stringbuilder1);
					}
				}
			} catch (Exception exception2) {
				logger.debug(exception2.getLocalizedMessage(), exception2);
			}
			System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>  4444");
			if (as2 != null && as2.length > 0)
				aifshell.setCommand(as2);
			if (s3 != null && !s3.isEmpty())
				aifshell.setMimeType(s3);
			aifshell.addJobChangeListener(aeshell);
			aifshell.setAction("O");
			TCComponentType.cacheTCPropertiesSet(new Object[] { tccomponent },
					new String[] { "symbol_name", "object_name" }, true);
			String s15 = tccomponent.getStringProperty("symbol_name");
			int i2 = s15.lastIndexOf('\\');
			String s18 = "";
			if (i2 > 0)
				s18 = s15.substring(i2 + 1);
			else
				s18 = s15;
			aifshell.setApplicationName(s18);
			aifshell.setToolName(tccomponent.getStringProperty("object_name"));
			aifshell.setViewOrEdit(s);
			aifshell.setAction("O");
			if (s4 != null && !s4.isEmpty())
				aifshell.setSearchBy(s4);
			if (logger.isDebugEnabled() || Debug.isOn("tool"))
				logger.info((new StringBuilder("Starting AIFShell ["))
						.append(aifshell).append("]").toString());
			aifshell.start();
		} else if ((i == 2 || i == 9) && afile != null) {
			Object obj1 = null;
			int j = 0;
			int l = afile.length;
			for (int j1 = 0; j1 < l; j1++) {
				File file = afile[j1];
				String as4[] = buildInputParams(file.getPath(), as, s2, i);
				AIFShell aifshell1 = new AIFShell("");
				if (as4 != null && as4.length > 0)
					aifshell1.setCommand(as4);
				if (s3 != null && !s3.isEmpty())
					aifshell1.setMimeType(s3);
				aifshell1.setAction("P");
				String s17 = tccomponent.getStringProperty("symbol_name");
				int k2 = s17.lastIndexOf('\\');
				String s19 = "";
				if (k2 > 0)
					s19 = s17.substring(k2 + 1);
				else
					s19 = s17;
				aifshell1.setApplicationName(s19);
				if (++j == l)
					aifshell1.addJobChangeListener(aeshell);
				aifshell1.start();
			}

		}
		System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>  5555");
	}

	void launchPreAction(AEShell aeshell) throws Exception {
		Registry registry = Registry.getRegistry(this);
		Object obj = null;
		TCComponent tccomponent = aeshell.askSelectedTool();
		String s = registry.getString(
				(new StringBuilder(String.valueOf(tccomponent.toString())))
						.append(".").append("PREACTION").toString(), null);
		if (logger.isDebugEnabled() || Debug.isOn("tool"))
			logger.info((new StringBuilder(
					"launchPreAction() with selectedToolName [")).append(s)
					.append("]").toString());
		if (s != null)
			try {
				AbstractDatasetOpenPreAction abstractdatasetopenpreaction = (AbstractDatasetOpenPreAction) Instancer
						.newInstanceEx(s, aeshell);
				abstractdatasetopenpreaction.startPreAction();
			} catch (Exception exception) {
				logger.error(exception.getLocalizedMessage(), exception);
				throw exception;
			}
	}

	String[] buildInputParams(String s, String as[], String s1, int i) {
		boolean flag = true;
		ArrayList arraylist = new ArrayList();
		String as1[] = null;
		Assert.isTrue(
				FileUtility.isValidPathString(s),
				(new StringBuilder(String.valueOf(Registry.getRegistry(
						FileUtility.class).getString(
						FileUtility.getInvalidPathMessage())))).append(" - ")
						.append(s).toString());
		File file = new File(s);
		File file1 = file.getParentFile();
		String s2 = null;
		if (file1 != null && file1.isDirectory() && file1.exists()) {
			as1 = file1.list();
			s2 = file1.getName();
		}
		String s3 = s != null ? file.getName() : null;
		if (logger.isDebugEnabled() || Debug.isOn("tool")) {
			StringBuilder stringbuilder = new StringBuilder();
			stringbuilder.append("==> buildInputParams(inputFileName [")
					.append(s).append("], ref_name [").append(s1)
					.append("], action ").append(i).append(") ");
			if (as != null) {
				String as3[];
				int j1 = (as3 = as).length;
				for (int l = 0; l < j1; l++) {
					String s4 = as3[l];
					stringbuilder.append('\t').append(s4).append(' ');
				}

				stringbuilder.append("\n\tinputFile [").append(s3)
						.append("], currExportDir [").append(file1);
				if (as1 != null) {
					stringbuilder.append("] has ")
							.append(as1 != null ? as1.length : 0)
							.append(" exported files");
					String as4[];
					int k1 = (as4 = as1).length;
					for (int i1 = 0; i1 < k1; i1++) {
						String s5 = as4[i1];
						stringbuilder.append('\t').append(s5).append(' ');
					}

				}
			}
			logger.info(stringbuilder);
		}
		if (as != null && as.length > 0)
			try {
				int j = as.length;
				for (int k = 0; k < j; k++) {
					if (logger.isDebugEnabled() || Debug.isOn("tool"))
						logger.info((new StringBuilder("==> Processing ["))
								.append(as[k]).append("]").toString());
					if (as[k].equals("$OBJECT_TAG")) {
						String s6 = getObjectString();
						arraylist.add(s6);
					} else if (as[k].equals("$OBJECT")) {
						String s7 = getProperty("object_name");
						arraylist.add(s7);
					} else if (as[k].equals("$USER")) {
						String s8 = getSession().getUser().getUserId();
						arraylist.add(s8);
					} else if (as[k].equals("$GROUP")) {
						String s9 = getSession().getGroup().getFullName();
						arraylist.add(s9);
					} else if (as[k].equals("$ACCESS")) {
						Registry registry = Registry.getRegistry(this);
						String s12 = null;
						if (okToModify())
							s12 = registry.getString("WRITE_ACCESS", "W_ONLY");
						else
							s12 = registry.getString("READ_ACCESS", "R_ONLY");
						arraylist.add(s12);
					} else if (as[k].equals("$ACTION")) {
						if (i == 3)
							arraylist.add("open");
						else if (i == 4)
							arraylist.add("openusing");
						else if (i == 2)
							arraylist.add("print");
						else if (i == 9)
							arraylist.add("printusing");
					} else if (as[k].charAt(0) == '$') {
						String s10 = as[k].substring(1);
						if (flag) {
							if (s10.compareTo(s1) == 0) {
								arraylist.add(s);
								flag = false;
								if (logger.isDebugEnabled()
										|| Debug.isOn("tool"))
									logger.info((new StringBuilder(
											"  Matched ref name [")).append(s1)
											.append("] with [").append(as[k])
											.append("]").toString());
							}
						} else if (as1 != null && as1.length > 0) {
							if (dsNamedRefs == null)
								dsNamedRefs = getDatasetDefinitionComponent()
										.getNamedReferenceContexts();
							String s13 = null;
							NamedReferenceContext anamedreferencecontext[];
							int l2 = (anamedreferencecontext = dsNamedRefs).length;
							for (int j2 = 0; j2 < l2; j2++) {
								NamedReferenceContext namedreferencecontext = anamedreferencecontext[j2];
								if (s10.compareTo(namedreferencecontext
										.getNamedReference()) != 0)
									continue;
								s13 = namedreferencecontext.getFileTemplate();
								if (logger.isDebugEnabled()
										|| Debug.isOn("tool"))
									logger.info((new StringBuilder("NameRef ["))
											.append(namedreferencecontext
													.getNamedReference())
											.append("] template [").append(s13)
											.append("]").toString());
								if (s13 != null && s13.charAt(0) == '*')
									s13 = s13.substring(1);
								break;
							}

							if (s13 != null && !s13.isEmpty()) {
								String as6[];
								int i3 = (as6 = as1).length;
								for (int k2 = 0; k2 < i3; k2++) {
									String s14 = as6[k2];
									if (s3.equals(s14)) {
										if (logger.isDebugEnabled()
												|| Debug.isOn("tool"))
											logger.info((new StringBuilder(
													"  Skipped file ["))
													.append(s14).append("]")
													.toString());
										continue;
									}
									if (!s14.endsWith(s13))
										continue;
									if (logger.isDebugEnabled()
											|| Debug.isOn("tool"))
										logger.info((new StringBuilder(
												"Matched filename ["))
												.append(s14)
												.append("] with template [")
												.append(s13).append("]")
												.toString());
									if (s2 != null) {
										String s15 = (new StringBuilder())
												.append(file1)
												.append(File.separator)
												.append(s14).toString();
										arraylist.add(s15);
									} else {
										arraylist.add(s14);
									}
									break;
								}

							}
						}
					} else {
						arraylist.add(as[k]);
					}
				}

			} catch (TCException _ex) {
			}
		String as2[] = new String[arraylist.size()];
		arraylist.toArray(as2);
		if (as2 != null && (logger.isDebugEnabled() || Debug.isOn("tool"))) {
			StringBuilder stringbuilder1 = new StringBuilder();
			stringbuilder1.append("buildInputParams() returns: ");
			String as5[];
			int i2 = (as5 = as2).length;
			for (int l1 = 0; l1 < i2; l1++) {
				String s11 = as5[l1];
				stringbuilder1.append(s11).append(' ');
			}

			logger.info(stringbuilder1);
		}
		return as2;
	}

	public void open(TCComponent tccomponent, String s, String s1)
			throws TCException, IOException {
		boolean flag = okToModify();
		open(tccomponent, s, s1, flag);
	}

	public void open(TCComponent tccomponent, String s, String s1, boolean flag)
			throws TCException, IOException {
		int i = 0;
		try {
			boolean flag1 = false;
			if (flag) {
				TCReservationService tcreservationservice = (TCReservationService) OSGIUtil
						.getService(KernelPlugin.getDefault(),
								TCReservationService.class);
				boolean flag3 = tcreservationservice.isAutoCheckoutEnabled();
				if (logger.isDebugEnabled())
					logger.debug((new StringBuilder("TC_Auto_Checkout ["))
							.append(flag3).append("]").toString());
				if (flag3 || tcreservationservice.isReserved(this))
					flag1 = okToModify();
			}
			if (flag1)
				i = reserveDataset();
			boolean flag2 = true;
			if (s == null) {
				s = getWorkingDir();
				flag2 = false;
			}
			File file = new File(s);
			if (file.isDirectory()) {
				prepareToolForLaunching(tccomponent, s, flag2, s1, 4, i, flag);
			} else {
				TCSession tcsession1 = getSession();
				if (flag) {
					TCReservationService tcreservationservice2 = tcsession1
							.getReservationService();
					tcreservationservice2.cancelReservation(this);
				}
				String s2 = tcsession1.getRegistry().getString(
						"createDirFailed");
				throw TCComponent.handleException((new StringBuilder(String
						.valueOf(s2))).append(" ").append(s).toString());
			}
		} catch (TCException tcexception) {
			if (flag && i == 1) {
				TCSession tcsession = getSession();
				TCReservationService tcreservationservice1 = tcsession
						.getReservationService();
				tcreservationservice1.cancelReservation(this);
			}
			throw tcexception;
		}
	}

	public void purge() throws TCException {
		((TCComponentDatasetType) getTypeComponent()).purge(this);
		fireComponentChangeEvent();
	}

	public TCComponentDataset saveAs(String s) throws TCException {
		return ((TCComponentDatasetType) getTypeComponent()).saveAs(this, s);
	}

	public TCComponentDataset saveAs(String s, String s1, String s2)
			throws TCException {
		return ((TCComponentDatasetType) getTypeComponent()).saveAs(this, s,
				s1, s2);
	}

	public TCComponentDataset saveVersionAs(String s, String s1, String s2,
			int i) throws TCException {
		return ((TCComponentDatasetType) getTypeComponent()).saveVersionAs(
				this, i, s, s1, s2);
	}

	public TCComponent[] getNamedReferences() throws TCException {
		return getRelatedComponents("ref_list");
	}

	public TCComponentTcFile[] getTcFiles() throws TCException {
		TCComponentContextList tccomponentcontextlist = getRelatedList();
		TCComponent atccomponent[] = tccomponentcontextlist
				.toTCComponentArray();
		ArrayList arraylist = new ArrayList();
		TCComponent atccomponent1[];
		int j = (atccomponent1 = atccomponent).length;
		for (int i = 0; i < j; i++) {
			TCComponent tccomponent = atccomponent1[i];
			if (tccomponent != null) {
				String s = tccomponent.getType();
				if (s.equalsIgnoreCase("ImanFile"))
					arraylist.add(tccomponent);
			}
		}

		return (TCComponentTcFile[]) arraylist
				.toArray(new TCComponentTcFile[arraylist.size()]);
	}

	public TCComponent[] getNonTcFileObjects() throws TCException {
		TCComponentContextList tccomponentcontextlist = getRelatedList();
		TCComponent atccomponent[] = tccomponentcontextlist
				.toTCComponentArray();
		ArrayList arraylist = new ArrayList();
		TCComponent atccomponent1[];
		int j = (atccomponent1 = atccomponent).length;
		for (int i = 0; i < j; i++) {
			TCComponent tccomponent = atccomponent1[i];
			if (tccomponent != null
					&& !(tccomponent instanceof TCComponentTool)
					&& !(tccomponent instanceof TCComponentTcFile)
					&& !(tccomponent instanceof TCComponentDatasetDefinition)
					&& !(tccomponent instanceof TCComponentUser)
					&& !(tccomponent instanceof TCComponentGroup)
					&& !(tccomponent instanceof TCComponentSite)
					&& !tccomponent.getType()
							.equalsIgnoreCase("RevisionAnchor"))
				arraylist.add(tccomponent);
		}

		return (TCComponent[]) arraylist.toArray(new TCComponent[arraylist
				.size()]);
	}

	@Override
	public boolean isSuitableForOpenAs() throws TCException {
		TCComponentDataset atccomponentdataset[] = getAllVersions();
		if (atccomponentdataset != null && atccomponentdataset.length > 1)
			return true;
		TCComponent atccomponent[] = getDatasetDefinitionComponent().getTools();
		if (atccomponent != null && atccomponent.length == 1) {
			String as[] = getPrimaryFileNames(atccomponent[0], 3);
			return as != null && as.length > 1;
		} else {
			return true;
		}
	}

	public TCComponentDatasetDefinition getDatasetDefinitionComponent()
			throws TCException {
		if (dsDefinitionComp == null) {
			String s = getTypeComponent().getTypeName();
			TCComponentDatasetDefinitionType tccomponentdatasetdefinitiontype = (TCComponentDatasetDefinitionType) getSession()
					.getTypeComponent("DatasetType");
			dsDefinitionComp = tccomponentdatasetdefinitiontype.find(s);
		}
		return dsDefinitionComp;
	}

	public void setUploadingFlag(boolean flag) {
		uploadingDataset = flag;
	}

	public boolean askUploadingFlag() {
		return uploadingDataset;
	}

	public void setDefaultTool(TCComponent tccomponent) throws TCException {
		if (tccomponent == null)
			return;
		TCProperty tcproperty = getTCProperty("tool_used");
		TCComponent tccomponent1 = tcproperty.getReferenceValue();
		if (tccomponent1 != null && tccomponent1.equals(tccomponent)) {
			return;
		} else {
			String s = tccomponent.getProperty("object_name");
			((TCComponentDatasetType) getTypeComponent()).setDefaultTool(this,
					s);
			return;
		}
	}

	public TCComponent getDefaultTool() throws TCException {
		return ((TCComponentDatasetType) getTypeComponent())
				.getDefaultTool(this);
	}

	public String getApplRegKey(String s) {
		String s1 = null;
		TCPreferenceService tcpreferenceservice = getSession()
				.getPreferenceService();
		String s2 = "TC_encapsulation_application_key";
		String as[] = tcpreferenceservice.getStringValues(s2);
		if (as != null) {
			String as1[];
			int j = (as1 = as).length;
			for (int i = 0; i < j; i++) {
				String s3 = as1[i];
				if (s3.equals("CAE")) {
					String s4 = "CAE_analysis_tools";
					String as2[] = tcpreferenceservice.getStringValues(s4);
					if (as2 != null) {
						String as3[];
						int l = (as3 = as2).length;
						for (int k = 0; k < l; k++) {
							String s5 = as3[k];
							if (!s.equals(s5))
								continue;
							s1 = "CAE";
							break;
						}

					}
				}
			}

		}
		return s1;
	}

	public void setCurrentWorkingDir(String s) {
		reqDir = s;
	}

	public String getCurrentWorkingDir() {
		return reqDir;
	}

	public static String getAction(int i) {
		if (i < 0 || i >= actionString.length)
			return actionString[0];
		else
			return actionString[i];
	}

	public boolean inIsIcContext() {
		return inIcContext;
	}

	public void setInIcContext() {
		if (!inIcContext) {
			inIcContext = true;
			try {
				((TCComponentDatasetType) getTypeComponent())
						.setInIcContext(this);
			} catch (TCException tcexception) {
				logger.error(tcexception.getLocalizedMessage(), tcexception);
			}
		}
	}

	public void resetInIcContext() {
		if (inIcContext) {
			inIcContext = false;
			try {
				((TCComponentDatasetType) getTypeComponent())
						.resetInIcContext(this);
			} catch (TCException tcexception) {
				logger.error(tcexception.getLocalizedMessage(), tcexception);
			}
		}
	}

	public void validateFiles(TCComponentDataset tccomponentdataset,
			File afile[]) throws TCException, ParserConfigurationException,
			SAXException, IOException {
		if (isValidComponentForExcelLive(tccomponentdataset)) {
			String s = tccomponentdataset.getProperty("object_name");
			TCComponentMSExcelX tccomponentmsexcelx = new TCComponentMSExcelX();
			tccomponentmsexcelx.validateFile(getSession(), afile, s);
		}
	}

	public boolean isValidComponentForExcelLive(
			TCComponentDataset tccomponentdataset) throws TCException {
		if (tccomponentdataset.isTypeOf("MSExcelX")) {
			TCComponent tccomponent = null;
			AIFComponentContext aaifcomponentcontext[] = tccomponentdataset
					.whereReferencedByTypeRelation(new String[0],
							new String[] { "IMAN_specification" });
			if (aaifcomponentcontext != null) {
				AIFComponentContext aaifcomponentcontext2[];
				int j = (aaifcomponentcontext2 = aaifcomponentcontext).length;
				for (int i = 0; i < j; i++) {
					AIFComponentContext aifcomponentcontext = aaifcomponentcontext2[i];
					com.teamcenter.rac.aif.kernel.InterfaceAIFComponent interfaceaifcomponent = aifcomponentcontext
							.getComponent();
					if ((interfaceaifcomponent instanceof TCComponent)
							&& ((TCComponent) interfaceaifcomponent)
									.isTypeOf("ExcelTemplateRevision"))
						tccomponent = (TCComponent) interfaceaifcomponent;
				}

			}
			if (tccomponent != null) {
				AIFComponentContext aaifcomponentcontext1[] = tccomponent
						.getRelated("items_tag");
				if (aaifcomponentcontext1 != null) {
					AIFComponentContext aaifcomponentcontext3[];
					int l = (aaifcomponentcontext3 = aaifcomponentcontext1).length;
					for (int k = 0; k < l; k++) {
						AIFComponentContext aifcomponentcontext1 = aaifcomponentcontext3[k];
						com.teamcenter.rac.aif.kernel.InterfaceAIFComponent interfaceaifcomponent1 = aifcomponentcontext1
								.getComponent();
						if ((interfaceaifcomponent1 instanceof TCComponent)
								&& ((TCComponent) interfaceaifcomponent1)
										.isTypeOf("ExcelTemplate"))
							return true;
					}

				}
			}
		}
		return false;
	}

	@Override
	public int compareTo(Object paramTCComponentDataset) {
		return toString().compareTo(paramTCComponentDataset.toString());
	}

	private static final Logger logger;
	public static final int ACTION_UNKNOWN = 0;
	public static final int ACTION_CREATE = 1;
	public static final int ACTION_PRINT = 2;
	public static final int ACTION_OPEN = 3;
	public static final int ACTION_OPEN_USING = 4;
	public static final int ACTION_SAVE_AS = 5;
	public static final int ACTION_DESTROY = 6;
	public static final int ACTION_PURGE = 7;
	public static final int ACTION_IMPORT = 8;
	public static final int ACTION_PRINT_USING = 9;
	public static final int ACTION_MORE = 10;
	public static final int ACTION_IMPORT_TO_EXISTING = 11;
	public static final int ACTION_SEND = 12;
	private boolean inIcContext;
	private static String actionString[] = { "ACTION_UNKNOWN", "ACTION_CREATE",
			"ACTION_PRINT", "ACTION_OPEN", "ACTION_OPEN_USING",
			"ACTION_SAVE_AS", "ACTION_DESTROY", "ACTION_PURGE",
			"ACTION_IMPORT", "ACTION_PRINT_USING", "ACTION_MORE",
			"ACTION_IMPORT_TO_EXISTING", "ACTION_SEND" };
	public static final String ACTION_OBJECT_SUFFIX = ".ACTION_OBJECT";
	public static final int NOT_CHECKED_OUT = 0;
	public static final int SHORT_TERM_CHECKED_OUT = 1;
	public static final int LONG_TERM_CHECKED_OUT = 2;
	private static String reqDir;
	private static boolean uploadingDataset = false;
	private TCComponentDatasetDefinition dsDefinitionComp;
	private NamedReferenceContext dsNamedRefs[];
	private List paramArrayList;
	private boolean isOfficeType;
	private String url;
	private String cookie;

	static {
		logger = Logger.getLogger(TCComponentDataset.class);
		if (!logger.isDebugEnabled() && Debug.isOn("dataset"))
			logger.setLevel(org.apache.log4j.Level.DEBUG);
	}
}

/*
 * DECOMPILATION REPORT
 * 
 * Decompiled from:
 * F:\Teamcenter10.1.4Env\portal\plugins\com.teamcenter.rac.kernel_10000.1.0.jar
 * Total time: 154 ms Jad reported messages/errors: Exit status: 0 Caught
 * exceptions:
 */