Solution : Windchill Data Deletion Utility for Bulk Removal of Windchill objects.

package ext.utility
import wt.associativity.EquivalenceLink;
import wt.change2.WTChangeActivity2;
import wt.change2.WTChangeIssue;
import wt.change2.WTChangeOrder2;
import wt.change2.WTChangeRequest2;
import wt.doc.WTDocument;
import wt.epm.EPMDocument;
import wt.epm.structure.EPMDescribeLink;
import wt.epm.structure.EPMMemberLink;
import wt.epm.structure.EPMReferenceLink;
import wt.fc.Persistable;
import wt.fc.PersistenceHelper;
import wt.fc.PersistenceServerHelper;
import wt.fc.QueryResult;
import wt.maturity.PromotionNotice;
import wt.method.RemoteAccess;
import wt.method.RemoteMethodServer;
import wt.part.WTPart;
import wt.part.WTPartAlternateLink;
import wt.part.WTPartDescribeLink;
import wt.part.WTPartUsageLink;
import wt.query.QuerySpec;
import wt.session.SessionServerHelper;
import wt.util.WTException;
import wt.util.WTPropertyVetoException;
import wt.vc.VersionControlHelper;
import wt.vc.wip.WorkInProgressHelper;
import wt.vc.wip.Workable;
import wt.workflow.work.WorkItem;
 
public class DataDeletionUtility implements RemoteAccess {
 
	
	/*
	 * Through this utility we are deleting data from windchill. The objects targeted are:
	 * 1.Part Usage Links
	 * 2.Part Describe Links
	 * 3.Equivalence Links
	 * 4.Part Alternate Links
	 * 5.EPM Describe links
	 * 6.EPM Uses links
	 * 7.EPM Reference Links
	 * 8.Change Notices
	 * 9.Change Requests
	 * 10.Change Activity
	 * 11.Problem Reports
	 * 12.Promotion Requests
	 * 13.EPM Documents
	 * 14.WTParts
	 * 15.WTDocuments
	 * 
	 */
	
	/*
	 * Run this command on windchill shell:
	 * windchill ext.utility.DataDeletionUtility
	 * to run this utility
	 */
	public static RemoteMethodServer getMS() {
		return RemoteMethodServer.getDefault();
	}
 
	public static void main(String[] argv) {
		try {
			
 
			RemoteMethodServer rms = getMS();
			rms.setUserName("wcadmin");
			rms.setPassword("wcadmin");
			rms.invoke("run", "ext.utility.DataDeletionUtility", null, null, null);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			System.exit(0);
		}
	}
	
	public static void run() throws Exception {
		Boolean enforced = SessionServerHelper.manager.isAccessEnforced(); 
		SessionServerHelper.manager.setAccessEnforced(false);
		deleteChangeObjects();
		deleteEqLinks();
		deletePartUsageLinks();
		deleteDescribeLinks();
		deletePartAlternateLinks();
		deleteEPMDescribeLinks();
		deleteEPMUsesLinks();
		deleteEPMReferenceLinks();
		
		deleteParts();
		deleteDocuments();
		deleteEPMDocument();
		SessionServerHelper.manager.setAccessEnforced(enforced);
	}
	
	@SuppressWarnings("deprecation")
	public static void deletePartUsageLinks() throws Exception {
		System.out.println("Deleting part usage links..");
		QuerySpec querySpec = new QuerySpec(WTPartUsageLink.class);
 QueryResult links = PersistenceHelper.manager.find(querySpec);

 while (links.hasMoreElements()) {
 	Persistable link = (Persistable) links.nextElement();
 try {
 System.out.println("Deleting link: " + link);
 PersistenceServerHelper.manager.remove(link);
 } catch (WTException e) {
 System.err.println("Failed to delete link: " + link);
 e.printStackTrace();
 }
 }
	}
	
	public static void deleteDescribeLinks() throws Exception {
		System.out.println("Deleting part describe links..");
		QuerySpec querySpec = new QuerySpec(WTPartDescribeLink.class);
 QueryResult links = PersistenceHelper.manager.find(querySpec);

 while (links.hasMoreElements()) {
 	Persistable link = (Persistable) links.nextElement();
 try {
 System.out.println("Deleting link: " + link);
 PersistenceServerHelper.manager.remove(link);
 } catch (WTException e) {
 System.err.println("Failed to delete link: " + link);
 e.printStackTrace();
 }
 }
	}
	
	public static void deleteEqLinks() throws Exception {
		System.out.println("Deleting equivalence links..");
		QuerySpec querySpec = new QuerySpec(EquivalenceLink.class);
 QueryResult eqlinks = PersistenceHelper.manager.find(querySpec);

 while (eqlinks.hasMoreElements()) {
 	Persistable link = (Persistable) eqlinks.nextElement();
 try {
 System.out.println("Deleting link: " + link);
 PersistenceServerHelper.manager.remove(link);
 } catch (WTException e) {
 System.err.println("Failed to delete link: " + link);
 e.printStackTrace();
 }
 }
	}
	
	public static void deletePartAlternateLinks() throws Exception {
		System.out.println("Deleting part alternate links..");
		QuerySpec querySpec = new QuerySpec(WTPartAlternateLink.class);
 QueryResult eqlinks = PersistenceHelper.manager.find(querySpec);

 while (eqlinks.hasMoreElements()) {
 	Persistable link = (Persistable) eqlinks.nextElement();
 try {
 System.out.println("Deleting link: " + link);
 PersistenceServerHelper.manager.remove(link);
 } catch (WTException e) {
 System.err.println("Failed to delete link: " + link);
 e.printStackTrace();
 }
 }
	}
	
	public static void deleteEPMDescribeLinks() throws Exception {
		System.out.println("Deleting EPM describe links..");
		QuerySpec querySpec = new QuerySpec(EPMDescribeLink.class);
 QueryResult epmDescLinks = PersistenceHelper.manager.find(querySpec);

 while (epmDescLinks.hasMoreElements()) {
 	Persistable link = (Persistable) epmDescLinks.nextElement();
 try {
 System.out.println("Deleting link: " + link);
 PersistenceServerHelper.manager.remove(link);
 } catch (WTException e) {
 System.err.println("Failed to delete epm desc link: " + link);
 e.printStackTrace();
 }
 }
	}
	
	public static void deleteEPMReferenceLinks() throws Exception {
		System.out.println("Deleting EPM ref links..");
		QuerySpec querySpec = new QuerySpec(EPMReferenceLink.class);
 QueryResult epmRefLinks = PersistenceHelper.manager.find(querySpec);

 while (epmRefLinks.hasMoreElements()) {
 	Persistable link = (Persistable) epmRefLinks.nextElement();
 try {
 System.out.println("Deleting link: " + link);
 PersistenceServerHelper.manager.remove(link);
 } catch (WTException e) {
 System.err.println("Failed to delete epm ref link: " + link);
 e.printStackTrace();
 }
 }
	}
	
	public static void deleteEPMUsesLinks() throws Exception {
		System.out.println("Deleting EPM uses links..");
		QuerySpec querySpec = new QuerySpec(EPMMemberLink.class);
 QueryResult EPMUsesLinks = PersistenceHelper.manager.find(querySpec);

 while (EPMUsesLinks.hasMoreElements()) {
 	Persistable link = (Persistable) EPMUsesLinks.nextElement();
 try {
 System.out.println("Deleting link: " + link);
 PersistenceServerHelper.manager.remove(link);
 } catch (WTException e) {
 System.err.println("Failed to delete epm uses link: " + link);
 e.printStackTrace();
 }
 }
	}
	
	
	public static void deleteChangeObjects() throws Exception {
		System.out.println("Deleting change objects..");
		QuerySpec querySpec1 = new QuerySpec(WTChangeOrder2.class);
 QueryResult CN = PersistenceHelper.manager.find(querySpec1);

 while (CN.hasMoreElements()) {
 	Persistable persCN = (Persistable) CN.nextElement();
 try {
 System.out.println("Deleting CN: " + persCN);
 PersistenceServerHelper.manager.remove(persCN);
 } catch (WTException e) {
 System.err.println("Failed to CN: " + persCN);
 e.printStackTrace();
 }
 }
 QuerySpec querySpec2 = new QuerySpec(WTChangeRequest2.class);
 QueryResult CR = PersistenceHelper.manager.find(querySpec2);

 while (CR.hasMoreElements()) {
 	Persistable persCR = (Persistable) CR.nextElement();
 try {
 System.out.println("Deleting CR: " + persCR);
 PersistenceServerHelper.manager.remove(persCR);
 } catch (WTException e) {
 System.err.println("Failed to CR: " + persCR);
 e.printStackTrace();
 }
 }
 QuerySpec querySpec3 = new QuerySpec(WTChangeActivity2.class);
 QueryResult CA = PersistenceHelper.manager.find(querySpec3);

 while (CA.hasMoreElements()) {
 	Persistable persCA = (Persistable) CA.nextElement();
 try {
 System.out.println("Deleting link: " + persCA);
 PersistenceServerHelper.manager.remove(persCA);
 } catch (WTException e) {
 System.err.println("Failed to delete link: " + persCA);
 e.printStackTrace();
 }
 }
 
 QuerySpec querySpec7 = new QuerySpec(WorkItem.class);
 QueryResult workItem = PersistenceHelper.manager.find(querySpec7);

 while (workItem.hasMoreElements()) {
 	Persistable task = (Persistable) workItem.nextElement();
 try {
 System.out.println("Deleting tasks: " + task);
 PersistenceServerHelper.manager.remove(task);
 } catch (WTException e) {
 System.err.println("Failed to delete task: " + task);
 e.printStackTrace();
 }
 }
 
 
 QuerySpec querySpec4 = new QuerySpec(WTChangeIssue.class);
 QueryResult problemReports = PersistenceHelper.manager.find(querySpec4);

 while (problemReports.hasMoreElements()) {
 	Persistable pr = (Persistable) problemReports.nextElement();
 try {
 System.out.println("Deleting Problem reports: " + pr);
 PersistenceServerHelper.manager.remove(pr);
 } catch (WTException e) {
 System.err.println("Failed to Problem reports: " + pr);
 e.printStackTrace();
 }
 }
 QuerySpec querySpec5 = new QuerySpec(PromotionNotice.class);
 QueryResult problemNotice = PersistenceHelper.manager.find(querySpec5);

 while (problemNotice.hasMoreElements()) {
 	Persistable pn = (Persistable) problemNotice.nextElement();
 try {
 System.out.println("Deleting Promotion Notice: " + pn);
 PersistenceServerHelper.manager.remove(pn);
 } catch (WTException e) {
 System.err.println("Failed to Promotion Notice: " + pn);
 e.printStackTrace();
 }
 }
 
	}
	
	
	
	public static void deleteEPMDocument() throws WTException {
		System.out.println("Deleting EPM document..");
 QuerySpec querySpec = new QuerySpec(EPMDocument.class);
 QueryResult docs = PersistenceServerHelper.manager.query(querySpec);
 
 while (docs.hasMoreElements()) {
 		
 	EPMDocument epmdoc1 = null;
 
 try {
 Persistable epmdoc = (Persistable) docs.nextElement();
 if(epmdoc instanceof EPMDocument) {
 	epmdoc1 = (EPMDocument) epmdoc;
 	QueryResult result = VersionControlHelper.service.allIterationsOf(epmdoc1.getMaster());
 	while(result.hasMoreElements()) {
 			System.out.println("Deleting EPM document: " + epmdoc1.getNumber());
 Persistable doc2= (Persistable) result.nextElement();
 if(WorkInProgressHelper.isCheckedOut((Workable) doc2)) {
 WorkInProgressHelper.service.checkin((Workable) doc2,"Checkin via api");
 }
 PersistenceHelper.manager.delete(doc2);
 	}
 }
 
 
 }catch (Exception e) {
 	System.err.println("Failed to delete epm doc: " + epmdoc1.getNumber());
 e.printStackTrace();
		}
	
	}
 }
	
	public static void deleteParts() throws WTException, WTPropertyVetoException {
		System.out.println("Deleting parts..");
 QuerySpec querySpec = new QuerySpec(WTPart.class);
 QueryResult parts = PersistenceServerHelper.manager.query(querySpec);
 
 while (parts.hasMoreElements()) {
 	WTPart part1 = null;
 		
 try {
 	Persistable part = (Persistable) parts.nextElement();
 	if(part instanceof WTPart) {
					part1 = (WTPart) part;
					QueryResult allIterations = VersionControlHelper.service.allIterationsOf(part1.getMaster());
					while(allIterations.hasMoreElements()) {
						System.out.println("Deleting part: " + part1.getNumber());
						Persistable part2= (Persistable) allIterations.nextElement();
						if(WorkInProgressHelper.isCheckedOut((Workable) part2)) {
							WorkInProgressHelper.service.checkin((Workable) part2,"Checkin via api");
						}
						PersistenceHelper.manager.delete(part2);
					}
						
				}
 System.out.println("Deleting part: " + ((WTPart)part).getNumber());
 } catch (WTException e) {
 System.err.println("Failed to delete part: " + part1.getNumber());
 e.printStackTrace();
 }
 }
 
	}
	
	public static void deleteDocuments() throws WTException, WTPropertyVetoException {
		System.out.println("Deleting docs..");
		QuerySpec querySpec = new QuerySpec(WTDocument.class);
		QueryResult docq = PersistenceServerHelper.manager.query(querySpec);

		while (docq.hasMoreElements()) {
			WTDocument doc1 = null;
			
 
			try {
				
				Persistable doc = (Persistable) docq.nextElement();
				if(doc instanceof WTDocument) {
					doc1 = (WTDocument) doc;
					QueryResult allIterations = VersionControlHelper.service.allIterationsOf(doc1.getMaster());
					while(allIterations.hasMoreElements()) {
						System.out.println("Deleting doc: " + doc1.getNumber());
						
						Persistable doc2 = (Persistable) allIterations.nextElement();
						if(WorkInProgressHelper.isCheckedOut((Workable) doc2)) {
							WorkInProgressHelper.service.checkin((Workable) doc2,"Checkin via api");
						}
						PersistenceHelper.manager.delete( doc2);
					}
					
						
				}
			} catch (WTException e) {
				System.err.println("Failed to delete doc: " + doc1.getNumber());
				e.printStackTrace();

			}
		}
	}
	
	
	
	
}