Attachment #72505 for bug #130240

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




<?xml version="1.0" encoding="UTF-8"?>
<feature
      id="org.eclipse.mylyn.xplanner_feature"
      label="%featureLabel"
      version="2.0.0.qualifier"
      provider-name="Eclipse.org"
      plugin="org.eclipse.mylyn.xplanner.ui">

   <description>
      %featureDescription

   </license>

   <url>
      <update label="Mylyn for Eclipse 3.3" url="http://download.eclipse.org/tools/mylyn/update/e3.3"/>
   </url>

   <requires>
      <import feature="org.eclipse.mylyn_feature" version="2.0.0.v20070514" match="equivalent"/>
      <import feature="org.eclipse.rcp" version="3.2.2.r322_v20070104-8pcviKVqd8J7C1U" match="compatible"/>
      <import feature="org.eclipse.platform" version="3.2.2.r322_v20070119-RQghndJN8IM0MsK" match="compatible"/>
      <import plugin="org.eclipse.mylar.context.core"/>
      <import plugin="org.eclipse.mylar.tasks.ui"/>
      <import plugin="org.eclipse.mylar.tasks.core"/>
      <import plugin="org.eclipse.search"/>
      <import plugin="org.eclipse.mylar.monitor.core"/>
      <import plugin="org.eclipse.mylar" version="2.0.0.v20070216" match="greaterOrEqual"/>
      <import feature="org.eclipse.mylar_feature" version="2.0.0.v20070216" match="greaterOrEqual"/>
   </requires>

   <plugin
         id="org.eclipse.mylyn.xplanner.core"
         download-size="0"
         install-size="0"
         version="0.0.0"
         unpack="false"/>

   <plugin
         id="org.eclipse.mylyn.xplanner.ui"
         download-size="0"
         install-size="0"
         version="0.0.0"

Lines 1-2 Link Here

(-)feature.properties (-2 / +2 lines)
1	featureLabel=Mylar Connector for XPlanner	1	featureLabel=Mylyn Connector: XPlanner
2	featureDescription=XPlanner client integrated with Eclipse and Mylar, can be used standalone.	2	featureDescription=XPlanner client integrated with Eclipse and Mylyn, can be used standalone.

Lines 5-11 Link Here

(-)src/org/eclipse/mylyn/xplanner/core/service/exceptions/InsufficientPermissionException.java (-1 / +1 lines)
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html	6	* http://www.eclipse.org/legal/epl-v10.html
7	*******************************************************************************/	7	*******************************************************************************/
8	package org.eclipse.mylar.xplanner.core.service.exceptions;	8	package org.eclipse.mylyn.xplanner.core.service.exceptions;
9		9
10	/**	10	/**
11	* @author Ravi Kumar	11	* @author Ravi Kumar

Lines 5-11 Link Here

(-)src/org/eclipse/mylyn/xplanner/core/service/exceptions/AuthenticationException.java (-1 / +1 lines)
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html	6	* http://www.eclipse.org/legal/epl-v10.html
7	*******************************************************************************/	7	*******************************************************************************/
8	package org.eclipse.mylar.xplanner.core.service.exceptions;	8	package org.eclipse.mylyn.xplanner.core.service.exceptions;
9		9
10	/**	10	/**
11	* @author Ravi Kumar	11	* @author Ravi Kumar

Lines 5-11 Link Here

(-)src/org/eclipse/mylyn/xplanner/core/service/exceptions/ServiceUnavailableException.java (-1 / +1 lines)
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html	6	* http://www.eclipse.org/legal/epl-v10.html
7	*******************************************************************************/	7	*******************************************************************************/
8	package org.eclipse.mylar.xplanner.core.service.exceptions;	8	package org.eclipse.mylyn.xplanner.core.service.exceptions;
9		9
10	/**	10	/**
11	* @author Ravi Kumar	11	* @author Ravi Kumar




 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.core.service.soap;

import java.net.URL;
import java.rmi.RemoteException;
import java.util.HashMap;

import org.apache.axis.client.Stub;
import org.apache.axis.configuration.FileProvider;
import org.eclipse.mylyn.xplanner.core.service.exceptions.AuthenticationException;
import org.eclipse.mylyn.xplanner.core.service.exceptions.ServiceUnavailableException;
import org.eclipse.mylyn.xplanner.wsdl.db.QueryException;
import org.eclipse.mylyn.xplanner.core.service.XPlannerClient;
import org.eclipse.mylyn.xplanner.core.service.XPlannerService;
import org.xplanner.soap.*;
import org.xplanner.soap.XPlanner.XPlanner;
import org.xplanner.soap.XPlanner.XPlannerServiceLocator;
import org.apache.axis.client.Stub;
import org.eclipse.mylar.xplanner.core.service.XPlannerServer;
import org.eclipse.mylar.xplanner.core.service.XPlannerService;
import org.eclipse.mylar.xplanner.core.service.exceptions.AuthenticationException;
import org.eclipse.mylar.xplanner.core.service.exceptions.ServiceUnavailableException;
import org.eclipse.mylar.xplanner.wsdl.db.QueryException;


// This class does not represent the data in a XPlanner installation.  It is merely

public class SoapXPlannerService extends XPlannerService {

	private static final String SOAP_URL_PREFIX = "/soap/XPlanner"; //$NON-NLS-1$
	private XPlannerClient client;
	private XPlanner service;
	boolean loginActive;

	public SoapXPlannerService(XPlannerClient aClient) {
		this.client = aClient;
		
		try {
			XPlannerServiceLocator s = new XPlannerServiceLocator(new FileProvider(this
					.getClass().getClassLoader().getResourceAsStream("client-config.wsdd"))); //$NON-NLS-1$
			s.setHttpUser(client.getHttpUser());
			s.setHttpPassword(client.getHttpPassword());
			s.setProxy(client.getProxy());
			s.setCompression(client.useCompression());
			service = s.getXPlanner(new URL(client.getBaseURL() + SOAP_URL_PREFIX));
			login(client.getCurrentUserName(), client.getCurrentUserPassword());
		} 
		catch (Throwable e) {
			e.printStackTrace();




 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.core.service.soap;

import org.eclipse.mylyn.xplanner.core.service.soap.SoapXPlannerService;
import org.eclipse.mylyn.xplanner.core.service.*;
import org.eclipse.mylar.xplanner.core.service.XPlannerServiceFactory;

/**
 * @author Ravi Kumar 

 */
public class SoapXPlannerServiceFactory implements XPlannerServiceFactory {

	public XPlannerService createService(XPlannerClient client) {
		// TODO Auto-generated method stub
		return new SoapXPlannerService(client);
	}

}




 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.core;

/**
 * @author Ravi Kumar
 * @author Helen Bershadskaya
 */
import org.eclipse.mylyn.xplanner.core.service.XPlannerServer;


public interface XPlannerServerListener {

Lines 5-11 Link Here

(-)src/org/eclipse/mylyn/xplanner/core/IXPlannerCoreExtensionConstants.java (-1 / +1 lines)
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html	6	* http://www.eclipse.org/legal/epl-v10.html
7	*******************************************************************************/	7	*******************************************************************************/
8	package org.eclipse.mylar.xplanner.core;	8	package org.eclipse.mylyn.xplanner.core;
9		9
10	/**	10	/**
11	* @author Ravi Kumar	11	* @author Ravi Kumar




 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.core;

import java.io.File;
import java.text.MessageFormat;

import java.util.logging.Level;
import java.util.logging.Logger;

import org.eclipse.core.runtime.*;
import org.eclipse.mylyn.xplanner.core.service.exceptions.AuthenticationException;
import org.eclipse.core.runtime.Status;
import org.eclipse.mylar.xplanner.core.service.exceptions.AuthenticationException;
import org.osgi.framework.BundleContext;

/**

 * @author Ravi Kumar 
 */
public class XPlannerCorePlugin extends Plugin {
	public static final String ID = "org.eclipse.mylyn.xplanner.core"; //$NON-NLS-1$
	
	//The shared instance.
	private static XPlannerCorePlugin plugin;
	//Resource bundle.
	private ResourceBundle resourceBundle;
	private XPlannerClientManager clientManager;
	
	/**
	 * The constructor.

	 */
	public void start(BundleContext context) throws Exception {
		super.start(context);
		File clientCache = getStateLocation().append("serverCache").toFile(); //$NON-NLS-1$
		
		// Turn off logging for the Attachment check.  We don't want or need soap with attachments
		Logger logger = Logger.getLogger("org.apache.axis.utils.JavaUtils"); //$NON-NLS-1$
		logger.setLevel(Level.SEVERE);
		
		clientManager = new XPlannerClientManager(clientCache);
		clientManager.start();
	}

	/**

		
			public String getPassword(URL baseURL, String username) {
				Map authenticationInfo = Platform.getAuthorizationInfo(baseURL, "XPlanner", ""); //$NON-NLS-1$ //$NON-NLS-2$
//				String username = (String) authenticationInfo.get("org.eclipse.mylyn.xplanner.core.username"); //$NON-NLS-1$
				String password = (String) authenticationInfo.get("org.eclipse.mylyn.xplanner.core.password"); //$NON-NLS-1$
				return password;
			}
		

	public void stop(BundleContext context) throws Exception {
		super.stop(context);
		
		if (clientManager != null) {
			clientManager.stop();
		}
		plugin = null;
		resourceBundle = null;
		clientManager = null;
	}

	/**

		return plugin;
	}

	public XPlannerClientManager getClientManager() {
		return clientManager;
	}
	
	/**

	public ResourceBundle getResourceBundle() {
		try {
			if (resourceBundle == null)
				resourceBundle = ResourceBundle.getBundle("org.eclipse.mylyn.xplanner.core.XPlannerCorePluginResources"); //$NON-NLS-1$
		} catch (MissingResourceException x) {
			resourceBundle = null;
		}




 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.core;

import org.eclipse.osgi.util.NLS;


 * @author Helen Bershadskaya
 */
public class Messages extends NLS {
	private static final String BUNDLE_NAME = "org.eclipse.mylyn.xplanner.core.messages"; //$NON-NLS-1$

	public static String XPlannerCorePlugin_UNEXPECTED_ERROR;



	public static String XPlannerValidator_CONNECTION_ERROR;

	public static String ClientManager_CLIENT_URL_CANNOT_BE_EMPTY;
	
	public static String ClientManager_INVALID_USERNAME_PASSWORD;

	static {
		// initialize resource bundle

Lines 6-12 Link Here

(-)src/org/eclipse/mylyn/xplanner/core/DebugManager.java (-1 / +1 lines)
6	* http://www.eclipse.org/legal/epl-v10.html	6	* http://www.eclipse.org/legal/epl-v10.html
7	*******************************************************************************/	7	*******************************************************************************/
8		8
9	package org.eclipse.mylar.xplanner.core;	9	package org.eclipse.mylyn.xplanner.core;
10		10
11	import org.eclipse.core.runtime.IStatus;	11	import org.eclipse.core.runtime.IStatus;
12	import org.eclipse.core.runtime.Platform;	12	import org.eclipse.core.runtime.Platform;

Lines 1-5 Link Here

(-)src/org/eclipse/mylyn/xplanner/core/messages.properties (-4 / +4 lines)
1	ServerManager_SERVER_URL_CANNOT_BE_EMPTY=Server url cannot be empty	1	ClientManager_CLIENT_URL_CANNOT_BE_EMPTY=Server url cannot be empty
2	ServerManager_INVALID_USERNAME_PASSWORD=Invalid user name or password.	2	ClientManager_INVALID_USERNAME_PASSWORD=Invalid user name or password.
3	XPlannerValidator_INVALID_CREDENTIALS_ERROR=The supplied credentials are invalid.\n\n{0}	3	XPlannerValidator_INVALID_CREDENTIALS_ERROR=The supplied credentials are invalid: {0}
4	XPlannerValidator_CONNECTION_ERROR=Connection error:\n\n{0}	4	XPlannerValidator_CONNECTION_ERROR=Connection error: {0}
5	XPlannerCorePlugin_UNEXPECTED_ERROR=Unexpected error	5	XPlannerCorePlugin_UNEXPECTED_ERROR=Unexpected error




/*******************************************************************************
 * Copyright (c) 2007 - 2007 CodeGear and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylar.xplanner.core;

/**
 * @author Ravi Kumar
 * @author Helen Bershadskaya
 */
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.URL;
import java.rmi.RemoteException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.apache.axis.AxisFault;
import org.eclipse.mylar.xplanner.core.service.CachedXPlannerServer;
import org.eclipse.mylar.xplanner.core.service.XPlannerServer;
import org.eclipse.mylar.xplanner.core.service.exceptions.AuthenticationException;
import org.eclipse.mylar.xplanner.core.service.exceptions.ServiceUnavailableException;
import org.xml.sax.SAXException;


/**
 * @author Helen Bershadskaya 
 * @author Ravi Kumar 
 */
public class ServerManager {

	private final File cacheLocation;

	private Map<String, XPlannerServer> serverByName = new HashMap<String, XPlannerServer>();

	// TODO Use a decent listener list
	private List<XPlannerServerListener> listeners = new ArrayList<XPlannerServerListener>();
	
	public ServerManager(File cacheLocation) {
		this.cacheLocation = cacheLocation;
	}
	
	protected void start() {
		// On first load the cache may not exist
		cacheLocation.mkdirs();
		
		File[] servers = this.cacheLocation.listFiles();
		for (int i = 0; i < servers.length; i++) {
			File serverCache = servers[i];
			File serverFile = new File(serverCache, "server.ser"); //$NON-NLS-1$
			
			ObjectInputStream ois = null;
			try {
				ois = new ObjectInputStream(new BufferedInputStream(new FileInputStream(serverFile)));
				XPlannerServer server = (XPlannerServer) ois.readObject();
				// TODO reconnect the services depending on user preferences
				
				serverByName.put(serverCache.getName(), server);
				ois.close();
			} catch (IOException e) {
				e.printStackTrace();
			} catch (ClassNotFoundException e) {
				e.printStackTrace();
			} finally {
				if (ois != null) {
					try {
						ois.close();
					} catch (IOException e) {
					}
				}
			}
		}
	}
	
	protected void stop() {
		for (Iterator<XPlannerServer> iServers = serverByName.values().iterator(); iServers.hasNext();) {
			XPlannerServer server = iServers.next();
			
			ObjectOutputStream oos = null;
			try {
				File cacheDir = new File(cacheLocation, server.getName());
				cacheDir.mkdirs();
				
				oos = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(new File(cacheDir, "server.ser")))); //$NON-NLS-1$
				oos.writeObject(server);
			} catch (IOException e) {
				e.printStackTrace();
			} finally {
				if (oos != null) {
					try {
						oos.close();
					} catch (IOException e) {
					}
				}
			}
		}
	}
	
	/**
	 * Tests the connection to a server.  If the URL is invalid ot the username
	 * and password are invalid this method will return with a exceptions carrying
	 * the failure reason. 
	 * @param baseUrl Base URL of the XPlanner installation
	 * @param username username to connect with
	 * @param password Password to connect with
	 * @return Short string describing the server information
	 * @throws AuthenticationException URL was valid but username and password were incorrect
	 * @throws ServiceUnavailableException URL was not valid
	 */
	public String testConnection(String baseUrl, String username, String password) throws AuthenticationException, ServiceUnavailableException {
		if (baseUrl == null || baseUrl.length() == 0) {
			throw new AuthenticationException(Messages.ServerManager_SERVER_URL_CANNOT_BE_EMPTY);
		}
		
		XPlannerServer server = null;
		
		try {
			new URL(baseUrl).openConnection(); // tests url validity

			server = createServer("Connection Test", baseUrl, false, username, password); //$NON-NLS-1$
			
			server.getTask(-1);
		}
		catch (RemoteException re) {
			if (re instanceof AxisFault) {
				String message = re.getMessage().trim();
				if (message.startsWith("(401)")) { //$NON-NLS-1$
					message = Messages.ServerManager_INVALID_USERNAME_PASSWORD;
				}
				else if (re.getCause() instanceof SAXException) {
					message = ""; //$NON-NLS-1$
				}
				else {
					message = message.startsWith(";") ? message.substring(1).trim() : message; //$NON-NLS-1$
				}
				throw new AuthenticationException(message);
			}
			else {
				throw new ServiceUnavailableException(re.getMessage());
			}
		}
		catch (Exception e) {
			throw new ServiceUnavailableException(e.getMessage());
		}
		finally {
			if (server != null) {
				removeServer(server);
			}
		}
		
		return "XPlanner"; //$NON-NLS-1$
	}
	
	public XPlannerServer getServer(String name) {
		return (XPlannerServer) serverByName.get(name);
	}
	
	public XPlannerServer[] getAllServers() {
		return (XPlannerServer[]) serverByName.values().toArray(new XPlannerServer[serverByName.size()]);
	}
	
	public XPlannerServer createServer(String name, String baseUrl, boolean hasSlowConnection, String username, String password) {
		if (baseUrl.charAt(baseUrl.length() - 1) == '/') {
			baseUrl = baseUrl.substring(0, baseUrl.length() - 1);
		}
		
		XPlannerServer server = new CachedXPlannerServer(name, baseUrl, hasSlowConnection, username, password);
		return server;
	}
	
	public void addServer(XPlannerServer server) {
		if (serverByName.containsKey(server.getName())) {
//			TODO: add this check back once the listeners for server property change are hooked up
//			 Also handle the case when serviceDelegate in the cachedServer is null
//			throw new RuntimeException("A server with that name already exists");
			removeServer(server);
		}
		serverByName.put(server.getName(), server);
		fireServerAddded(server);
	}
	
	public void removeServer(XPlannerServer server) {
		serverByName.remove(server.getName());
		
		File serverCache = new File(this.cacheLocation, server.getName());
		if (serverCache.exists()) {
			recursiveDelete(serverCache);
		}
		fireServerRemoved(server);
	}

	/**
	 * TODO need to make this a bit smarter.  Perhaps have an object to hold connectino info
	 * @param name
	 * @param baseURL
	 * @param username
	 * @param password
	 */
	public void updateServerDetails(String name, String baseURL, boolean hasSlowConnection, String username, String password) {
		CachedXPlannerServer server = (CachedXPlannerServer) serverByName.get(name);
		// TODO we should really have a modify event

		fireServerRemoved(server);
		
		// TODO need to flush the server cache since we are possibly a different person
		server.setBaseURL(baseURL);
		server.setSlowConnection(hasSlowConnection);
		server.setCurrentUserName(username);
		server.setCurrentPassword(password);
		
		fireServerAddded(server);
	}
	
	public void addServerListener(XPlannerServerListener listener) {
		listeners.add(listener);
	}
	
	public void removeServerListener(XPlannerServerListener listener) {
		listeners.remove(listener);
	}
	
	private void fireServerRemoved(XPlannerServer server) {
		for (Iterator<XPlannerServerListener> iListeners = listeners.iterator(); iListeners.hasNext();) {
			XPlannerServerListener listener = (XPlannerServerListener)iListeners.next();
			listener.serverRemoved(server);
		}
	}
	
	private void fireServerAddded(XPlannerServer server) {
		for (Iterator<XPlannerServerListener> iListeners = listeners.iterator(); iListeners.hasNext();) {
			XPlannerServerListener listener = (XPlannerServerListener)iListeners.next();
			listener.serverAdded(server);
		}
	}
	
	private void recursiveDelete(File baseFile) {
		if (baseFile.isFile()) {
			baseFile.delete();
		} else {
			File[] children = baseFile.listFiles();
			for (int i = 0; i < children.length; i++) {
				File file = children[i];
				recursiveDelete(file);
			}
			baseFile.delete();
		}
	}
}

Lines 1-3 Link Here

(-).settings/org.eclipse.core.resources.prefs (-1 / +1 lines)
1	#Fri Mar 09 11:38:32 PST 2007	1	#Fri Mar 09 11:38:32 PST 2007
2	eclipse.preferences.version=1	2	eclipse.preferences.version=1
3	encoding//src/org/eclipse/mylar/xplanner/core/messages.properties=8859_1	3	encoding//src/org/eclipse/mylyn/xplanner/core/messages.properties=8859_1

Lines 8-14 Link Here

(-)src/org/xplanner/soap/NoteData.java (-1 / +1 lines)
8	package org.xplanner.soap;	8	package org.xplanner.soap;
9		9
10	@SuppressWarnings("unchecked")	10	@SuppressWarnings("unchecked")
11	public class NoteData extends org.eclipse.mylar.xplanner.wsdl.soap.domain.DomainData implements java.io.Serializable {	11	public class NoteData extends org.eclipse.mylyn.xplanner.wsdl.soap.domain.DomainData implements java.io.Serializable {
12	private int attachedToId;	12	private int attachedToId;
13		13
14	private int attachmentId;	14	private int attachmentId;

Lines 8-14 Link Here

(-)src/org/xplanner/soap/ProjectData.java (-1 / +1 lines)
8	package org.xplanner.soap;	8	package org.xplanner.soap;
9		9
10	@SuppressWarnings("unchecked")	10	@SuppressWarnings("unchecked")
11	public class ProjectData extends org.eclipse.mylar.xplanner.wsdl.soap.domain.DomainData implements java.io.Serializable {	11	public class ProjectData extends org.eclipse.mylyn.xplanner.wsdl.soap.domain.DomainData implements java.io.Serializable {
12	private java.lang.String description;	12	private java.lang.String description;
13		13
14	private java.lang.String name;	14	private java.lang.String name;

Lines 8-14 Link Here

(-)src/org/xplanner/soap/UserStoryData.java (-1 / +1 lines)
8	package org.xplanner.soap;	8	package org.xplanner.soap;
9		9
10	@SuppressWarnings("unchecked")	10	@SuppressWarnings("unchecked")
11	public class UserStoryData extends org.eclipse.mylar.xplanner.wsdl.soap.domain.DomainData implements java.io.Serializable {	11	public class UserStoryData extends org.eclipse.mylyn.xplanner.wsdl.soap.domain.DomainData implements java.io.Serializable {
12	private double actualHours;	12	private double actualHours;
13		13
14	private double adjustedEstimatedHours;	14	private double adjustedEstimatedHours;

Lines 8-14 Link Here

(-)src/org/xplanner/soap/PersonData.java (-1 / +1 lines)
8	package org.xplanner.soap;	8	package org.xplanner.soap;
9		9
10	@SuppressWarnings("unchecked")	10	@SuppressWarnings("unchecked")
11	public class PersonData extends org.eclipse.mylar.xplanner.wsdl.soap.domain.DomainData implements java.io.Serializable {	11	public class PersonData extends org.eclipse.mylyn.xplanner.wsdl.soap.domain.DomainData implements java.io.Serializable {
12	private java.lang.String email;	12	private java.lang.String email;
13		13
14	private java.lang.String initials;	14	private java.lang.String initials;

Lines 8-14 Link Here

(-)src/org/xplanner/soap/TimeEntryData.java (-1 / +1 lines)
8	package org.xplanner.soap;	8	package org.xplanner.soap;
9		9
10	@SuppressWarnings("unchecked")	10	@SuppressWarnings("unchecked")
11	public class TimeEntryData extends org.eclipse.mylar.xplanner.wsdl.soap.domain.DomainData implements java.io.Serializable {	11	public class TimeEntryData extends org.eclipse.mylyn.xplanner.wsdl.soap.domain.DomainData implements java.io.Serializable {
12	private java.lang.String description;	12	private java.lang.String description;
13		13
14	private double duration;	14	private double duration;

Lines 8-14 Link Here

(-)src/org/xplanner/soap/TaskData.java (-1 / +1 lines)
8	package org.xplanner.soap;	8	package org.xplanner.soap;
9		9
10	@SuppressWarnings("unchecked")	10	@SuppressWarnings("unchecked")
11	public class TaskData extends org.eclipse.mylar.xplanner.wsdl.soap.domain.DomainData implements java.io.Serializable {	11	public class TaskData extends org.eclipse.mylyn.xplanner.wsdl.soap.domain.DomainData implements java.io.Serializable {
12	private int acceptorId;	12	private int acceptorId;
13		13
14	private double actualHours;	14	private double actualHours;

Lines 8-14 Link Here

(-)src/org/xplanner/soap/IterationData.java (-1 / +1 lines)
8	package org.xplanner.soap;	8	package org.xplanner.soap;
9		9
10	@SuppressWarnings("unchecked")	10	@SuppressWarnings("unchecked")
11	public class IterationData extends org.eclipse.mylar.xplanner.wsdl.soap.domain.DomainData implements java.io.Serializable {	11	public class IterationData extends org.eclipse.mylyn.xplanner.wsdl.soap.domain.DomainData implements java.io.Serializable {
12	private double actualHours;	12	private double actualHours;
13		13
14	private double addedHours;	14	private double addedHours;

Lines 5-11 Link Here

(-)src-gen/org/eclipse/mylyn/xplanner/wsdl/soap/domain/DomainData.java (-1 / +1 lines)
5	* by the Apache Axis 1.3 Oct 05, 2005 (05:23:37 EDT) WSDL2Java emitter.	5	* by the Apache Axis 1.3 Oct 05, 2005 (05:23:37 EDT) WSDL2Java emitter.
6	*/	6	*/
7		7
8	package org.eclipse.mylar.xplanner.wsdl.soap.domain;	8	package org.eclipse.mylyn.xplanner.wsdl.soap.domain;
9		9
10	@SuppressWarnings("unchecked")	10	@SuppressWarnings("unchecked")
11	public abstract class DomainData implements java.io.Serializable {	11	public abstract class DomainData implements java.io.Serializable {




 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.core.service;

import org.eclipse.core.runtime.*;
import org.eclipse.mylyn.xplanner.core.IXPlannerCoreExtensionConstants;
import org.eclipse.mylyn.xplanner.core.XPlannerCorePlugin;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.mylar.xplanner.core.IXPlannerCoreExtensionConstants;
import org.eclipse.mylar.xplanner.core.XPlannerCorePlugin;


/**
 * TODO This is eclipse specific at the moment.  Need to find a way to load a
 * XPlannerService instance based off some use preference.
 * TODO mention that this should really only be used by internal classes and tests
 *

	
	private static XPlannerServiceFactory factory;
	
	public static synchronized XPlannerService getXPlannerService(XPlannerClient client) {
		if (factory == null) {
			factory = loadServiceProviderFactories();
		}
		return factory.createService(client);
	}
	
	public static XPlannerServiceFactory loadServiceProviderFactories() {

					for (int j = 0; j < configElements.length; j++) {
						try {
							return (XPlannerServiceFactory) configElements[j].createExecutableExtension("class"); //$NON-NLS-1$
						} 
						catch (CoreException e) {
							plugin.getLog().log(e.getStatus());
						} 
						catch (ClassCastException e) {
							XPlannerCorePlugin.log(IStatus.ERROR, "Must implement the correct class", e); //$NON-NLS-1$
							XPlannerCorePlugin.log(IStatus.ERROR, "Must implement the correct class", e); //$NON-NLS-1$
						}




/*******************************************************************************
 * Copyright (c) 2007 - 2007 CodeGear and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylar.xplanner.core.service;

import java.io.Serializable;
import java.rmi.RemoteException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;

import org.eclipse.mylar.xplanner.wsdl.db.QueryException;
import org.xplanner.soap.IterationData;
import org.xplanner.soap.NoteData;
import org.xplanner.soap.PersonData;
import org.xplanner.soap.ProjectData;
import org.xplanner.soap.TaskData;
import org.xplanner.soap.TimeEntryData;
import org.xplanner.soap.UserStoryData;


/**
 * XPlanner server implementation that caches information that is unlikey to change
 * during the session.  This server could be persisted to disk and re-loaded.
 * It has lifecycle methods to allow data in the cache to be reloaded.
 * 
 * TODO it is assumed that it will be backed by a standad XPlanner service layer 
 * 
 * @author Ravi Kumar
 * @author Helen Bershadskaya
 */
public class CachedXPlannerServer extends XPlannerServer implements Serializable {
  public static final int INVALID_ID = -1;
  
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	private String name;
	private String baseURL;
	private boolean hasSlowConnection;
	private String userName;
	private String password;
	private transient XPlannerService serviceDelegate;

	public CachedXPlannerServer(String name, String baseURL, boolean hasSlowConnection, String userName, String password) {
		this.name = name;
		this.baseURL = baseURL;
		this.hasSlowConnection = hasSlowConnection;
		this.userName = userName;
		this.password = password;
		
		this.serviceDelegate = ServiceManager.getXPlannerService(this);
		serviceDelegate.login(userName, password);
	}

	public String getBaseURL() {
		return baseURL;
	}

	public String getCurrentUserName() {
		return userName;
	}

	public String getCurrentUserPassword() {
		return password;
	}

	public int getMaximumNumberOfMatches() {
		return 0;
	}

	public String getName() {
		return name;
	}

	public boolean hasSlowConnection() {
		return hasSlowConnection;
	}


	public void setSlowConnection(boolean hasSlowConnection) {
		this.hasSlowConnection = hasSlowConnection;
	}

	public void setBaseURL(String baseURL) {
		this.baseURL = baseURL;
	}

	public void setCurrentPassword(String password) {
		this.password = password;
	}

	public void setCurrentUserName(String userName) {
		this.userName = userName;
	}
	
	public String login(String username, String password) {
		return serviceDelegate.login(username, password);		
	}

	public boolean logout() {
		boolean ok = true;
	
		//TODO -- shouldn't have a null service delegate, but definitely get into this condition if "finish"
		// repository definition with an invalid server
	
		if (serviceDelegate != null) {
			ok = serviceDelegate.logout();
		}
		
		return ok;
	}

	public IterationData addIteration(IterationData iteration) throws RemoteException {
		return serviceDelegate.addIteration(iteration);
	}

	public NoteData addNote(NoteData note) throws RemoteException {
		return serviceDelegate.addNote(note);
	}

	public PersonData addPerson(PersonData object) throws RemoteException {
		return serviceDelegate.addPerson(object);
	}

	public ProjectData addProject(ProjectData project) throws RemoteException {
		return serviceDelegate.addProject(project);
	}

	public TaskData addTask(TaskData task) throws RemoteException {
		return serviceDelegate.addTask(task);
	}

	public TimeEntryData addTimeEntry(TimeEntryData timeEntry) throws RemoteException {
		return serviceDelegate.addTimeEntry(timeEntry);
	}

	public UserStoryData addUserStory(UserStoryData story) throws RemoteException {
		return serviceDelegate.addUserStory(story);
	}

	public void deleteAttribute(int objectId, String key) throws RemoteException {
		serviceDelegate.deleteAttribute(objectId, key);
	}

	public boolean equals(Object obj) {
		return this == obj || serviceDelegate.equals(obj) || 
		 (obj instanceof CachedXPlannerServer && ((CachedXPlannerServer)obj).serviceDelegate.equals(serviceDelegate));
	}

	public String getAttribute(int objectId, String key) throws RemoteException {
		return serviceDelegate.getAttribute(objectId, key);
	}

	@SuppressWarnings("unchecked")
	public HashMap getAttributes(int objectId) throws RemoteException {
		return serviceDelegate.getAttributes(objectId);
	}

	@SuppressWarnings("unchecked")
	public HashMap getAttributesWithPrefix(int objectId, String prefix) throws RemoteException {
		return serviceDelegate.getAttributesWithPrefix(objectId, prefix);
	}

	public IterationData getCurrentIteration(int projectId) throws RemoteException {
		return serviceDelegate.getCurrentIteration(projectId);
	}

	public TaskData[] getCurrentTasksForPerson(int personId) throws RemoteException, QueryException {
		return serviceDelegate.getCurrentTasksForPerson(personId);
	}

	public IterationData getIteration(int id) throws RemoteException {
		return serviceDelegate.getIteration(id);
	}

	public IterationData[] getIterations(int projectId) throws RemoteException {
		return serviceDelegate.getIterations(projectId);
	}

	public NoteData getNote(int id) throws RemoteException {
		return serviceDelegate.getNote(id);
	}

	public NoteData[] getNotesForObject(int attachedToId) throws RemoteException {
		return serviceDelegate.getNotesForObject(attachedToId);
	}

	public PersonData[] getPeople() throws RemoteException {
		return serviceDelegate.getPeople();
	}

	public PersonData getPerson(int id) throws RemoteException {
		return serviceDelegate.getPerson(id);
	}

	public TaskData[] getPlannedTasksForPerson(int personId) throws RemoteException, QueryException {
		return serviceDelegate.getPlannedTasksForPerson(personId);
	}

	public ProjectData getProject(int id) throws RemoteException {
		return serviceDelegate.getProject(id);
	}

	public ProjectData[] getProjects() throws RemoteException {
		return serviceDelegate.getProjects();
	}

	public TaskData getTask(int id) throws RemoteException {
		if (serviceDelegate == null) {
			System.out.println(" why is serivce Delegate null???"); //$NON-NLS-1$
		}
		return serviceDelegate.getTask(id);
	}

	public TaskData[] getTasks(int containerId) throws RemoteException {
		return serviceDelegate.getTasks(containerId);
	}

	public TimeEntryData[] getTimeEntries(int containerId) throws RemoteException {
		return serviceDelegate.getTimeEntries(containerId);
	}

	public TimeEntryData getTimeEntry(int id) throws RemoteException {
		return serviceDelegate.getTimeEntry(id);
	}

	public UserStoryData[] getUserStories(int containerId) throws RemoteException {
		return serviceDelegate.getUserStories(containerId);
	}

	public UserStoryData getUserStory(int id) throws RemoteException {
		return serviceDelegate.getUserStory(id);
	}

	public int hashCode() {
		return serviceDelegate.hashCode();
	}

	public void removeIteration(int id) throws RemoteException {
		serviceDelegate.removeIteration(id);
	}

	public void removeNote(int id) throws RemoteException {
		serviceDelegate.removeNote(id);
	}

	public void removePerson(int id) throws RemoteException {
		serviceDelegate.removePerson(id);
	}

	public void removeProject(int id) throws RemoteException {
		serviceDelegate.removeProject(id);
	}

	public void removeTask(int id) throws RemoteException {
		serviceDelegate.removeTask(id);
	}

	public void removeTimeEntry(int id) throws RemoteException {
		serviceDelegate.removeTimeEntry(id);
	}

	public void removeUserStory(int id) throws RemoteException {
		serviceDelegate.removeUserStory(id);
	}

	public void setAttribute(int objectId, String key, String value) throws RemoteException {
		serviceDelegate.setAttribute(objectId, key, value);
	}

	public void update(IterationData object) throws RemoteException {
		serviceDelegate.update(object);
	}

	public void update(NoteData note) throws RemoteException {
		serviceDelegate.update(note);
	}

	public void update(PersonData object) throws RemoteException {
		serviceDelegate.update(object);
	}

	public void update(ProjectData object) throws RemoteException {
		serviceDelegate.update(object);
	}

	public void update(TaskData object) throws RemoteException {
		serviceDelegate.update(object);
	}

	public void update(TimeEntryData object) throws RemoteException {
		serviceDelegate.update(object);
	}

	public void update(UserStoryData object) throws RemoteException {
		serviceDelegate.update(object);
	}

	public TaskData[] getUserStoryTasksForPerson(int personId, int userStoryId) {
		if (personId < 0 || userStoryId < 0) {
			return new TaskData[0];
		}
		
		List<TaskData> userStoryTasksForPerson = new ArrayList<TaskData>();
		try {
			TaskData[] iterationTasks = getTasks(userStoryId);
			// get all tasks for specified user storyserv
			for (int i = 0; i < iterationTasks.length; i++) {
				TaskData taskData = iterationTasks[i];
				if (taskData.getAcceptorId() == personId) {
					userStoryTasksForPerson.add(taskData);
				}
			}
			
		}
		catch (RemoteException e) {
			e.printStackTrace();
		}
		
		return userStoryTasksForPerson.toArray(new TaskData[userStoryTasksForPerson.size()]);
	}
	
	public UserStoryData[] getIterationUserStoriesForTracker(int trackerId, int iterationId) {
		if (trackerId < 0 || iterationId < 0) {
			return new UserStoryData[0];
		}

		List<UserStoryData> userStoriesForTracker = new ArrayList<UserStoryData>();
		UserStoryData[] userStories;
		try {
			userStories = getUserStories(iterationId);
			// get all tasks for specified user story
			for (int i = 0; i < userStories.length; i++) {
				UserStoryData userStory = userStories[i];
				if (userStory.getTrackerId() == trackerId) {
					userStoriesForTracker.add(userStory);
				}
			}
		}
		catch (RemoteException e) {
			e.printStackTrace();
		}
		
		return userStoriesForTracker.toArray(new UserStoryData[userStoriesForTracker.size()]);
	}

	public int getCurrentPersonId() {
		int currentPersonId = INVALID_ID;
		
	  String userName = getCurrentUserName();
	  if (userName != null) {
	  	try {
				PersonData[] people = getPeople();
				if (people != null) {
					for (int i = 0; i < people.length && currentPersonId == INVALID_ID; i++) {
						PersonData person = people[i];
						if (person.getUserId().equals(userName)) {
							currentPersonId = person.getId();
						}
					}
				}
			}
			catch (RemoteException e) {
				e.printStackTrace();
			}
	  }
	  
	  return currentPersonId;
	}
	
	public UserStoryData[] getUserStoriesForProject(int projectId) {
		if (projectId == INVALID_ID) {
			return new UserStoryData[0];
		}
		
		ArrayList<UserStoryData> projectUserStories = new ArrayList<UserStoryData>();
		try {
			IterationData[] projectIterations = getIterations(projectId);
			for (IterationData iteration : projectIterations) {
				UserStoryData[] iterationUserStories = getUserStories(iteration.getId());
				if (iterationUserStories.length > 0) {
					projectUserStories.addAll(Arrays.asList(iterationUserStories));
				}
			}
		}
		catch (RemoteException e) {
			e.printStackTrace();
		}
		
		return (UserStoryData[]) projectUserStories.toArray(new UserStoryData[projectUserStories.size()]);
	}
	
	public UserStoryData[] getUserStoriesForProject(int projectId, int trackerId) {
		if (projectId == INVALID_ID) {
			return new UserStoryData[0];
		}
		
		ArrayList<UserStoryData> projectTrackerUserStories = new ArrayList<UserStoryData>();
		UserStoryData[] projectUserStories = getUserStoriesForProject(projectId);
		for (UserStoryData userStory : projectUserStories) {
			if (userStory.getTrackerId() == trackerId) {
				projectTrackerUserStories.add(userStory);
			}
		}
		
		return (UserStoryData[]) projectTrackerUserStories.toArray(new UserStoryData[projectTrackerUserStories.size()]);

	}
	
	public TaskData[] getTasksForProject(int projectId) {
		if (projectId == -1) {
			return new TaskData[0];
		}
		
		ArrayList<TaskData> projectTasks = new ArrayList<TaskData>();
		try {
			UserStoryData[] userStories = getUserStoriesForProject(projectId);
			for (UserStoryData userStory : userStories) {
				TaskData[] userStoryTasks = getTasks(userStory.getId());
				if (userStoryTasks.length > 0) {
					projectTasks.addAll(Arrays.asList(userStoryTasks));
				}
			}
		}
		catch (RemoteException e) {
			e.printStackTrace();
		}
		
		return (TaskData[]) projectTasks.toArray(new TaskData[projectTasks.size()]);
	}
	
	public TaskData[] getTasksForProject(int projectId, int personId) {
		if (projectId == INVALID_ID || personId == INVALID_ID) {
			return new TaskData[0];
		}
		
		ArrayList<TaskData> projectPersonTasks = new ArrayList<TaskData>();
		TaskData[] allProjectTasks = getTasksForProject(projectId);
		for (TaskData task : allProjectTasks) {
			if (task.getAcceptorId() == personId) {
				projectPersonTasks.add(task);
			}
		}
		
		return (TaskData[]) projectPersonTasks.toArray(new TaskData[projectPersonTasks.size()]);
	}
	
	public TaskData[] getTasksForIteration(int iterationId) {
		if (iterationId == INVALID_ID) {
			return new TaskData[0];
		}
		
		ArrayList<TaskData> iterationTasks = new ArrayList<TaskData>();
		try {
			UserStoryData[] userStories = getUserStories(iterationId);
			for (UserStoryData userStory : userStories) {
				TaskData[] userStoryTasks = getTasks(userStory.getId());
				if (userStoryTasks.length > 0) {
					iterationTasks.addAll(Arrays.asList(userStoryTasks));
				}
			}
		}
		catch (RemoteException e) {
			e.printStackTrace();
		}
		
		return (TaskData[]) iterationTasks.toArray(new TaskData[iterationTasks.size()]);
	}
	
	public TaskData[] getTasksForIteration(int iterationId, int personId) {
		if (iterationId == INVALID_ID || personId == INVALID_ID) {
			return new TaskData[0];
		}
		
		ArrayList<TaskData> iterationPersonTasks = new ArrayList<TaskData>();
		TaskData[] allIterationTasks = getTasksForIteration(iterationId);
		for (TaskData task : allIterationTasks) {
			if (task.getAcceptorId() == personId) {
				iterationPersonTasks.add(task);
			}
		}
		
		return (TaskData[]) iterationPersonTasks.toArray(new TaskData[iterationPersonTasks.size()]);
	}
}

Lines 5-11 Link Here

(-)src/org/eclipse/mylyn/xplanner/core/service/PasswordPrompter.java (-1 / +1 lines)
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html	6	* http://www.eclipse.org/legal/epl-v10.html
7	*******************************************************************************/	7	*******************************************************************************/
8	package org.eclipse.mylar.xplanner.core.service;	8	package org.eclipse.mylyn.xplanner.core.service;
9		9
10	import java.net.URL;	10	import java.net.URL;
11		11




 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.core.service;

/**
 * Factory class for creating ta XPlanner Service imlementation.

 */
public interface XPlannerServiceFactory {
	/**
	 * Create a new service that will communicate to the supplied <code>client</code>.
	 * How the service talks to the client is up to the implementation.
	 * @param client XPlannerClient instance to communicate with
	 * @return Configured XPlanner Service
	 */
	public abstract XPlannerService createService(XPlannerClient client);
}




 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.core.service;

import org.eclipse.mylyn.xplanner.core.service.exceptions.AuthenticationException;
import org.eclipse.mylyn.xplanner.core.service.exceptions.ServiceUnavailableException;
import org.xplanner.soap.XPlanner.XPlanner;



    }
    
	/**
	 * Refresh any cached information with the latest values from the remote client.
	 * This operation may take a long time to complete and should not be called
	 * from a UI thread.
	 */

Lines 5-11 Link Here

(-)src/org/eclipse/mylyn/xplanner/core/service/XPlannerServer.java (-2 / +8 lines)
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html	6	* http://www.eclipse.org/legal/epl-v10.html
7	*******************************************************************************/	7	*******************************************************************************/
8	package org.eclipse.mylar.xplanner.core.service;	8	package org.eclipse.mylyn.xplanner.core.service;
		9
		10	import java.net.Proxy;
9		11
10	import org.xplanner.soap.TaskData;	12	import org.xplanner.soap.TaskData;
11	import org.xplanner.soap.UserStoryData;	13	import org.xplanner.soap.UserStoryData;
Lines 68-79 Link Here
68	public abstract TaskData[] getTasksForProject(int projectId, int personId);	70	public abstract TaskData[] getTasksForProject(int projectId, int personId);
69	public abstract TaskData[] getTasksForIteration(int iterationId);	71	public abstract TaskData[] getTasksForIteration(int iterationId);
70	public abstract TaskData[] getTasksForIteration(int iterationId, int personId);	72	public abstract TaskData[] getTasksForIteration(int iterationId, int personId);
		73	public abstract boolean useCompression();
		74	public abstract Proxy getProxy();
		75	public abstract String getHttpUser();
		76	public abstract String getHttpPassword();
71		77
72	// /**	78	// /**
73	// * Force a login to the remote repository.	79	// * Force a login to the remote repository.
74	// * @deprecated There is no need to call this method as all services should automatically	80	// * @deprecated There is no need to call this method as all services should automatically
75	// * login when the session is about to expire. If you need to check if the credentials	81	// * login when the session is about to expire. If you need to check if the credentials
76	// * are valid, call {@link org.eclipse.mylar.xplanner.core.ServerManager#testConnection(String, String, String)}	82	// * are valid, call {@link org.eclipse.mylyn.xplanner.core.ServerManager#testConnection(String, String, String)}
77	// */	83	// */
78	// public abstract void login();	84	// public abstract void login();
79	//	85	//

Lines 22-27 Link Here

(-).project (+1 lines)
22	</buildCommand>	22	</buildCommand>
23	</buildSpec>	23	</buildSpec>
24	<natures>	24	<natures>
		25	<nature>org.eclipse.jem.workbench.JavaEMFNature</nature>
25	<nature>org.eclipse.pde.PluginNature</nature>	26	<nature>org.eclipse.pde.PluginNature</nature>
26	<nature>org.eclipse.jdt.core.javanature</nature>	27	<nature>org.eclipse.jdt.core.javanature</nature>
27	</natures>	28	</natures>

Lines 4-13 Link Here

(-)XPlanner WSDL2Java.launch (-3 / +3 lines)
4	<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">	4	<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">
5	<listEntry value="4"/>	5	<listEntry value="4"/>
6	</listAttribute>	6	</listAttribute>
7	<stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="-o "${project_loc:org.eclipse.mylar.core.soap}/src" ./wsdl/XPlanner.wsdl"/>	7	<stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="-o "${project_loc:org.eclipse.mylyn.core.soap}/src" ./wsdl/XPlanner.wsdl"/>
8	<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="org.eclipse.mylar.core.soap"/>	8	<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="org.eclipse.mylyn.core.soap"/>
9	<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">	9	<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
10	<listEntry value="/org.eclipse.mylar.core.soap"/>	10	<listEntry value="/org.eclipse.mylyn.core.soap"/>
11	</listAttribute>	11	</listAttribute>
12	<booleanAttribute key="org.eclipse.debug.core.appendEnvironmentVariables" value="true"/>	12	<booleanAttribute key="org.eclipse.debug.core.appendEnvironmentVariables" value="true"/>
13	</launchConfiguration>	13	</launchConfiguration>

Lines 7-15 Link Here

(-)plugin.xml (-2 / +2 lines)
7	schema="schema/serviceProviderFactory.exsd"/>	7	schema="schema/serviceProviderFactory.exsd"/>
8		8
9	<extension	9	<extension
10	point="org.eclipse.mylar.xplanner.core.serviceProviderFactory">	10	point="org.eclipse.mylyn.xplanner.core.serviceProviderFactory">
11	<serviceProviderFactory	11	<serviceProviderFactory
12	class="org.eclipse.mylar.xplanner.core.service.soap.SoapXPlannerServiceFactory"	12	class="org.eclipse.mylyn.xplanner.core.service.soap.SoapXPlannerServiceFactory"
13	name="%serviceProviderFactoryNameSoap"/>	13	name="%serviceProviderFactoryNameSoap"/>
14	</extension>	14	</extension>
15	</plugin>	15	</plugin>

Lines 1-4 Link Here

(-)plugin.properties (-2 / +2 lines)
1	bundleName=Mylar Connector for XPlanner: Core	1	bundleName=Mylyn XPlanner Core Plug-in
2	bundleVendor=Eclipse.org	2	bundleVendor=Eclipse.org
3	extensionPointNameServiceProviderFactory=Mylar XPlanner Service Provider Factory	3	extensionPointNameServiceProviderFactory=Mylyn XPlanner Service Provider Factory
4	serviceProviderFactoryNameSoap=SOAP Service Provider	4	serviceProviderFactoryNameSoap=SOAP Service Provider




source.. = src/, src-gen/
output.. = bin/
source.plugin.jar = src/,\
                    src-gen/
output.plugin.jar = bin/
bin.includes = .,\
               lib/,\
               META-INF/,\
               schema/,\
               plugin.jar,\
               plugin.properties,\
               plugin.xml,\
               about.html

               lib/,\
               META-INF/,\
               schema/,\
               plugin.jar,\
               plugin.properties,\
               plugin.xml,\
               about.html,\

Lines 5-11 Link Here

(-)src-gen/org/eclipse/mylyn/xplanner/wsdl/db/QueryException.java (-1 / +1 lines)
5	* by the Apache Axis 1.3 Oct 05, 2005 (05:23:37 EDT) WSDL2Java emitter.	5	* by the Apache Axis 1.3 Oct 05, 2005 (05:23:37 EDT) WSDL2Java emitter.
6	*/	6	*/
7		7
8	package org.eclipse.mylar.xplanner.wsdl.db;	8	package org.eclipse.mylyn.xplanner.wsdl.db;
9		9
10	@SuppressWarnings("unchecked")	10	@SuppressWarnings("unchecked")
11	public class QueryException extends org.apache.axis.AxisFault implements java.io.Serializable {	11	public class QueryException extends org.apache.axis.AxisFault implements java.io.Serializable {




<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.eclipse.mylyn.xplanner.core">
<annotation>
      <appInfo>
         <meta.schema plugin="org.eclipse.mylyn.xplanner.core" id="serviceProviderFactory" name="Service provider factory"/>
      </appInfo>
      <documentation>
         [Enter description of this extension point.]

                  Class that implements the XPlanner Core service interface
               </documentation>
               <appInfo>
                  <meta.attribute kind="java" basedOn=":org.eclipse.mylyn.xplanner.core.service.XPlannerServiceFactory"/>
               </appInfo>
            </annotation>
         </attribute>




    xPlanner.removeUserStory(id);
  }
  
  public org.xplanner.soap.TaskData[] getCurrentTasksForPerson(int personId) throws java.rmi.RemoteException, org.eclipse.mylyn.xplanner.wsdl.db.QueryException{
    if (xPlanner == null)
      _initXPlannerProxy();
    return xPlanner.getCurrentTasksForPerson(personId);
  }
  
  public org.xplanner.soap.TaskData[] getPlannedTasksForPerson(int personId) throws java.rmi.RemoteException, org.eclipse.mylyn.xplanner.wsdl.db.QueryException{
    if (xPlanner == null)
      _initXPlannerProxy();
    return xPlanner.getPlannedTasksForPerson(personId);

Lines 40-47 Link Here

(-)src/org/xplanner/soap/XPlanner/XPlanner.java (-2 / +2 lines)
40	public void removeIteration(int id) throws java.rmi.RemoteException;	40	public void removeIteration(int id) throws java.rmi.RemoteException;
41	public org.xplanner.soap.UserStoryData addUserStory(org.xplanner.soap.UserStoryData story) throws java.rmi.RemoteException;	41	public org.xplanner.soap.UserStoryData addUserStory(org.xplanner.soap.UserStoryData story) throws java.rmi.RemoteException;
42	public void removeUserStory(int id) throws java.rmi.RemoteException;	42	public void removeUserStory(int id) throws java.rmi.RemoteException;
43	public org.xplanner.soap.TaskData[] getCurrentTasksForPerson(int personId) throws java.rmi.RemoteException, org.eclipse.mylar.xplanner.wsdl.db.QueryException;	43	public org.xplanner.soap.TaskData[] getCurrentTasksForPerson(int personId) throws java.rmi.RemoteException, org.eclipse.mylyn.xplanner.wsdl.db.QueryException;
44	public org.xplanner.soap.TaskData[] getPlannedTasksForPerson(int personId) throws java.rmi.RemoteException, org.eclipse.mylar.xplanner.wsdl.db.QueryException;	44	public org.xplanner.soap.TaskData[] getPlannedTasksForPerson(int personId) throws java.rmi.RemoteException, org.eclipse.mylyn.xplanner.wsdl.db.QueryException;
45	public void removeTask(int id) throws java.rmi.RemoteException;	45	public void removeTask(int id) throws java.rmi.RemoteException;
46	public org.xplanner.soap.TimeEntryData getTimeEntry(int id) throws java.rmi.RemoteException;	46	public org.xplanner.soap.TimeEntryData getTimeEntry(int id) throws java.rmi.RemoteException;
47	public org.xplanner.soap.TimeEntryData addTimeEntry(org.xplanner.soap.TimeEntryData timeEntry) throws java.rmi.RemoteException;	47	public org.xplanner.soap.TimeEntryData addTimeEntry(org.xplanner.soap.TimeEntryData timeEntry) throws java.rmi.RemoteException;




        oper.setUse(org.apache.axis.constants.Use.ENCODED);
        oper.addFault(new org.apache.axis.description.FaultDesc(
                      new javax.xml.namespace.QName("http://xplanner.org:8080/soap/XPlanner", "fault"), //$NON-NLS-1$ //$NON-NLS-2$
                      "org.eclipse.mylyn.xplanner.wsdl.db.QueryException", //$NON-NLS-1$
                      new javax.xml.namespace.QName("http://db.xplanner.technoetic.com", "QueryException"),  //$NON-NLS-1$ //$NON-NLS-2$
                      true
                     ));

        oper.setUse(org.apache.axis.constants.Use.ENCODED);
        oper.addFault(new org.apache.axis.description.FaultDesc(
                      new javax.xml.namespace.QName("http://xplanner.org:8080/soap/XPlanner", "fault"), //$NON-NLS-1$ //$NON-NLS-2$
                      "org.eclipse.mylyn.xplanner.wsdl.db.QueryException", //$NON-NLS-1$
                      new javax.xml.namespace.QName("http://db.xplanner.technoetic.com", "QueryException"),  //$NON-NLS-1$ //$NON-NLS-2$
                      true
                     ));

            java.lang.Class simplelistdf = org.apache.axis.encoding.ser.SimpleListDeserializerFactory.class;
            qName = new javax.xml.namespace.QName("http://db.xplanner.technoetic.com", "QueryException"); //$NON-NLS-1$ //$NON-NLS-2$
            cachedSerQNames.add(qName);
            cls = org.eclipse.mylyn.xplanner.wsdl.db.QueryException.class;
            cachedSerClasses.add(cls);
            cachedSerFactories.add(beansf);
            cachedDeserFactories.add(beandf);

            qName = new javax.xml.namespace.QName("http://domain.soap.xplanner.technoetic.com", "DomainData"); //$NON-NLS-1$ //$NON-NLS-2$
            cachedSerQNames.add(qName);
            cls = org.eclipse.mylyn.xplanner.wsdl.soap.domain.DomainData.class;
            cachedSerClasses.add(cls);
            cachedSerFactories.add(beansf);
            cachedDeserFactories.add(beandf);

        _call.setSOAPActionURI(""); //$NON-NLS-1$
        _call.setSOAPVersion(org.apache.axis.soap.SOAPConstants.SOAP11_CONSTANTS);
        _call.setOperationName(new javax.xml.namespace.QName("http://soap.xplanner.technoetic.com", "getTask")); //$NON-NLS-1$ //$NON-NLS-2$
        _call.setTimeout(new Integer(30000));
        
        setRequestHeaders(_call);
        setAttachments(_call);
 try {        java.lang.Object _resp = _call.invoke(new java.lang.Object[] {new java.lang.Integer(id)});

}
    }

    public org.xplanner.soap.TaskData[] getCurrentTasksForPerson(int personId) throws java.rmi.RemoteException, org.eclipse.mylyn.xplanner.wsdl.db.QueryException {
        if (super.cachedEndpoint == null) {
            throw new org.apache.axis.NoEndPointException();
        }

        if (axisFaultException.detail instanceof java.rmi.RemoteException) {
              throw (java.rmi.RemoteException) axisFaultException.detail;
         }
        if (axisFaultException.detail instanceof org.eclipse.mylyn.xplanner.wsdl.db.QueryException) {
              throw (org.eclipse.mylyn.xplanner.wsdl.db.QueryException) axisFaultException.detail;
         }
   }
  throw axisFaultException;
}
    }

    public org.xplanner.soap.TaskData[] getPlannedTasksForPerson(int personId) throws java.rmi.RemoteException, org.eclipse.mylyn.xplanner.wsdl.db.QueryException {
        if (super.cachedEndpoint == null) {
            throw new org.apache.axis.NoEndPointException();
        }

        if (axisFaultException.detail instanceof java.rmi.RemoteException) {
              throw (java.rmi.RemoteException) axisFaultException.detail;
         }
        if (axisFaultException.detail instanceof org.eclipse.mylyn.xplanner.wsdl.db.QueryException) {
              throw (org.eclipse.mylyn.xplanner.wsdl.db.QueryException) axisFaultException.detail;
         }
   }
  throw axisFaultException;

Lines 7-15 Link Here

(-)src/org/xplanner/soap/XPlanner/XPlannerServiceLocator.java (+74 lines)
7		7
8	package org.xplanner.soap.XPlanner;	8	package org.xplanner.soap.XPlanner;
9		9
		10	import java.net.Proxy;
		11	import java.util.Hashtable;
		12	import java.util.Map;
		13
		14	import javax.xml.rpc.Call;
		15	import javax.xml.rpc.ServiceException;
		16
		17	import org.apache.axis.transport.http.HTTPConstants;
		18
10	@SuppressWarnings("unchecked")	19	@SuppressWarnings("unchecked")
11	public class XPlannerServiceLocator extends org.apache.axis.client.Service implements org.xplanner.soap.XPlanner.XPlannerService {	20	public class XPlannerServiceLocator extends org.apache.axis.client.Service implements org.xplanner.soap.XPlanner.XPlannerService {
12		21
		22	private Proxy proxy;
		23	private String httpUser;
		24	private String httpPassword;
		25	private boolean compression;
		26
13	public XPlannerServiceLocator() {	27	public XPlannerServiceLocator() {
14	}	28	}
15		29
Lines 140-143 Link Here
140	setEndpointAddress(portName.getLocalPart(), address);	154	setEndpointAddress(portName.getLocalPart(), address);
141	}	155	}
142		156
		157	/*
		158	* (non-Javadoc)
		159	*
		160	* @see org.apache.axis.client.Service#createCall()
		161	*/
		162	public Call createCall() throws ServiceException {
		163	Call call = super.createCall();
		164	// JIRA does not accept compressed SOAP messages: see bug 175915
		165	//call.setProperty(HTTPConstants.MC_GZIP_REQUEST, Boolean.TRUE);
		166	if (compression) {
		167	call.setProperty(HTTPConstants.MC_ACCEPT_GZIP, Boolean.TRUE);
		168	}
		169	if (httpUser != null && httpPassword != null) {
		170	call.setProperty(XPlannerHttpSender.HTTP_USER, httpUser);
		171	call.setProperty(XPlannerHttpSender.HTTP_PASSWORD, httpPassword);
		172	}
		173	if (proxy != null) {
		174	call.setProperty(XPlannerHttpSender.PROXY, proxy);
		175	}
		176
		177	// Some clients break with a 411 Length Required when chunked encoding
		178	// is used
		179	Map<String, Boolean> headers = new Hashtable<String, Boolean>();
		180	headers.put(HTTPConstants.HEADER_TRANSFER_ENCODING_CHUNKED, Boolean.FALSE);
		181	call.setProperty(HTTPConstants.REQUEST_HEADERS, headers);
		182	return call;
		183	}
		184
		185	public Proxy getProxy() {
		186	return proxy;
		187	}
		188
		189	public void setProxy(Proxy proxy) {
		190	this.proxy = proxy;
		191	}
		192
		193	public String getHttpUser() {
		194	return httpUser;
		195	}
		196
		197	public void setHttpUser(String httpUser) {
		198	this.httpUser = httpUser;
		199	}
		200
		201	public String getHttpPassword() {
		202	return httpPassword;
		203	}
		204
		205	public void setHttpPassword(String httpPassword) {
		206	this.httpPassword = httpPassword;
		207	}
		208
		209	public boolean isCompression() {
		210	return compression;
		211	}
		212
		213	public void setCompression(boolean compression) {
		214	this.compression = compression;
		215	}
		216
143	}	217	}

Lines 1-18 Link Here

(-)META-INF/MANIFEST.MF (-9 / +12 lines)
1	Manifest-Version: 1.0	1	Manifest-Version: 1.0
2	Bundle-ManifestVersion: 2	2	Bundle-ManifestVersion: 2
3	Bundle-Name: %bundleName	3	Bundle-Name: %bundleName
4	Bundle-SymbolicName: org.eclipse.mylar.xplanner.core;singleton:=true	4	Bundle-SymbolicName: org.eclipse.mylyn.xplanner.core;singleton:=true
5	Bundle-Version: 2.0.0.qualifier	5	Bundle-Version: 2.0.0.qualifier
6	Bundle-Activator: org.eclipse.mylar.xplanner.core.XPlannerCorePlugin	6	Bundle-Activator: org.eclipse.mylyn.xplanner.core.XPlannerCorePlugin
7	Bundle-Vendor: %bundleVendor	7	Bundle-Vendor: %bundleVendor
8	Bundle-Localization: plugin	8	Bundle-Localization: plugin
9	Require-Bundle: org.eclipse.core.runtime	9	Require-Bundle: org.eclipse.core.runtime,
		10	org.eclipse.mylyn,
		11	org.eclipse.mylyn.web.core
10	Eclipse-LazyStart: true	12	Eclipse-LazyStart: true
11	Export-Package: org.eclipse.mylar.xplanner.core,	13	Export-Package: org.apache.axis,
12	org.eclipse.mylar.xplanner.core.service,
13	org.eclipse.mylar.xplanner.core.service.exceptions,org.eclipse.mylar.xplanner.wsdl.db,
14	org.eclipse.mylar.xplanner.wsdl.soap.domain,
15	org.apache.axis,
16	org.apache.axis.attachments,	14	org.apache.axis.attachments,
17	org.apache.axis.client,	15	org.apache.axis.client,
18	org.apache.axis.client.async,	16	org.apache.axis.client.async,
Lines 67-75 Link Here
67	org.apache.axis.wsdl.gen,	65	org.apache.axis.wsdl.gen,
68	org.apache.axis.wsdl.symbolTable,	66	org.apache.axis.wsdl.symbolTable,
69	org.apache.axis.wsdl.toJava,	67	org.apache.axis.wsdl.toJava,
		68	org.eclipse.mylyn.xplanner.wsdl.db,
		69	org.eclipse.mylyn.xplanner.wsdl.soap.domain,
		70	org.eclipse.mylyn.xplanner.core,
		71	org.eclipse.mylyn.xplanner.core.service,
		72	org.eclipse.mylyn.xplanner.core.service.exceptions,
70	org.xplanner.soap,	73	org.xplanner.soap,
71	org.xplanner.soap.XPlanner	74	org.xplanner.soap.XPlanner
72	Bundle-ClassPath: plugin.jar,	75	Bundle-ClassPath: .,
73	lib/axis.jar,	76	lib/axis.jar,
74	lib/commons-codec-1.3.jar,	77	lib/commons-codec-1.3.jar,
75	lib/commons-discovery-0.2.jar,	78	lib/commons-discovery-0.2.jar,




/*******************************************************************************
 * Copyright (c) 2007 - 2007 CodeGear and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.core;

/**
 * @author Ravi Kumar
 * @author Helen Bershadskaya
 */
import org.eclipse.mylyn.xplanner.core.service.XPlannerClient;


public interface XPlannerClientListener {

	public abstract void clientAdded(XPlannerClient client);
	
	public abstract void clientRemoved(XPlannerClient client);
}




/*******************************************************************************
 * Copyright (c) 2007 - 2007 CodeGear and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.core.service;

import java.net.Proxy;

import org.xplanner.soap.TaskData;
import org.xplanner.soap.UserStoryData;

/**
 * TODO this class needs to be populated using the SOAP or JAX-RPC interfaces.
 * Once this is done it should be cached on disk somewhere so we don't have to
 * query the server each time a client loads.  It should be possible to reload
 * and restore the cache information.  We also need to store the images in a
 * cache somewhere since we will use them a lot.
 * 
 * TODO explain this is an attempt to enrich the XPlanner service layer
 * 
 * TODO move all of the assignee stuff somewhere else.
 * 
 * @author Ravi Kumar 
 * @author Helen Bershadskaya 
 */

public abstract class XPlannerClient extends XPlannerService {
	public static final int NO_LIMIT = -1;
	
	
	/**
	 * Assign to the default user
	 */
	public static final int ASSIGNEE_DEFAULT = 1;
	
	/**
	 * Leave the assignee field as is (this does not apply when performing an assign to action)
	 */
	public static final int ASSIGNEE_CURRENT = 2;
	
	/**
	 * Assign to nobody
	 */
	public static final int ASSIGNEE_NONE = 3;
	
	/**
	 * Assign to a specific user.  To get the name of the assignee call {@link #getAssignee()}
	 */
	public static final int ASSIGNEE_USER = 4;
	
	/**
	 * Assign to the current user
	 */
	public static final int ASSIGNEE_SELF = 5;
	
	public abstract boolean hasSlowConnection();
	public abstract String getName();
	public abstract String getBaseURL();
	public abstract String getCurrentUserName();
	public abstract String getCurrentUserPassword();
	public abstract int getCurrentPersonId();
	public abstract TaskData[] getUserStoryTasksForPerson(int personId, int userStoryId);
	public abstract UserStoryData[] getIterationUserStoriesForTracker(int trackerId, int iterationId);
	public abstract UserStoryData[] getUserStoriesForProject(int projectId);
	public abstract UserStoryData[] getUserStoriesForProject(int projectId, int trackerId);
	public abstract TaskData[] getTasksForProject(int projectId);
	public abstract TaskData[] getTasksForProject(int projectId, int personId);
	public abstract TaskData[] getTasksForIteration(int iterationId);
	public abstract TaskData[] getTasksForIteration(int iterationId, int personId);
	public abstract boolean useCompression();
	public abstract Proxy getProxy();
	public abstract String getHttpUser();
	public abstract String getHttpPassword();
	
//	/**
//	 * Force a login to the remote repository.
//	 * @deprecated There is no need to call this method as all services should automatically
//	 * login when the session is about to expire.  If you need to check if the credentials
//	 * are valid, call {@link org.eclipse.mylyn.xplanner.core.ClientManager#testConnection(String, String, String)}
//	 */
//	public abstract void login();
//	
//	/**
//	 * Force the current session to be closed.  This method should only be called during
//	 * application shutdown and then only out of courtesy to the server.  XPlanner will
//	 * automatically expire sessions after a set amount of time.
//	 */
//	public abstract void logout();
//	
}




package org.xplanner.soap.XPlanner;

import java.net.Proxy;
import java.net.URL;

import org.apache.axis.MessageContext;
import org.apache.axis.transport.http.CommonsHTTPSender;
import org.apache.commons.httpclient.HostConfiguration;
import org.apache.commons.httpclient.HttpClient;
import org.eclipse.mylyn.web.core.WebClientUtil;

public class XPlannerHttpSender extends CommonsHTTPSender {
	
	public static final String PROXY = "org.eclipse.mylyn.xplanner.proxy"; //$NON-NLS-1$
	public static final String HTTP_USER = "org.eclipse.mylyn.xplanner.httpUser"; //$NON-NLS-1$
	public static final String HTTP_PASSWORD = "org.eclipse.mylyn.xplanner.httpPassword"; //$NON-NLS-1$
	
	@Override
	protected HostConfiguration getHostConfiguration(HttpClient client, MessageContext context, URL url) {
		Proxy proxy = (Proxy) context.getProperty(PROXY);
		String httpUser = (String) context.getProperty(HTTP_USER);
		String httpPassword = (String) context.getProperty(HTTP_PASSWORD);
		WebClientUtil.setupHttpClient(client, proxy, url.toString(), httpUser, httpPassword);
		return client.getHostConfiguration();
	}
}




<?xml version="1.0" encoding="UTF-8"?>
<deployment name="defaultClientConfig"
            xmlns="http://xml.apache.org/axis/wsdd/"
            xmlns:java="http://xml.apache.org/axis/wsdd/providers/java">
<!--
  <transport name="http" pivot="java:org.apache.axis.transport.http.CommonsHTTPSender" />
  <transport name="https" pivot="java:org.apache.axis.transport.http.CommonsHTTPSender"/>
-->
  <transport name="http" pivot="java:org.xplanner.soap.XPlannerHttpSender" />
  <transport name="https" pivot="java:org.xplanner.soap.XPlannerHttpSender"/>

  <transport name="local" pivot="java:org.apache.axis.transport.local.LocalSender"/>

</deployment>




/*******************************************************************************
 * Copyright (c) 2007 - 2007 CodeGear and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.core;

/**
 * @author Ravi Kumar
 * @author Helen Bershadskaya
 */
import java.io.*;
import java.net.Proxy;
import java.net.URL;
import java.rmi.RemoteException;
import java.util.*;

import org.apache.axis.AxisFault;
import org.eclipse.mylyn.xplanner.core.service.CachedXPlannerClient;
import org.eclipse.mylyn.xplanner.core.service.XPlannerClient;
import org.eclipse.mylyn.xplanner.core.service.exceptions.AuthenticationException;
import org.eclipse.mylyn.xplanner.core.service.exceptions.ServiceUnavailableException;
import org.xml.sax.SAXException;


/**
 * @author Helen Bershadskaya 
 * @author Ravi Kumar 
 */
public class XPlannerClientManager {

	private final File cacheLocation;

	private Map<String, XPlannerClient> clientByName = new HashMap<String, XPlannerClient>();

	// TODO Use a decent listener list
	private List<XPlannerClientListener> listeners = new ArrayList<XPlannerClientListener>();
	
	public XPlannerClientManager(File cacheLocation) {
		this.cacheLocation = cacheLocation;
	}
	
	protected void start() {
		// On first load the cache may not exist
		cacheLocation.mkdirs();
		
		File[] clients = this.cacheLocation.listFiles();
		for (int i = 0; i < clients.length; i++) {
			File clientCache = clients[i];
			File clientFile = new File(clientCache, "server.ser"); //$NON-NLS-1$
			
			ObjectInputStream ois = null;
			try {
				ois = new ObjectInputStream(new BufferedInputStream(new FileInputStream(clientFile)));
				XPlannerClient client = (XPlannerClient) ois.readObject();
				// TODO reconnect the services depending on user preferences
				
				clientByName.put(clientCache.getName(), client);
				ois.close();
			} catch (IOException e) {
				e.printStackTrace();
			} catch (ClassNotFoundException e) {
				e.printStackTrace();
			} finally {
				if (ois != null) {
					try {
						ois.close();
					} catch (IOException e) {
					}
				}
			}
		}
	}
	
	protected void stop() {
		for (Iterator<XPlannerClient> iClients = clientByName.values().iterator(); iClients.hasNext();) {
			XPlannerClient client = iClients.next();
			
			ObjectOutputStream oos = null;
			try {
				File cacheDir = new File(cacheLocation, client.getName());
				cacheDir.mkdirs();
				
				oos = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(new File(cacheDir, "server.ser")))); //$NON-NLS-1$
				oos.writeObject(client);
			} catch (IOException e) {
				e.printStackTrace();
			} finally {
				if (oos != null) {
					try {
						oos.close();
					} catch (IOException e) {
					}
				}
			}
		}
	}
	
	/**
	 * Tests the connection to a client.  If the URL is invalid ot the username
	 * and password are invalid this method will return with a exceptions carrying
	 * the failure reason. 
	 * @param baseUrl Base URL of the XPlanner installation
	 * @param username username to connect with
	 * @param password Password to connect with
	 * @return Short string describing the client information
	 * @throws AuthenticationException URL was valid but username and password were incorrect
	 * @throws ServiceUnavailableException URL was not valid
	 */
	public String testConnection(String baseUrl, String username, String password,
			Proxy proxy, String httpUser, String httpPassword) throws AuthenticationException, ServiceUnavailableException {
		if (baseUrl == null || baseUrl.length() == 0) {
			throw new AuthenticationException(Messages.ClientManager_CLIENT_URL_CANNOT_BE_EMPTY);
		}
		
		XPlannerClient client = null;
		
		try {
			new URL(baseUrl).openConnection(); // tests url validity

			client = createClient("Connection Test", baseUrl, false, username, password, //$NON-NLS-1$
				false, proxy, httpUser, httpPassword);
			
			client.getTask(-1);
		}
		catch (RemoteException re) {
			if (re instanceof AxisFault) {
				String message = re.getMessage().trim();
				if (message.startsWith("(401)")) { //$NON-NLS-1$
					message = Messages.ClientManager_INVALID_USERNAME_PASSWORD;
				}
				else if (re.getCause() instanceof SAXException) {
					message = ""; //$NON-NLS-1$
				}
				else {
					if (re.getCause() != null) {
						message = re.getCause().getMessage();
					}
					message = message.startsWith(";") ? message.substring(1).trim() : message; //$NON-NLS-1$
				}
				throw new AuthenticationException(message);
			}
			else {
				throw new ServiceUnavailableException(re.getMessage());
			}
		}
		catch (Exception e) {
			throw new ServiceUnavailableException(e.getMessage());
		}
		finally {
			if (client != null) {
				removeClient(client);
			}
		}
		
		return "XPlanner"; //$NON-NLS-1$
	}
	
	public XPlannerClient getClient(String name) {
		return (XPlannerClient) clientByName.get(name);
	}
	
	public XPlannerClient[] getAllClients() {
		return (XPlannerClient[]) clientByName.values().toArray(new XPlannerClient[clientByName.size()]);
	}
	
	public XPlannerClient createClient(String name, String baseUrl, boolean hasSlowConnection, 
			String username, String password, boolean useCompression, Proxy proxy, String httpUser, String httpPassword) {
		if (baseUrl.charAt(baseUrl.length() - 1) == '/') {
			baseUrl = baseUrl.substring(0, baseUrl.length() - 1);
		}
		
		XPlannerClient client = new CachedXPlannerClient(name, baseUrl, hasSlowConnection, username, password, useCompression,
				proxy, httpUser, httpPassword);
		return client;
	}
	
	public void addClient(XPlannerClient client) {
		if (clientByName.containsKey(client.getName())) {
//			TODO: add this check back once the listeners for client property change are hooked up
//			 Also handle the case when serviceDelegate in the cachedServer is null
//			throw new RuntimeException("A server with that name already exists");
			removeClient(client);
		}
		clientByName.put(client.getName(), client);
		fireClientAddded(client);
	}
	
	public void removeClient(XPlannerClient client) {
		clientByName.remove(client.getName());
		
		File clientCache = new File(this.cacheLocation, client.getName());
		if (clientCache.exists()) {
			recursiveDelete(clientCache);
		}
		fireClientRemoved(client);
	}

	/**
	 * TODO need to make this a bit smarter.  Perhaps have an object to hold connectino info
	 * @param name
	 * @param baseURL
	 * @param username
	 * @param password
	 */
	public void updateClientDetails(String name, String baseURL, boolean hasSlowConnection, String username, String password) {
		CachedXPlannerClient client = (CachedXPlannerClient) clientByName.get(name);
		// TODO we should really have a modify event

		fireClientRemoved(client);
		
		// TODO need to flush the client cache since we are possibly a different person
		client.setBaseURL(baseURL);
		client.setSlowConnection(hasSlowConnection);
		client.setCurrentUserName(username);
		client.setCurrentPassword(password);
		
		fireClientAddded(client);
	}
	
	public void addClientListener(XPlannerClientListener listener) {
		listeners.add(listener);
	}
	
	public void removeClientListener(XPlannerClientListener listener) {
		listeners.remove(listener);
	}
	
	private void fireClientRemoved(XPlannerClient client) {
		for (Iterator<XPlannerClientListener> iListeners = listeners.iterator(); iListeners.hasNext();) {
			XPlannerClientListener listener = (XPlannerClientListener)iListeners.next();
			listener.clientRemoved(client);
		}
	}
	
	private void fireClientAddded(XPlannerClient client) {
		for (Iterator<XPlannerClientListener> iListeners = listeners.iterator(); iListeners.hasNext();) {
			XPlannerClientListener listener = (XPlannerClientListener)iListeners.next();
			listener.clientAdded(client);
		}
	}
	
	private void recursiveDelete(File baseFile) {
		if (baseFile.isFile()) {
			baseFile.delete();
		} else {
			File[] children = baseFile.listFiles();
			for (int i = 0; i < children.length; i++) {
				File file = children[i];
				recursiveDelete(file);
			}
			baseFile.delete();
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2007 - 2007 CodeGear and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.core.service;

import java.io.Serializable;
import java.net.Proxy;
import java.rmi.RemoteException;
import java.util.*;

import org.eclipse.mylyn.xplanner.wsdl.db.QueryException;
import org.xplanner.soap.*;


/**
 * XPlanner client implementation that caches information that is unlikely to change
 * during the session.  This client could be persisted to disk and re-loaded.
 * It has lifecycle methods to allow data in the cache to be reloaded.
 * 
 * TODO it is assumed that it will be backed by a standard XPlanner service layer 
 * 
 * @author Ravi Kumar
 * @author Helen Bershadskaya
 */
public class CachedXPlannerClient extends XPlannerClient 
	implements Serializable {
	
  public static final int INVALID_ID = -1;
  
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	private String name;
	private String baseURL;
	private boolean hasSlowConnection;
	private String userName;
	private String password;
	private final boolean useCompression;
	private final transient Proxy proxy;
	private final String httpUser;
	private final String httpPassword;
	private transient XPlannerService serviceDelegate;

	public CachedXPlannerClient(String name, String baseURL, boolean hasSlowConnection, String userName, String password,
			boolean useCompression, Proxy proxy, String httpUser, String httpPassword) {
		this.name = name;
		this.baseURL = baseURL;
		this.hasSlowConnection = hasSlowConnection;
		this.userName = userName;
		this.password = password;
		this.useCompression = useCompression;
		this.proxy = proxy;
		this.httpUser = httpUser;
		this.httpPassword = httpPassword;

		
		this.serviceDelegate = ServiceManager.getXPlannerService(this);
		serviceDelegate.login(userName, password);
	}

	public String getBaseURL() {
		return baseURL;
	}

	public String getCurrentUserName() {
		return userName;
	}

	public String getCurrentUserPassword() {
		return password;
	}

	public int getMaximumNumberOfMatches() {
		return 0;
	}

	public String getName() {
		return name;
	}

	public boolean hasSlowConnection() {
		return hasSlowConnection;
	}


	public void setSlowConnection(boolean hasSlowConnection) {
		this.hasSlowConnection = hasSlowConnection;
	}

	public void setBaseURL(String baseURL) {
		this.baseURL = baseURL;
	}

	public void setCurrentPassword(String password) {
		this.password = password;
	}

	public void setCurrentUserName(String userName) {
		this.userName = userName;
	}
	
	public String login(String username, String password) {
		return serviceDelegate.login(username, password);		
	}

	public boolean logout() {
		boolean ok = true;
	
		//TODO -- shouldn't have a null service delegate, but definitely get into this condition if "finish"
		// repository definition with an invalid client
	
		if (serviceDelegate != null) {
			ok = serviceDelegate.logout();
		}
		
		return ok;
	}

	public IterationData addIteration(IterationData iteration) throws RemoteException {
		return serviceDelegate.addIteration(iteration);
	}

	public NoteData addNote(NoteData note) throws RemoteException {
		return serviceDelegate.addNote(note);
	}

	public PersonData addPerson(PersonData object) throws RemoteException {
		return serviceDelegate.addPerson(object);
	}

	public ProjectData addProject(ProjectData project) throws RemoteException {
		return serviceDelegate.addProject(project);
	}

	public TaskData addTask(TaskData task) throws RemoteException {
		return serviceDelegate.addTask(task);
	}

	public TimeEntryData addTimeEntry(TimeEntryData timeEntry) throws RemoteException {
		return serviceDelegate.addTimeEntry(timeEntry);
	}

	public UserStoryData addUserStory(UserStoryData story) throws RemoteException {
		return serviceDelegate.addUserStory(story);
	}

	public void deleteAttribute(int objectId, String key) throws RemoteException {
		serviceDelegate.deleteAttribute(objectId, key);
	}

	public boolean equals(Object obj) {
		return this == obj || serviceDelegate.equals(obj) || 
		 (obj instanceof CachedXPlannerClient && ((CachedXPlannerClient)obj).serviceDelegate.equals(serviceDelegate));
	}

	public String getAttribute(int objectId, String key) throws RemoteException {
		return serviceDelegate.getAttribute(objectId, key);
	}

	@SuppressWarnings("unchecked")
	public HashMap getAttributes(int objectId) throws RemoteException {
		return serviceDelegate.getAttributes(objectId);
	}

	@SuppressWarnings("unchecked")
	public HashMap getAttributesWithPrefix(int objectId, String prefix) throws RemoteException {
		return serviceDelegate.getAttributesWithPrefix(objectId, prefix);
	}

	public IterationData getCurrentIteration(int projectId) throws RemoteException {
		return serviceDelegate.getCurrentIteration(projectId);
	}

	public TaskData[] getCurrentTasksForPerson(int personId) throws RemoteException, QueryException {
		return serviceDelegate.getCurrentTasksForPerson(personId);
	}

	public IterationData getIteration(int id) throws RemoteException {
		return serviceDelegate.getIteration(id);
	}

	public IterationData[] getIterations(int projectId) throws RemoteException {
		return serviceDelegate.getIterations(projectId);
	}

	public NoteData getNote(int id) throws RemoteException {
		return serviceDelegate.getNote(id);
	}

	public NoteData[] getNotesForObject(int attachedToId) throws RemoteException {
		return serviceDelegate.getNotesForObject(attachedToId);
	}

	public PersonData[] getPeople() throws RemoteException {
		return serviceDelegate.getPeople();
	}

	public PersonData getPerson(int id) throws RemoteException {
		return serviceDelegate.getPerson(id);
	}

	public TaskData[] getPlannedTasksForPerson(int personId) throws RemoteException, QueryException {
		return serviceDelegate.getPlannedTasksForPerson(personId);
	}

	public ProjectData getProject(int id) throws RemoteException {
		return serviceDelegate.getProject(id);
	}

	public ProjectData[] getProjects() throws RemoteException {
		return serviceDelegate.getProjects();
	}

	public TaskData getTask(int id) throws RemoteException {
		if (serviceDelegate == null) {
			System.out.println(" why is serivce Delegate null???"); //$NON-NLS-1$
		}
		return serviceDelegate.getTask(id);
	}

	public TaskData[] getTasks(int containerId) throws RemoteException {
		return serviceDelegate.getTasks(containerId);
	}

	public TimeEntryData[] getTimeEntries(int containerId) throws RemoteException {
		return serviceDelegate.getTimeEntries(containerId);
	}

	public TimeEntryData getTimeEntry(int id) throws RemoteException {
		return serviceDelegate.getTimeEntry(id);
	}

	public UserStoryData[] getUserStories(int containerId) throws RemoteException {
		return serviceDelegate.getUserStories(containerId);
	}

	public UserStoryData getUserStory(int id) throws RemoteException {
		return serviceDelegate.getUserStory(id);
	}

	public int hashCode() {
		return serviceDelegate.hashCode();
	}

	public void removeIteration(int id) throws RemoteException {
		serviceDelegate.removeIteration(id);
	}

	public void removeNote(int id) throws RemoteException {
		serviceDelegate.removeNote(id);
	}

	public void removePerson(int id) throws RemoteException {
		serviceDelegate.removePerson(id);
	}

	public void removeProject(int id) throws RemoteException {
		serviceDelegate.removeProject(id);
	}

	public void removeTask(int id) throws RemoteException {
		serviceDelegate.removeTask(id);
	}

	public void removeTimeEntry(int id) throws RemoteException {
		serviceDelegate.removeTimeEntry(id);
	}

	public void removeUserStory(int id) throws RemoteException {
		serviceDelegate.removeUserStory(id);
	}

	public void setAttribute(int objectId, String key, String value) throws RemoteException {
		serviceDelegate.setAttribute(objectId, key, value);
	}

	public void update(IterationData object) throws RemoteException {
		serviceDelegate.update(object);
	}

	public void update(NoteData note) throws RemoteException {
		serviceDelegate.update(note);
	}

	public void update(PersonData object) throws RemoteException {
		serviceDelegate.update(object);
	}

	public void update(ProjectData object) throws RemoteException {
		serviceDelegate.update(object);
	}

	public void update(TaskData object) throws RemoteException {
		serviceDelegate.update(object);
	}

	public void update(TimeEntryData object) throws RemoteException {
		serviceDelegate.update(object);
	}

	public void update(UserStoryData object) throws RemoteException {
		serviceDelegate.update(object);
	}

	public TaskData[] getUserStoryTasksForPerson(int personId, int userStoryId) {
		if (personId < 0 || userStoryId < 0) {
			return new TaskData[0];
		}
		
		List<TaskData> userStoryTasksForPerson = new ArrayList<TaskData>();
		try {
			TaskData[] iterationTasks = getTasks(userStoryId);
			// get all tasks for specified user storyserv
			for (int i = 0; i < iterationTasks.length; i++) {
				TaskData taskData = iterationTasks[i];
				if (taskData.getAcceptorId() == personId) {
					userStoryTasksForPerson.add(taskData);
				}
			}
			
		}
		catch (RemoteException e) {
			e.printStackTrace();
		}
		
		return userStoryTasksForPerson.toArray(new TaskData[userStoryTasksForPerson.size()]);
	}
	
	public UserStoryData[] getIterationUserStoriesForTracker(int trackerId, int iterationId) {
		if (trackerId < 0 || iterationId < 0) {
			return new UserStoryData[0];
		}

		List<UserStoryData> userStoriesForTracker = new ArrayList<UserStoryData>();
		UserStoryData[] userStories;
		try {
			userStories = getUserStories(iterationId);
			// get all tasks for specified user story
			for (int i = 0; i < userStories.length; i++) {
				UserStoryData userStory = userStories[i];
				if (userStory.getTrackerId() == trackerId) {
					userStoriesForTracker.add(userStory);
				}
			}
		}
		catch (RemoteException e) {
			e.printStackTrace();
		}
		
		return userStoriesForTracker.toArray(new UserStoryData[userStoriesForTracker.size()]);
	}

	public int getCurrentPersonId() {
		int currentPersonId = INVALID_ID;
		
	  String userName = getCurrentUserName();
	  if (userName != null) {
	  	try {
				PersonData[] people = getPeople();
				if (people != null) {
					for (int i = 0; i < people.length && currentPersonId == INVALID_ID; i++) {
						PersonData person = people[i];
						if (person.getUserId().equals(userName)) {
							currentPersonId = person.getId();
						}
					}
				}
			}
			catch (RemoteException e) {
				e.printStackTrace();
			}
	  }
	  
	  return currentPersonId;
	}
	
	public UserStoryData[] getUserStoriesForProject(int projectId) {
		if (projectId == INVALID_ID) {
			return new UserStoryData[0];
		}
		
		ArrayList<UserStoryData> projectUserStories = new ArrayList<UserStoryData>();
		try {
			IterationData[] projectIterations = getIterations(projectId);
			for (IterationData iteration : projectIterations) {
				UserStoryData[] iterationUserStories = getUserStories(iteration.getId());
				if (iterationUserStories.length > 0) {
					projectUserStories.addAll(Arrays.asList(iterationUserStories));
				}
			}
		}
		catch (RemoteException e) {
			e.printStackTrace();
		}
		
		return (UserStoryData[]) projectUserStories.toArray(new UserStoryData[projectUserStories.size()]);
	}
	
	public UserStoryData[] getUserStoriesForProject(int projectId, int trackerId) {
		if (projectId == INVALID_ID) {
			return new UserStoryData[0];
		}
		
		ArrayList<UserStoryData> projectTrackerUserStories = new ArrayList<UserStoryData>();
		UserStoryData[] projectUserStories = getUserStoriesForProject(projectId);
		for (UserStoryData userStory : projectUserStories) {
			if (userStory.getTrackerId() == trackerId) {
				projectTrackerUserStories.add(userStory);
			}
		}
		
		return (UserStoryData[]) projectTrackerUserStories.toArray(new UserStoryData[projectTrackerUserStories.size()]);

	}
	
	public TaskData[] getTasksForProject(int projectId) {
		if (projectId == -1) {
			return new TaskData[0];
		}
		
		ArrayList<TaskData> projectTasks = new ArrayList<TaskData>();
		try {
			UserStoryData[] userStories = getUserStoriesForProject(projectId);
			for (UserStoryData userStory : userStories) {
				TaskData[] userStoryTasks = getTasks(userStory.getId());
				if (userStoryTasks.length > 0) {
					projectTasks.addAll(Arrays.asList(userStoryTasks));
				}
			}
		}
		catch (RemoteException e) {
			e.printStackTrace();
		}
		
		return (TaskData[]) projectTasks.toArray(new TaskData[projectTasks.size()]);
	}
	
	public TaskData[] getTasksForProject(int projectId, int personId) {
		if (projectId == INVALID_ID || personId == INVALID_ID) {
			return new TaskData[0];
		}
		
		ArrayList<TaskData> projectPersonTasks = new ArrayList<TaskData>();
		TaskData[] allProjectTasks = getTasksForProject(projectId);
		for (TaskData task : allProjectTasks) {
			if (task.getAcceptorId() == personId) {
				projectPersonTasks.add(task);
			}
		}
		
		return (TaskData[]) projectPersonTasks.toArray(new TaskData[projectPersonTasks.size()]);
	}
	
	public TaskData[] getTasksForIteration(int iterationId) {
		if (iterationId == INVALID_ID) {
			return new TaskData[0];
		}
		
		ArrayList<TaskData> iterationTasks = new ArrayList<TaskData>();
		try {
			UserStoryData[] userStories = getUserStories(iterationId);
			for (UserStoryData userStory : userStories) {
				TaskData[] userStoryTasks = getTasks(userStory.getId());
				if (userStoryTasks.length > 0) {
					iterationTasks.addAll(Arrays.asList(userStoryTasks));
				}
			}
		}
		catch (RemoteException e) {
			e.printStackTrace();
		}
		
		return (TaskData[]) iterationTasks.toArray(new TaskData[iterationTasks.size()]);
	}
	
	public TaskData[] getTasksForIteration(int iterationId, int personId) {
		if (iterationId == INVALID_ID || personId == INVALID_ID) {
			return new TaskData[0];
		}
		
		ArrayList<TaskData> iterationPersonTasks = new ArrayList<TaskData>();
		TaskData[] allIterationTasks = getTasksForIteration(iterationId);
		for (TaskData task : allIterationTasks) {
			if (task.getAcceptorId() == personId) {
				iterationPersonTasks.add(task);
			}
		}
		
		return (TaskData[]) iterationPersonTasks.toArray(new TaskData[iterationPersonTasks.size()]);
	}
	

	public String getHttpPassword() {
		return httpPassword;
	}

	public String getHttpUser() {
		return httpUser;
	}

	public Proxy getProxy() {
		return proxy;
	}

	public boolean useCompression() {
		return useCompression;
	}

}




 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.ui;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.*;

import org.eclipse.mylyn.tasks.core.AbstractAttributeFactory;
import org.eclipse.mylyn.tasks.core.RepositoryTaskAttribute;


/**

	public static final String ATTRIBUTE_USER_STORY_NAME = "userStoryName"; //$NON-NLS-1$
	public static final String ATTRIBUTE_TASK_COMPLETED = "completed"; //$NON-NLS-1$

	public static final String ATTRIBUTE_SUBTASK_IDS = "attribute.xplanner.subtask_ids";
	public static final String ATTRIBUTE_SUBTASK_KEYS = "attribute.xplanner.subtask_keys";
	
	private static Map<String, Attribute> commonKeyToAttributesMap = new HashMap<String, Attribute>();

	public enum Attribute {
		DESCRIPTION("Description:", RepositoryTaskAttribute.DESCRIPTION, false), //$NON-NLS-1$
		OWNER("Acceptor:", RepositoryTaskAttribute.USER_ASSIGNED, true), //$NON-NLS-1$
		PRIORITY("Priority:", RepositoryTaskAttribute.PRIORITY, true), //$NON-NLS-1$
		STATUS("Status:", RepositoryTaskAttribute.STATUS, true), //$NON-NLS-1$
		NAME("Name:", RepositoryTaskAttribute.SUMMARY, false), //$NON-NLS-1$
		CREATED_ON("Created:", RepositoryTaskAttribute.DATE_CREATION, true),  //$NON-NLS-1$
		MODIFIED_TIME("Last Update:", RepositoryTaskAttribute.DATE_MODIFIED, true),  //$NON-NLS-1$
		SUBTASK_IDS("Subtask ids:", XPlannerAttributeFactory.ATTRIBUTE_SUBTASK_IDS, true),
		SUBTASK_KEYS("Sub-Tasks:", XPlannerAttributeFactory.ATTRIBUTE_SUBTASK_KEYS, true),

		; 
		
		private final boolean isReadOnly;
		
		private final String displayName;

		private final String commonAttributeKey;

		Attribute(String displayName, String commonAttributeKey, boolean readonly) {
			this.displayName = displayName;
			this.commonAttributeKey = commonAttributeKey;
			this.isReadOnly = readonly;
			
			commonKeyToAttributesMap.put(commonAttributeKey, this);
		}

		public String getCommonAttributeKey() {
			return commonAttributeKey;
		}

		public String getDisplayName() {
			return displayName;
		}

		public boolean isReadOnly() {
			return isReadOnly;
		}
		
		@Override
		public String toString() {
			return getDisplayName();
		}
	}


	static {
		// make sure hash maps get initialized when class is loaded
		Attribute.values();
	}

	@Override
	public String getName(String key) {
		Attribute attribute = commonKeyToAttributesMap.get(key);
		return (attribute != null) ? attribute.getDisplayName() : key;
	}

	@Override

	}

	@Override
	public boolean isHidden(String key) {
		return false;
	}

	@Override
	public boolean isReadOnly(String key) {				
		Attribute attribute = commonKeyToAttributesMap.get(key);
		return (attribute != null) ? attribute.isReadOnly() : false;
	}
	
	public Date getDateForAttributeType(String attributeKey, String dateString) {
		if(dateString == null || dateString.equals("")) { //$NON-NLS-1$




/*******************************************************************************
 * Copyright (c) 2007 - 2007 CodeGear and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylar.xplanner.ui;

import java.net.MalformedURLException;
import java.net.URL;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.mylar.core.MylarStatusHandler;
import org.eclipse.mylar.tasks.core.ITaskRepositoryListener;
import org.eclipse.mylar.tasks.core.TaskRepository;
import org.eclipse.mylar.tasks.ui.TasksUiPlugin;
import org.eclipse.mylar.xplanner.core.ServerManager;
import org.eclipse.mylar.xplanner.core.XPlannerCorePlugin;
import org.eclipse.mylar.xplanner.core.service.XPlannerServer;
import org.eclipse.mylar.xplanner.core.service.exceptions.AuthenticationException;
import org.eclipse.mylar.xplanner.core.service.exceptions.ServiceUnavailableException;

/**
 * This class acts as a layer of indirection between clients in this project and
 * the server API implemented by the XPlanner Dashboard, and also abstracts some
 * Mylar implementation details. It initializes a xPlannerServer object and serves
 * as the central location to get a reference to it.
 * 
 * @author Ravi Kumar 
 * @author Helen Bershadskaya 
 * 
 */
public class XPlannerServerFacade implements ITaskRepositoryListener {

	private ServerManager serverManager = null;

	private static XPlannerServerFacade instance = null;

	public XPlannerServerFacade() {
		TasksUiPlugin.getRepositoryManager().addListener(this);
		serverManager = XPlannerCorePlugin.getDefault().getServerManager();
	}

	/**
	 * Lazily creates server.
	 */
	public XPlannerServer getXPlannerServer(TaskRepository repository) throws CoreException {
		try {
			XPlannerRepositoryUtils.checkRepositoryValidated(repository.getUrl());
			String serverHostname = getServerHost(repository);
		XPlannerServer server = serverManager.getServer(serverHostname);
//TODO: add this check back once the listeners for server property change are hooked up
// Also handle the case when serviceDelegate in the cachedServer is null

//			if (server == null) {
				server = serverManager.createServer(serverHostname, repository.getUrl(), false,
						repository.getUserName(), repository.getPassword());
				serverManager.addServer(server);
//			}
			if (server == null) {
				throw new ServiceUnavailableException(serverHostname + " " + repository.getUrl()); //$NON-NLS-1$
			}
			return server;
		} 
		catch (CoreException ce) {
			MylarStatusHandler.log(Messages.XPlannerServerFacade_SERVER_CONNECTION_ERROR, this);
			throw ce;
		}
		catch (ServiceUnavailableException sue) {
			throw sue;
		} 
		catch (RuntimeException e) {
			MylarStatusHandler.log(Messages.XPlannerServerFacade_SERVER_CONNECTION_ERROR, this);
			throw e;
		}
	}

	public static XPlannerServerFacade getDefault() {
		if (instance == null) {
			instance = new XPlannerServerFacade();
		}
		return instance;
	}

	public void logOutFromAll() {
		try {
			XPlannerServer[] allServers = serverManager.getAllServers();
			for (int i = 0; i < allServers.length; i++) {
				allServers[i].logout();
			}
		} catch (Exception e) {
			// ignore
		}
	}

	public void repositoriesRead() {
		// ignore
	}

	public void repositoryAdded(TaskRepository repository) {
		if (repository.getKind().equals(XPlannerMylarUIPlugin.REPOSITORY_KIND)) {
			try {
				getXPlannerServer(repository);
			}
			catch (CoreException e) {
				MylarStatusHandler.log(e.getMessage(), this); 
			}
		}
	}

	public void repositoryRemoved(TaskRepository repository) {
		if (repository.getKind().equals(XPlannerMylarUIPlugin.REPOSITORY_KIND)) {
			String serverHostname = getServerHost(repository);
			XPlannerServer server = serverManager.getServer(serverHostname);
			removeServer(server);
			XPlannerRepositoryUtils.removeValidatedRepositoryUrl(repository.getUrl());
		}
	}
	
	public void repositorySettingsChanged(TaskRepository repository) {
		repositoryRemoved(repository);
		repositoryAdded(repository);
	}

	public void refreshServerSettings(TaskRepository repository) {
		String serverHostname = getServerHost(repository);
		XPlannerServer server = serverManager.getServer(serverHostname);
		if (server != null) {
			server.refreshDetails();
		}
	}
	
	
	private void removeServer(XPlannerServer server) {
		if (server != null) {
			server.logout();
			serverManager.removeServer(server);
		}
	} 

	/**
	 * Validate the server URL and user credentials
	 * @param serverUrl Location of the XPlanner Server
	 * @param user Username
	 * @param password Password
	 * @return String describing validation failure or null if the details are valid
	 */
	public void validateServerAndCredentials(String serverUrl, String user, 
		String password) throws Exception {
		
		XPlannerRepositoryUtils.removeValidatedRepositoryUrl(serverUrl);
		serverManager.testConnection(serverUrl, user, password);
		XPlannerRepositoryUtils.addValidatedRepositoryUrl(serverUrl);
	}

	private static String getServerHost(TaskRepository repository) {
		try {
			return new URL(repository.getUrl()).getHost();
		} catch (MalformedURLException ex) {
			throw new RuntimeException(Messages.XPlannerServerFacade_INVALID_URL_EXCEPTION+repository.getUrl(), ex);
		}
	}
	
	/**
	 * TODO: refactor
	 */
	public static void handleConnectionException(Exception e) {
		if (e instanceof ServiceUnavailableException) {
			MylarStatusHandler.fail(e, Messages.XPlannerServerFacade_CONNECTION_FAILURE_ERROR
					+ Messages.XPlannerServerFacade_NETWORK_CONNECTION_FAILURE,
					true);
		} 
		else if (e instanceof AuthenticationException) {
			MylarStatusHandler.fail(e, Messages.XPlannerServerFacade_AUTHENTICATION_FAILED
					+ Messages.XPlannerServerFacade_USERNAME_PASSWORD_ERROR, true);
		} 
		else if (e instanceof RuntimeException) {
			MylarStatusHandler.fail(e, Messages.XPlannerServerFacade_NO_REPOSITORY_FOUND
					+ Messages.XPlannerServerFacade_VERIFY_VALID_REPOSITORY, true);
		} 
		else {
			MylarStatusHandler.fail(e, Messages.XPlannerServerFacade_COULD_NOT_CONNECT_TO_REPOSITORY
					+ Messages.XPlannerServerFacade_CHECK_CREDENTIALS, true);
		}
	}	
}




/*******************************************************************************
 * Copyright (c) 2007 - 2007 CodeGear and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylar.xplanner.ui;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.StringTokenizer;

import org.eclipse.mylar.core.MylarStatusHandler;
import org.eclipse.mylar.internal.tasks.core.RepositoryTaskHandleUtil;
import org.eclipse.mylar.tasks.core.AbstractQueryHit;
import org.eclipse.mylar.tasks.core.AbstractRepositoryQuery;
import org.eclipse.mylar.tasks.core.AbstractTaskContainer;
import org.eclipse.mylar.tasks.core.DelegatingTaskExternalizer;
import org.eclipse.mylar.tasks.core.ITask;
import org.eclipse.mylar.tasks.core.ITaskListExternalizer;
import org.eclipse.mylar.tasks.core.TaskExternalizationException;
import org.eclipse.mylar.tasks.core.TaskList;
import org.eclipse.mylar.tasks.ui.TasksUiPlugin;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;

/**
 * @author Ravi Kumar 
 * @author Helen Bershadskaya 
 */
public class XPlannerTaskExternalizer extends DelegatingTaskExternalizer {

	private static final String TOKEN_SEPARATOR = ";"; //$NON-NLS-1$

	private static final String KEY_XPLANNER = "XPlanner"; //$NON-NLS-1$

	private static final String KEY_CUSTOM = "XPlannerCustom"; //$NON-NLS-1$

	private static final String KEY_XPLANNER_CATEGORY = "XPlannerQuery" + KEY_CATEGORY; //$NON-NLS-1$

	private static final String KEY_XPLANNER_QUERY_HIT = KEY_XPLANNER + KEY_QUERY_HIT;

	private static final String KEY_XPLANNER_QUERY = KEY_XPLANNER + KEY_QUERY;

	private static final String KEY_XPLANNER_CUSTOM = KEY_XPLANNER + KEY_CUSTOM + KEY_QUERY;

	private static final String KEY_XPLANNER_ITEM = "XPlannerItem"; //$NON-NLS-1$

	private static final String KEY_QUERY_NAME = "QueryName"; //$NON-NLS-1$

	private static final String KEY_QUERY_CONTENT_ID_TYPE = "QueryContentIdType"; //$NON-NLS-1$

	private static final String KEY_QUERY_IS_TASKS = "QueryIsTasks"; //$NON-NLS-1$

	private static final String KEY_QUERY_CONTENT_ID = "QueryConentId"; //$NON-NLS-1$

	private static final String KEY_QUERY_PERSON_ID = "QueryPersonId"; //$NON-NLS-1$

	private static final String KEY_QUERY_MY_CURRENT_TASKS = "QueryMyCurrentTasks"; //$NON-NLS-1$

	private static final String KEY_KEY = "Key"; //$NON-NLS-1$
	
	public boolean canReadQuery(Node node) {
		return node.getNodeName().equals(KEY_XPLANNER_QUERY) || node.getNodeName().equals(KEY_XPLANNER_CUSTOM);
	}

	public boolean canCreateElementFor(AbstractRepositoryQuery category) {
		return category instanceof XPlannerCustomQuery;
	}

	public boolean canCreateElementFor(ITask task) {
		return task instanceof XPlannerTask;
	}

	public AbstractRepositoryQuery readQuery(Node node, TaskList taskList) throws TaskExternalizationException {
		Element element = (Element) node;

		AbstractRepositoryQuery query = null;
		String custom = element.getAttribute(KEY_QUERY_NAME);
		if (custom != null && custom.length() > 0) {
			query = new XPlannerCustomQuery(element.getAttribute(KEY_REPOSITORY_URL), custom, TasksUiPlugin
					.getTaskListManager().getTaskList());
			initializeQuery((XPlannerCustomQuery)query, element);
		}

		return query;
	}

	public Element createTaskElement(ITask task, Document doc, Element parent) {
		Element node = super.createTaskElement(task, doc, parent);
		node.setAttribute(KEY_KEY, ((XPlannerTask) task).getKey());
		return node;
	}

	private void initializeQuery(XPlannerCustomQuery query, Element element) {
		String myCurrentTasks = element.getAttribute(KEY_QUERY_MY_CURRENT_TASKS);
		if (myCurrentTasks != null && Boolean.valueOf(myCurrentTasks)) {
			query.setMyCurrentTasks(true);
		}
		else {
			// selected content type
			String contentIdType = element.getAttribute(KEY_QUERY_CONTENT_ID_TYPE);
			if (contentIdType != null) {
				query.setContentIdType((XPlannerCustomQuery.ContentIdType.valueOf(contentIdType)));
			}

			// use tasks?
			String useTasks = element.getAttribute(KEY_QUERY_IS_TASKS);
			if (useTasks != null) {
			  query.setUseTasks(Boolean.valueOf(useTasks));
			}  
			
			// use all?
			String personId = element.getAttribute(KEY_QUERY_PERSON_ID);
			if (personId != null) {
			  query.setPersonId(Integer.valueOf(personId));
			}  
			
			// content id
			String contentIds = element.getAttribute(KEY_QUERY_CONTENT_ID);
			if (contentIds != null) {
				query.setContentIds(decodeIds(contentIds));
			}
		}	
	}
	
	private String encodeIds(List<Integer> contentIds) {
		StringBuilder result = new StringBuilder();
		for (Iterator<Integer> iter = contentIds.iterator(); iter.hasNext();) {
			Integer id = iter.next();
			result.append(id);
			if (iter.hasNext()) {
				result.append(TOKEN_SEPARATOR);
			}
		}

		return result.toString();
	}

	private List<Integer> decodeIds(String encoded) {
		if (encoded == null) {
			return XPlannerCustomQuery.INVALID_IDS;
		}
		
		StringTokenizer tokens = new StringTokenizer(encoded, TOKEN_SEPARATOR);
		ArrayList<Integer> ids = new ArrayList<Integer>();
		while (tokens.hasMoreTokens()) {
			ids.add(Integer.valueOf(tokens.nextToken()));
		}
		
		return ids;
	}

	
	public Element createQueryElement(AbstractRepositoryQuery query, Document doc, Element parent) {
		String queryTagName = getQueryTagNameForElement(query);
		Element node = doc.createElement(queryTagName);

		node.setAttribute(KEY_NAME, query.getSummary());
		node.setAttribute(KEY_QUERY_STRING, query.getUrl());
		node.setAttribute(KEY_REPOSITORY_URL, query.getRepositoryUrl());

		XPlannerCustomQuery xplannerCustomQuery = (XPlannerCustomQuery) query;
		
		// name
		String queryName = xplannerCustomQuery.getQueryName();
		node.setAttribute(KEY_QUERY_NAME, queryName);
		
		boolean isMyCurrentTasks = xplannerCustomQuery.isMyCurrentTasks();
		if (isMyCurrentTasks) {
			// show only my current tasks
			node.setAttribute(KEY_QUERY_MY_CURRENT_TASKS, Boolean.toString(true));
		}
		else {
			// don't show only my current tasks
			node.setAttribute(KEY_QUERY_MY_CURRENT_TASKS, Boolean.toString(false));
			
			// selected content type
			String contentIdType = xplannerCustomQuery.getContentIdType().name();
			node.setAttribute(KEY_QUERY_CONTENT_ID_TYPE, contentIdType);

			// is tasks
			boolean isUseTasks = xplannerCustomQuery.isUseTasks();
			node.setAttribute(KEY_QUERY_IS_TASKS, Boolean.toString(isUseTasks));
			
			// content id
			List<Integer> contentIds = xplannerCustomQuery.getContentIds();
			node.setAttribute(KEY_QUERY_CONTENT_ID, encodeIds(contentIds));
			
			// person id
			int personId = xplannerCustomQuery.getPersonId();
			node.setAttribute(KEY_QUERY_PERSON_ID, Integer.toString(personId));
		}
		
		for (AbstractQueryHit hit : query.getHits()) {
				try {
					Element element = null;
					for (ITaskListExternalizer externalizer : super.getDelegateExternalizers()) {
						if (externalizer.canCreateElementFor(hit)) {
							element = externalizer.createQueryHitElement(hit, doc, node);
						}
					}
					if (element == null) {
						createQueryHitElement(hit, doc, node);
					}	
				} 
				catch (Exception e) {
					MylarStatusHandler.log(e, e.getMessage());
				}
		}
		parent.appendChild(node);
		return node;
	}

	@Override
	public String getTaskTagName() {
		return KEY_XPLANNER_ITEM;
	}

	@Override
	public ITask createTask(String repositoryUrl, String taskId, String summary, Element element, TaskList taskList, AbstractTaskContainer category, ITask parent)
			throws TaskExternalizationException {

		String key;
		XPlannerTask task = new XPlannerTask(repositoryUrl, taskId, summary, false);
		if (element.hasAttribute(KEY_KEY)) {
			key = element.getAttribute(KEY_KEY);
			task.setKey(key);
		} 
		else {
			// ignore if key not found
		}
		return task;
	}

	public boolean canReadQueryHit(Node node) {
		return node.getNodeName().equals(getQueryHitTagName());
	}

	@Override
	public AbstractQueryHit createQueryHit(String repositoryUrl, String taskId, String summary, Element element, TaskList taskList, AbstractRepositoryQuery query)
		throws TaskExternalizationException {

		String handle;
		if (element.hasAttribute(KEY_HANDLE)) {
			handle = element.getAttribute(KEY_HANDLE);
		} 
		else {
			throw new TaskExternalizationException(Messages.XPlannerTaskExternalizer_HANDLE_NOT_STORED_EXCEPTION);
		}

		XPlannerQueryHit hit = null;		
		ITask correspondingTask = taskList.getTask(handle);
		if (correspondingTask instanceof XPlannerTask) {
			String id = RepositoryTaskHandleUtil.getTaskId(handle);
			hit = new XPlannerQueryHit(taskList, 
				correspondingTask.getSummary(), correspondingTask.getPriority(),
				query.getRepositoryUrl(), id, (XPlannerTask)correspondingTask);
			hit.setHandleIdentifier(handle);
		}
		
		return hit;
	}

	public String getQueryTagNameForElement(AbstractRepositoryQuery query) {
		if (query instanceof XPlannerCustomQuery) {
			return KEY_XPLANNER_CUSTOM;
		}
		return ""; //$NON-NLS-1$
	}

	@Override
	public String getCategoryTagName() {
		return KEY_XPLANNER_CATEGORY;
	}

	@Override
	public String getQueryHitTagName() {
		return KEY_XPLANNER_QUERY_HIT;
	}

}




 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.ui;

import java.io.IOException;
import java.net.MalformedURLException;
import java.net.Proxy;
import java.rmi.RemoteException;
import java.security.GeneralSecurityException;
import java.text.MessageFormat;


import javax.security.auth.login.LoginException;

import org.eclipse.core.runtime.*;
import org.eclipse.mylyn.internal.tasks.core.RepositoryTaskHandleUtil;
import org.eclipse.mylyn.tasks.core.*;
import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
import org.eclipse.mylyn.xplanner.core.XPlannerCorePlugin;
import org.eclipse.mylyn.xplanner.core.service.XPlannerClient;
import org.xplanner.soap.*;
import org.eclipse.mylar.tasks.ui.TasksUiPlugin;
import org.eclipse.mylar.xplanner.core.XPlannerCorePlugin;
import org.eclipse.mylar.xplanner.core.service.XPlannerServer;
import org.xplanner.soap.IterationData;
import org.xplanner.soap.PersonData;
import org.xplanner.soap.ProjectData;
import org.xplanner.soap.TaskData;
import org.xplanner.soap.UserStoryData;

/**
 * @author Ravi Kumar

		
	}
	
	public static RepositoryTaskData createRepositoryTaskData(TaskRepository repository, XPlannerTask xplannerTask, XPlannerClient client) throws CoreException {
		RepositoryTaskData repositoryTaskData = null;
		
		try {
			if (XPlannerTask.Kind.TASK.toString().equals(xplannerTask.getTaskKind())) {
				TaskData taskData = client.getTask(Integer.valueOf(xplannerTask.getTaskId()).intValue());
				repositoryTaskData = XPlannerRepositoryUtils.getXPlannerRepositoryTaskData(
						repository.getUrl(), taskData, RepositoryTaskHandleUtil.getTaskId(xplannerTask.getHandleIdentifier()));
				xplannerTask.setCompleted(taskData.isCompleted());
			}
			else if (XPlannerTask.Kind.USER_STORY.toString().equals(xplannerTask.getTaskKind())) {
				UserStoryData userStory = client.getUserStory(Integer.valueOf(xplannerTask.getTaskId()).intValue());
				repositoryTaskData = XPlannerRepositoryUtils.getXPlannerRepositoryTaskData(
						repository.getUrl(), userStory, RepositoryTaskHandleUtil.getTaskId(xplannerTask.getHandleIdentifier()));
				xplannerTask.setCompleted(userStory.isCompleted());
			}
		} 
		catch (final Exception e) {
			throw new CoreException(new Status(IStatus.ERROR, XPlannerMylynUIPlugin.PLUGIN_ID, 0, 
				MessageFormat.format(Messages.XPlannerRepositoryUtils_TASK_DOWNLOAD_FAILED,
					  xplannerTask.getRepositoryUrl(), TasksUiPlugin.LABEL_VIEW_REPOSITORIES), e));
		}

		return repositoryTaskData;
	}

	public static RepositoryTaskData createRepositoryTaskData(TaskRepository repository, 
			String taskId) throws CoreException {
		
		RepositoryTaskData repositoryTaskData = null;
		
		XPlannerClient client = XPlannerClientFacade.getDefault().getXPlannerClient(repository);
		
		try {
			TaskData taskData = client.getTask(Integer.valueOf(taskId).intValue());
			if (taskData != null) {
				repositoryTaskData = XPlannerRepositoryUtils.getXPlannerRepositoryTaskData(
						repository.getUrl(), taskData, taskId);
			}
			else {
				UserStoryData userStory = client.getUserStory(Integer.valueOf(taskId).intValue());
				if (userStory != null) {
					repositoryTaskData = XPlannerRepositoryUtils.getXPlannerRepositoryTaskData(
							repository.getUrl(), userStory, taskId);
				}
			}
		} 
		catch (final Exception e) {
			throw new CoreException(new Status(IStatus.ERROR, XPlannerMylynUIPlugin.PLUGIN_ID, 0, 
				MessageFormat.format(Messages.XPlannerRepositoryUtils_TASK_DOWNLOAD_FAILED,
					  repository.getUrl(), TasksUiPlugin.LABEL_VIEW_REPOSITORIES), e));
		}
		
		return repositoryTaskData;
	}

	public static RepositoryTaskData getXPlannerRepositoryTaskData(String repositoryUrl, TaskData taskData, String id) 
		throws IOException, MalformedURLException, LoginException, GeneralSecurityException, CoreException {

		RepositoryTaskData repositoryTaskData = new RepositoryTaskData(
				new XPlannerAttributeFactory(),
				XPlannerMylynUIPlugin.REPOSITORY_KIND, repositoryUrl, id, XPlannerTask.Kind.TASK.toString());
		
		setupTaskAttributes(taskData, repositoryTaskData);


		throws IOException, MalformedURLException, LoginException, GeneralSecurityException, CoreException {

		RepositoryTaskData repositoryTaskData = new RepositoryTaskData(new XPlannerAttributeFactory(),
				XPlannerMylynUIPlugin.REPOSITORY_KIND, repositoryUrl, id, XPlannerTask.Kind.USER_STORY.toString());
		setupUserStoryAttributes(userStory, repositoryTaskData);
	
		return repositoryTaskData;

		throws CoreException {
		
		TaskRepository repository = TasksUiPlugin.getRepositoryManager().getRepository(
				XPlannerMylynUIPlugin.REPOSITORY_KIND, repositoryTaskData.getRepositoryUrl());
		XPlannerClient client = XPlannerClientFacade.getDefault().getXPlannerClient(repository);

		// description
		repositoryTaskData.setAttributeValue(RepositoryTaskAttribute.DESCRIPTION, taskData.getDescription());
		
		// priority
		repositoryTaskData.setAttributeValue(RepositoryTaskAttribute.PRIORITY, 
			getPriorityFromXPlannerObject(taskData, client));
		
		// status
		repositoryTaskData.setAttributeValue(RepositoryTaskAttribute.STATUS, taskData.getDispositionName());


		// assigned to 
		repositoryTaskData.setAttributeValue(RepositoryTaskAttribute.USER_ASSIGNED, getPersonName(
			taskData.getAcceptorId(), client));
		
		// createdDate 
		Date createdDate = taskData.getCreatedDate().getTime();

		repositoryTaskData.setAttributeValue(XPlannerAttributeFactory.ATTRIBUTE_ADJUSTED_ESTIMATED_HOURS_NAME, "" + taskData.getAdjustedEstimatedHours()); //$NON-NLS-1$

		// project name
		repositoryTaskData.setAttributeValue(XPlannerAttributeFactory.ATTRIBUTE_PROJECT_NAME, getProjectName(taskData, client));

		// iteration name
		repositoryTaskData.setAttributeValue(XPlannerAttributeFactory.ATTRIBUTE_ITERATION_NAME, getIterationName(taskData, client));

		// user story name
		repositoryTaskData.setAttributeValue(XPlannerAttributeFactory.ATTRIBUTE_USER_STORY_NAME, 
				getUserStoryName(taskData, client));

		// completed
		repositoryTaskData.setAttributeValue(XPlannerAttributeFactory.ATTRIBUTE_TASK_COMPLETED, 

		throws CoreException {
		
		TaskRepository repository = TasksUiPlugin.getRepositoryManager().getRepository(
				XPlannerMylynUIPlugin.REPOSITORY_KIND, repositoryTaskData.getRepositoryUrl());
		XPlannerClient client = XPlannerClientFacade.getDefault().getXPlannerClient(repository);

		// description
		repositoryTaskData.setAttributeValue(RepositoryTaskAttribute.DESCRIPTION, userStory.getDescription());
		
		// priority
		repositoryTaskData.setAttributeValue(RepositoryTaskAttribute.PRIORITY, 
			getPriorityFromXPlannerObject(userStory, client));
		
		// summary
		repositoryTaskData.setAttributeValue(RepositoryTaskAttribute.SUMMARY, userStory.getName());

		
		// assigned to 
		repositoryTaskData.setAttributeValue(RepositoryTaskAttribute.USER_ASSIGNED, getPersonName(
				userStory.getTrackerId(), client));
		
		// createdDate -- user story doesn't have created date
		

		repositoryTaskData.setAttributeValue(XPlannerAttributeFactory.ATTRIBUTE_ADJUSTED_ESTIMATED_HOURS_NAME, "" + userStory.getAdjustedEstimatedHours()); //$NON-NLS-1$

		// project name
		repositoryTaskData.setAttributeValue(XPlannerAttributeFactory.ATTRIBUTE_PROJECT_NAME, getProjectName(userStory, client));

		// iteration name
		repositoryTaskData.setAttributeValue(XPlannerAttributeFactory.ATTRIBUTE_ITERATION_NAME, getIterationName(userStory, client));
	}
	
	public static String getProjectName(RepositoryTaskData repositoryTaskData) {

		return repositoryTaskData.getAttributeValue(XPlannerAttributeFactory.ATTRIBUTE_USER_STORY_NAME);
	}
	
	public static String getPersonName(int personId, XPlannerClient client) {
		String personName = Messages.XPlannerRepositoryUtils_NO_PERSON_NAME;

		try {
		  PersonData personData = client.getPerson(personId);
		  if (personData != null) {
		  	personName = personData.getName();
		  }

			createdDate = XPlannerAttributeFactory.DATE_FORMAT.parse(dateString);
		}
		catch (ParseException e) {
			XPlannerMylynUIPlugin.log(e.getCause(), "", false); //$NON-NLS-1$
		}
		
		return createdDate;
	}

	public static String getProjectName(TaskData taskData, XPlannerClient client) {
	  String projectName = Messages.XPlannerRepositoryUtils_NO_PROJECT_NAME;

	  UserStoryData userStory;
		try {
			userStory = client.getUserStory(taskData.getStoryId());
			projectName = getProjectName(userStory, client);
		}
		catch (RemoteException e) {
			// TODO Auto-generated catch block

		return projectName;
	}
	
	public static String getProjectName(UserStoryData userStory, XPlannerClient client) {
	  String projectName = Messages.XPlannerRepositoryUtils_NO_PROJECT_NAME;
	  
		try {
		  if (userStory != null) {
		    IterationData iteration = client.getIteration(userStory.getIterationId());
		    if (iteration != null) {
		      ProjectData project = client.getProject(iteration.getProjectId());
		      if (project != null) {
		        projectName = project.getName();
		      }  

	  return projectName;
	}

	public static String getIterationName(TaskData taskData, XPlannerClient client) {
	  String iterationName = Messages.XPlannerRepositoryUtils_NO_ITERATION_NAME;
	  
		try {
			UserStoryData userStory = client.getUserStory(taskData.getStoryId());
			iterationName = getIterationName(userStory, client);
		}
		catch (RemoteException e) {
			// TODO Auto-generated catch block

		return iterationName;
	}

	public static String getIterationName(UserStoryData userStory, XPlannerClient client) {
	  String iterationName = Messages.XPlannerRepositoryUtils_NO_ITERATION_NAME;
	  
		try {
	    IterationData iteration = client.getIteration(userStory.getIterationId());
	    if (iteration != null) {
	      iterationName = iteration.getName();
	    }

	  return iterationName;
	}

	public static String getUserStoryName(TaskData taskData, XPlannerClient client) {
	  String userStoryName = Messages.XPlannerRepositoryUtils_NO_USER_STORY_NAME;
	  
		try {
      UserStoryData userStory = client.getUserStory(taskData.getStoryId());
		  if (userStory != null) {
		  	userStoryName = userStory.getName();
		  }

		return repositoryTaskData.getAttributeValue(RepositoryTaskAttribute.SUMMARY);
	}

	public static String getPriorityFromXPlannerObject(Object xplannerObject, XPlannerClient client) {
		int priority = -1;
		UserStoryData userStory = null;
		
		try {
			if (xplannerObject instanceof TaskData) {
				userStory = client.getUserStory(((TaskData)xplannerObject).getStoryId());
			}
			else if (xplannerObject instanceof UserStoryData) {
				userStory = (UserStoryData)xplannerObject;

		}
		
		TaskRepository taskRepository = TasksUiPlugin.getRepositoryManager().getRepository(
				XPlannerMylynUIPlugin.REPOSITORY_KIND, repositoryUrl);		
		if (taskRepository != null && !isRepositoryUrlValidated(taskRepository.getUrl())) {
			validateRepository(taskRepository);
		}
	}

	public static void validateRepository(TaskRepository taskRepository) throws CoreException {
		validateRepository(taskRepository.getUrl(),
				taskRepository.getUserName(), taskRepository.getPassword(), taskRepository.getProxy(), 
				taskRepository.getHttpUser(), taskRepository.getHttpPassword());
	}
	
	public static void validateRepository(String url, String userName, String password) throws CoreException {
		validateRepository(url, userName, password, Proxy.NO_PROXY, null, null);
	}
	
	public static void validateRepository(String url, String userName, String password,
		Proxy proxy, String httpUser, String httpPassword) throws CoreException {
		
		try {
			XPlannerClientFacade.getDefault().validateServerAndCredentials(url, userName, password,
				proxy, httpUser, httpPassword);
					taskRepository.getUserName(), taskRepository.getPassword());
		} 
		catch (Exception e) {
			throw new CoreException(XPlannerCorePlugin.toStatus(e));
		}

	}
	
}
 




 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.ui;

import java.rmi.RemoteException;
import java.text.MessageFormat;
import java.text.ParseException;
import java.util.*;

import org.eclipse.core.runtime.*;
import org.eclipse.mylyn.internal.tasks.core.RepositoryTaskHandleUtil;
import org.eclipse.mylyn.monitor.core.StatusHandler;
import org.eclipse.mylyn.tasks.core.*;
import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
import org.eclipse.mylyn.xplanner.core.service.XPlannerClient;
import org.eclipse.mylyn.xplanner.wsdl.soap.domain.DomainData;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.mylar.internal.tasks.core.RepositoryTaskHandleUtil;
import org.eclipse.mylar.tasks.core.AbstractRepositoryConnector;
import org.eclipse.mylar.tasks.core.AbstractRepositoryQuery;
import org.eclipse.mylar.tasks.core.AbstractRepositoryTask;
import org.eclipse.mylar.tasks.core.IAttachmentHandler;
import org.eclipse.mylar.tasks.core.ITask;
import org.eclipse.mylar.tasks.core.ITaskDataHandler;
import org.eclipse.mylar.tasks.core.QueryHitCollector;
import org.eclipse.mylar.tasks.core.RepositoryTaskData;
import org.eclipse.mylar.tasks.core.TaskList;
import org.eclipse.mylar.tasks.core.TaskRepository;
import org.eclipse.mylar.tasks.ui.TasksUiPlugin;
import org.eclipse.mylar.xplanner.core.service.XPlannerServer;
import org.xplanner.soap.TaskData;
import org.xplanner.soap.UserStoryData;

import org.eclipse.mylar.xplanner.wsdl.soap.domain.DomainData;

/**
 * @author Ravi Kumar 
 * @author Helen Bershadskaya 
 */
public class XPlannerRepositoryConnector extends AbstractRepositoryConnector {

	//private static final String VERSION_SUPPORT = Messages.XPlannerRepositoryConnector_VERSION_SUPPORT;

	private XPlannerTaskDataHandler offlineHandler;
	
	//private List<String> supportedVersions;

	/** Name initially given to new tasks. Public for testing */
	public static final String NEW_TASK_DESC = Messages.XPlannerRepositoryConnector_NEW_TASK_DESCRIPTION;

	public void init(TaskList taskList) {
		super.init(taskList);
		this.offlineHandler = new XPlannerTaskDataHandler(taskList);
	}

	public String getLabel() {
		return XPlannerMylynUIPlugin.XPLANNER_CLIENT_LABEL;
	}

	public String getConnectorKind() {
		return XPlannerMylynUIPlugin.REPOSITORY_KIND;
	}

	@Override
	public AbstractAttachmentHandler getAttachmentHandler() {
		// not implemented yet
		return null;
	}

	@Override
	public AbstractTaskDataHandler getTaskDataHandler() {
		return offlineHandler;
	}


		return true;
	}

	protected AbstractTask makeTask(String repositoryUrl, String id, String summary) {
		return new XPlannerTask(repositoryUrl, id, summary);
	}

	public AbstractTask createTask(String repositoryUrl, String id, String summary) {
		AbstractTask task = null;
		
		TaskRepository repository = TasksUiPlugin.getRepositoryManager().getRepository(
			XPlannerMylynUIPlugin.REPOSITORY_KIND, repositoryUrl);
		String handleIdentifier = RepositoryTaskHandleUtil.getHandle(repository.getUrl(), id);
		AbstractTask existingTask = TasksUiPlugin.getTaskListManager().getTaskList().getTask(
			handleIdentifier);

		if (existingTask instanceof XPlannerTask) {
			task = (XPlannerTask) existingTask;
		} 
		else {
			try {
				task = createTask(repository, id);
			}
			catch (CoreException e) {
				XPlannerMylynUIPlugin.log(e, "", false); //$NON-NLS-1$
			}
		}

		return task;
	}
	
	private AbstractTask createTask(TaskRepository repository, String key) throws CoreException {
		XPlannerTask task = null;

		XPlannerRepositoryUtils.checkRepositoryValidated(repository.getUrl());
		XPlannerClient client = XPlannerClientFacade.getDefault().getXPlannerClient(repository);
		if (client != null) {
			XPlannerTask task = null;
			try {
				// first check if taskdata exists
				TaskData taskData = client.getTask(Integer.valueOf(key).intValue());
				if (taskData != null) {
					task = createTask(taskData, taskData.getName(), String.valueOf(taskData.getId()), repository);
					updateTaskDetails(repository.getUrl(), task, taskData, true);
				}
				else {
					// otherwise check if a user story exists
					UserStoryData userStory = client.getUserStory(Integer.valueOf(key).intValue());
					if (userStory != null) {
						task = createTask(userStory, userStory.getName(), String.valueOf(userStory.getId()), repository);
						updateTaskDetails(repository.getUrl(), task, userStory, true);
					}
				}
			} 
			catch (Exception e) {
				e.printStackTrace();
			} 

			if (task != null) {
				TasksUiPlugin.getTaskListManager().getTaskList().addTask(task);
				return task;
			}

		}
		
		return task;
	}

	@Override
	public IStatus performQuery(AbstractRepositoryQuery repositoryQuery, TaskRepository repository,
			IProgressMonitor monitor, ITaskCollector resultCollector) {
		
		if (!(repositoryQuery instanceof XPlannerCustomQuery)) {
			return Status.OK_STATUS;



		try {
			monitor.beginTask("Running query", IProgressMonitor.UNKNOWN);
			XPlannerClient client = XPlannerClientFacade.getDefault().getXPlannerClient(repository);

			if (xplannerCustomQuery.isMyCurrentTasks()) {
				return queryMyCurrentTasks(xplannerCustomQuery, client, repository, resultCollector);
			}
			else {
				return queryTasks(xplannerCustomQuery, client, repository, resultCollector);
			}
			
		}

			if ((reason == null) || (reason.length() == 0)) {
				reason = e.getClass().getName();
			}
			return new Status(IStatus.OK, TasksUiPlugin.ID_PLUGIN, IStatus.ERROR, 
				MessageFormat.format(Messages.XPlannerRepositoryConnector_PerformQueryFailure, reason), e );
		}
		finally {
			monitor.done();
		}
		
		//return Status.OK_STATUS;
	}


//TODO -- no longer used -- remove if really unnecessary	
//	private IStatus queryUserStories(XPlannerCustomQuery xplannerCustomQuery, 
//		XPlannerClient client, TaskRepository repository, QueryHitCollector resultCollector) throws RemoteException {
//		
//		int iterationId = xplannerCustomQuery.getContentId();
//		UserStoryData[] userStories;

//		// check if want all or person's stories
//		if (xplannerCustomQuery.getPersonId() != XPlannerCustomQuery.INVALID_ID) {
//			int trackerId = xplannerCustomQuery.getPersonId();
//			userStories = client.getIterationUserStoriesForTracker(trackerId, iterationId);
//		}
//		else {
//			userStories = client.getUserStories(iterationId);
//		}
//		
//		return getUserStoryQueryHits(Arrays.asList(userStories), repository, xplannerCustomQuery, resultCollector);
//	}

	private IStatus queryMyCurrentTasks(XPlannerCustomQuery xplannerCustomQuery,
		XPlannerClient client, TaskRepository repository, ITaskCollector resultCollector) throws RemoteException {
		
		ArrayList<TaskData> xplannerTasks = new ArrayList<TaskData>();
		int currentPersonId = client.getCurrentPersonId();
		
		xplannerTasks.addAll(Arrays.asList(client.getCurrentTasksForPerson(currentPersonId)));
		xplannerTasks.addAll(Arrays.asList(client.getPlannedTasksForPerson(currentPersonId)));
		
		return getTaskQueryHits(xplannerTasks, repository, xplannerCustomQuery, resultCollector);
	}

	private IStatus queryTasks(XPlannerCustomQuery xplannerCustomQuery, 
		XPlannerClient client, TaskRepository repository, ITaskCollector resultCollector) throws RemoteException {
		
		List<Integer> contentIds = xplannerCustomQuery.getContentIds();
		ArrayList<TaskData> xplannerTasks = new ArrayList<TaskData>();
		XPlannerCustomQuery.ContentIdType contentIdType = xplannerCustomQuery.getContentIdType();
		
		for (Integer contentId : contentIds) {
			addTasks(contentId, contentIdType, xplannerTasks, xplannerCustomQuery, client);
		}
		
		return getTaskQueryHits(xplannerTasks, repository, xplannerCustomQuery, resultCollector);


	private void addTasks(int contentId, 
		XPlannerCustomQuery.ContentIdType contentIdType, List<TaskData> xplannerTasks, 
		XPlannerCustomQuery xplannerCustomQuery, XPlannerClient client) throws RemoteException {
		
		if (contentId == XPlannerCustomQuery.INVALID_ID) {
			return;
		}
		
		if (contentIdType == XPlannerCustomQuery.ContentIdType.PROJECT) {
			UserStoryData[] userStories = client.getUserStoriesForProject(contentId);
			for (UserStoryData userStory : userStories) {
				addUserStoryTasks(xplannerCustomQuery, userStory.getId(), xplannerTasks, client);
			}
		}
		else if (contentIdType == XPlannerCustomQuery.ContentIdType.ITERATION) {
			UserStoryData[] userStories = client.getUserStories(contentId);
			for (UserStoryData userStory : userStories) {
				addUserStoryTasks(xplannerCustomQuery, userStory.getId(), xplannerTasks, client);
			}
		}
		else if (contentIdType == XPlannerCustomQuery.ContentIdType.USER_STORY) {
			addUserStoryTasks(xplannerCustomQuery, contentId, xplannerTasks, client);
		}
	}

	private void addUserStoryTasks(XPlannerCustomQuery query, int userStoryId, 
		List<TaskData> xplannerTasks, XPlannerClient client) {
		// check if want all or person's tasks
		if (query.getPersonId() != XPlannerCustomQuery.INVALID_ID) {
			int personId = query.getPersonId();
			xplannerTasks.addAll(Arrays.asList(client.getUserStoryTasksForPerson(personId, userStoryId)));
		}
		else {
			try {
				xplannerTasks.addAll(Arrays.asList(client.getTasks(userStoryId)));
			}
			catch (RemoteException e) {
				e.printStackTrace();

	}
	
	private IStatus getTaskQueryHits(List<TaskData> tasks, 
		TaskRepository repository, XPlannerCustomQuery query, ITaskCollector resultCollector) {
		
		for (TaskData data : tasks) {
			String id = String.valueOf(data.getId());
			AbstractTask task = TasksUiPlugin.getTaskListManager().getTaskList().getTask(repository.getUrl(), id);
			if (task != null) {
				updateTaskDetails(repository.getUrl(), (XPlannerTask) task, data, false);
			}
			updateTaskDetails(repository.getUrl(), (XPlannerTask) task, data, false);

			XPlannerQueryHit hit = new XPlannerQueryHit(
				taskList, task.getSummary(), task.getPriority(), query.getRepositoryUrl(), 
				id, (XPlannerTask) task);
			try {
				resultCollector.accept(hit);
				} catch (CoreException e) {
				return new Status(IStatus.OK, TasksUiPlugin.PLUGIN_ID, IStatus.ERROR, 
						MessageFormat.format(Messages.XPlannerRepositoryConnector_ERROR_RETRIEVING_RESULTS, query.getRepositoryUrl()), e );
			}

//			try {
// HeB -- priority already set in task				
//				XPlannerClient client = XPlannerClientFacade.getDefault().getXPlannerClient(repository);
//				UserStoryData userStory = client.getUserStory(data.getStoryId());
//				String priority = userStory == null ? AbstractTask.PriorityLevel.getDefault().toString() : 
//					"" + userStory.getPriority(); //$NON-NLS-1$
//				task.setPriority(priority);
			else {
				task = createTask(data, data.getName(), String.valueOf(data.getId()), repository);
			if (!(task instanceof XPlannerTask)) {
				task = createTask(data, data.getName(), id, repository);
			}
			updateTaskDetails(repository.getUrl(), (XPlannerTask) task, data, false);

			XPlannerQueryHit hit = new XPlannerQueryHit(taskList, 
				task.getSummary(), task.getPriority(), query.getRepositoryUrl(), 
				id, (XPlannerTask) task);
			try {
				resultCollector.accept(hit);
			} 
			catch (CoreException e) {
				return new Status(IStatus.OK, TasksUiPlugin.PLUGIN_ID, IStatus.ERROR, 
						MessageFormat.format(Messages.XPlannerRepositoryConnector_ERROR_RETRIEVING_RESULTS, query.getRepositoryUrl()), e );
			}
			
			resultCollector.accept(task);
//			} 
//			catch (Exception e) {
//				return new Status(IStatus.OK, TasksUiPlugin.PLUGIN_ID, IStatus.ERROR, 
//						MessageFormat.format(Messages.XPlannerRepositoryConnector_ERROR_RETRIEVING_RESULTS, query.getRepositoryUrl()), e );
//			}
		}
		
		return Status.OK_STATUS;
	}

// no longer called -- calling routine commented out	
//	private IStatus getUserStoryQueryHits(List<UserStoryData> userStories, 
//		TaskRepository repository, XPlannerCustomQuery query, QueryHitCollector resultCollector) {
//		
//		for (UserStoryData data : userStories) {
//			String id = String.valueOf(data.getId());
//			ITask task = TasksUiPlugin.getTaskListManager().getTaskList().getTask(repository.getUrl(), id);
//			if (task != null) {
//				updateTaskDetails(repository.getUrl(), (XPlannerTask) task, data, false);
//			}
//
//			XPlannerQueryHit hit = new XPlannerQueryHit(taskList, 
//				data.getDescription(), "" + data.getPriority(), query.getRepositoryUrl(),  //$NON-NLS-1$
//				id);
//			resultCollector.accept(hit);
//		}
//		
//		return Status.OK_STATUS;
//	}
	
	@Override
	public void updateTaskFromRepository(TaskRepository repository, AbstractTask repositoryTask,
		IProgressMonitor monitor) throws CoreException {
		
		if (repository != null && repositoryTask instanceof XPlannerTask) {
			XPlannerTask xPlannerTask = (XPlannerTask) repositoryTask;
			XPlannerClient client = XPlannerClientFacade.getDefault().getXPlannerClient(repository);
			if (client != null) {
				TaskData xplannerTaskData;
				try {
					xplannerTaskData = client.getTask(Integer.valueOf(xPlannerTask.getTaskId()).intValue());
					if (xplannerTaskData != null) {
						updateTaskDetails(repository.getUrl(), xPlannerTask, xplannerTaskData, true);
					}
					else {
						UserStoryData userStoryData;
						userStoryData = client.getUserStory(Integer.valueOf(xPlannerTask.getTaskId()).intValue());
						if (userStoryData != null) {
							updateTaskDetails(repository.getUrl(), xPlannerTask, userStoryData, true);
						}
					}
				}
				catch (Exception e) {
					throw new CoreException(new Status(IStatus.ERROR, 
							XPlannerMylynUIPlugin.PLUGIN_ID, IStatus.ERROR, Messages.XPlannerRepositoryConnector_ERROR_UPDATING_TASK, e));
				}
			}
		}
	}

	@Override
	public void updateTaskFromTaskData(TaskRepository repository, AbstractTask repositoryTask,
		RepositoryTaskData taskData) {
		
		if (taskData != null) {
			XPlannerTask xplannerTask = (XPlannerTask) repositoryTask;
			String url = repository.getUrl() + XPlannerMylynUIPlugin.TASK_URL_PREFIX + taskData.getId();
			xplannerTask.setUrl(url);
			xplannerTask.setSummary(taskData.getSummary());
			xplannerTask.setOwner(taskData.getAssignedTo());
			xplannerTask.setPriority(taskData.getAttributeValue(RepositoryTaskAttribute.PRIORITY));
			xplannerTask.setTaskKind(taskData.getTaskKind());

			
			if (XPlannerRepositoryUtils.isCompleted(taskData)) {
				xplannerTask.setCompleted(true);
				try {
					xplannerTask.setCompletionDate(	// guess that completed when last modified
							XPlannerAttributeFactory.TIME_DATE_FORMAT.parse(
							taskData.getAttribute(RepositoryTaskAttribute.DATE_MODIFIED).getValue()));
				}
				catch (ParseException e) {
					StatusHandler.log(e, Messages.XPlannerRepositoryConnector_COULD_NOT_CONVERT_TASK_DATE);
				}
			} 
			else {
				xplannerTask.setCompleted(false);
				xplannerTask.setCompletionDate(null);
			}
		}
	}
	
	@Override
	public String getRepositoryUrlFromTaskUrl(String url) {
		if (url == null) {
			return null;
		}
		int index = url.indexOf(XPlannerMylynUIPlugin.DELIM_URL_PREFIX);
		if (index != -1) {
			return url.substring(0, index);
		}


	public void updateTaskDetails(String repositoryUrl, XPlannerTask task, TaskData taskData, boolean notifyOfChange) {
		if (taskData.getId() > 0) {
			String url = repositoryUrl + XPlannerMylynUIPlugin.TASK_URL_PREFIX + taskData.getId();
			task.setUrl(url);
			if (taskData.getName() != null) {
				task.setSummary(taskData.getName());
				task.setKey(String.valueOf(taskData.getId()));
			}
		}
		if (taskData.isCompleted()) {

		}

		if (notifyOfChange) {
			TasksUiPlugin.getTaskListManager().getTaskList().notifyTaskChanged(task, true);
		}
	}
	

		UserStoryData userStory, boolean notifyOfChange) {
		
		if (userStory.getId() > 0) {
			String url = repositoryUrl + XPlannerMylynUIPlugin.USER_STORY_URL_PREFIX + userStory.getId();
			task.setUrl(url);
			if (userStory.getName() != null) {
				task.setSummary(userStory.getName());
				task.setKey(String.valueOf(userStory.getId()));
			}
		}

		}
	    
		task.setPriority("" + userStory.getPriority()); //$NON-NLS-1$
		task.setTaskKind(XPlannerTask.Kind.USER_STORY.toString());

		if (notifyOfChange) {
			TasksUiPlugin.getTaskListManager().getTaskList().notifyTaskChanged(task, true);
		}
	}
	

		
		XPlannerTask task;
		
		AbstractTask existingTask = TasksUiPlugin.getTaskListManager().getTaskList().getTask(
			repository.getUrl(), id);	
			handleIdentifier);
		if (existingTask instanceof XPlannerTask) {
			task = (XPlannerTask) existingTask;
		} 
		else {
			task = new XPlannerTask(repository.getUrl(), id, name);
			task.setKey(String.valueOf(data.getId()));
			task.setKind(data);
//HeB -- testing			
//			TasksUiPlugin.getTaskListManager().getTaskList().addTask(task);
		
		RepositoryTaskData taskData = null;
		try {
			XPlannerServer server = XPlannerServerFacade.getDefault().getXPlannerServer(repository);
			taskData = XPlannerRepositoryUtils.createRepositoryTaskData(repository, task, server);
		} 
		catch (Throwable e) {
			e.printStackTrace();
		}
		if (taskData != null) {
			task.setTaskData(taskData);
		}

		return task;


	@Override
	public void updateAttributes(TaskRepository repository, IProgressMonitor monitor) throws CoreException {
		XPlannerClientFacade.getDefault().refreshClientSettings(repository);
	}
	
	public String getTaskUrl(String repositoryUrl, String taskId) {
		String taskUrl = null;

		TaskRepository repository = TasksUiPlugin.getRepositoryManager()
				.getRepository(XPlannerMylynUIPlugin.REPOSITORY_KIND, repositoryUrl);
		try {
			XPlannerClient client = XPlannerClientFacade.getDefault().getXPlannerClient(repository);
			if (client != null) {
				TaskData taskData = client.getTask(Integer.valueOf(taskId).intValue());
				// first check if taskdata exists
				if (taskData != null) {
					if (taskData.getId() > 0) {
						taskUrl = repositoryUrl + XPlannerMylynUIPlugin.TASK_URL_PREFIX
								+ taskData.getId();
					}
				}
				else {
					// otherwise check if a user story exists
					UserStoryData userStory = client.getUserStory(Integer.valueOf(taskId)
							.intValue());
					if (userStory != null) {
						taskUrl = repositoryUrl + XPlannerMylynUIPlugin.USER_STORY_URL_PREFIX + userStory.getId();
					}
				}
			}

			return null;
		}
		
		int index = url.indexOf(XPlannerMylynUIPlugin.DELIM_URL_SUFFIX);
		if (index != -1) {
			taskId = url.substring(index + XPlannerMylynUIPlugin.DELIM_URL_SUFFIX.length());
		}
		
		return taskId;
	}
	
	public Set<AbstractTask> getChangedSinceLastSync(TaskRepository repository,
			Set<AbstractTask> tasks) throws CoreException {
	
		XPlannerClient client = XPlannerClientFacade.getDefault().getXPlannerClient(repository);
		if (client == null) {
			return Collections.emptySet();
		} 
		else {
			Set<AbstractTask> changedTasks = new HashSet<AbstractTask>();
			for (AbstractTask task : tasks) {
				if (task instanceof XPlannerTask) {
					XPlannerTask xplannerTask = (XPlannerTask) task;
					TaskData taskData;
					try {
						taskData = client.getTask(Integer.valueOf(xplannerTask.getTaskId()).intValue());
						if (taskData != null) {
							Date lastUpdateTime = taskData.getLastUpdateTime().getTime();
							String lastSynchStamp = xplannerTask.getLastReadTimeStamp();
							Date lastSynchTime = null;
							if (lastSynchStamp != null && lastSynchStamp.length() > 0) {
								lastSynchTime = XPlannerAttributeFactory.TIME_DATE_FORMAT.parse(lastSynchStamp);

		}
	}

	@Override
	public boolean markStaleTasks(TaskRepository repository,
		Set<AbstractTask> tasks, IProgressMonitor monitor) throws CoreException {
		
		boolean changed = false;
		
		try {
			monitor.beginTask("Getting changed tasks", IProgressMonitor.UNKNOWN);
			
			if (repository.getSynchronizationTimeStamp() == null) {
				for (AbstractTask task : tasks) {
					task.setStale(true);
				}
				changed = true;
			}
			else {
				Set<AbstractTask> changedTasks = getChangedSinceLastSync(repository, tasks);
				for (AbstractTask changedTask : changedTasks) {
					changedTask.setStale(true);
				}
	
				changed = true;
			}
		} 
		finally {
			monitor.done();
		}
		
		return changed;
	}

}




MylynXPlannerPlugin_CLIENT_LABEL=XPlanner (supports 0.7 and later)
MylynXPlannerPlugin_CLIENT_DIALOG_TITLE=Mylyn XPlanner Client
MylynXPlannerPlugin_NOT_AVAILABLE_IN_SKU=Mylyn XPlanner plugin features are not available in this SKU
MylynXPlannerPlugin_XPLANNER_ERROR_TITLE=Mylyn XPlanner Error
XPlannerClientFacade_SERVER_CONNECTION_ERROR=Error connecting to XPlanner Server
XPlannerClientFacade_CONNECTION_FAILURE_ERROR=XPlanner Connection Failure.\n\n
XPlannerClientFacade_INVALID_URL_EXCEPTION=Invalid url 
XPlannerClientFacade_NETWORK_CONNECTION_FAILURE=Please check your network connection and XPlanner server settings in the Task Repositories view.
XPlannerRepositoryConnector_NEW_TASK_DESCRIPTION=New Task
XPlannerRepositoryConnector_PerformQueryFailure=Mylyn XPlanner query failure: {0}
XPlannerRepositoryConnector_ERROR_RETRIEVING_RESULTS=Error while retrieving results from: {0}
XPlannerRepositoryConnector_COULD_NOT_CONVERT_TASK_DATE=Could not convert task date using format
XPlannerRepositoryConnector_ERROR_UPDATING_TASK=Error updating task
XPlannerClientFacade_AUTHENTICATION_FAILED=XPlanner Authentication Failed.\n\n
XPlannerClientFacade_USERNAME_PASSWORD_ERROR=Please check your XPlanner username and password in the Task Repositories view
XPlannerClientFacade_NO_REPOSITORY_FOUND=No XPlanner repository found.\n\n
XPlannerClientFacade_VERIFY_VALID_REPOSITORY=Please verify that a vaild XPlanner repository exists in the Task Repositories view
XPlannerRepositoryConnector_VERSION_SUPPORT=0.7 and higher
XPlannerRepositoryConnector_ErrorDialogTitle=XPlanner Query Error
XPlannerRepositoryUtils_TASK_DOWNLOAD_FAILED=Task download failed. Ensure proper repository configuration of {0} in {1}.

XPlannerRepositoryUtils_NO_PROJECT_NAME=<no project name>
XPlannerRepositoryUtils_NO_ITERATION_NAME=<no iteration name>
XPlannerRepositoryUtils_NO_USER_STORY_NAME=<no user story name>
XPlannerClientFacade_COULD_NOT_CONNECT_TO_REPOSITORY=Could not connect to XPlanner repository.\n\n
XPlannerTaskExternalizer_FAILED_TO_LOAD_HITS_EXCEPTION=Failed to load all hits
XPlannerTaskExternalizer_HANDLE_NOT_STORED_EXCEPTION=Handle not stored for task
XPlannerOfflineTaskHandler_CANNOT_POST_DATA_TO_SERVER=Cannot post XPlanner task data to XPlanner server
XPlannerTaskExternalizer_DESCRIPTION_NOT_STORED_EXCEPTION=Description not stored for task
XPlannerClientFacade_CHECK_CREDENTIALS=Please check your credentials in the Task Repositories view




/*******************************************************************************
 * Copyright (c) 2007 - 2007 CodeGear and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylar.xplanner.ui;

import org.eclipse.mylar.tasks.core.TaskRepository;
import org.eclipse.mylar.tasks.ui.TasksUiPlugin;
import org.eclipse.mylar.xplanner.ui.wizard.NewXPlannerQueryWizard;

/**
 * @author Ravi Kumar
 * @author Helen Bershadskaya
 */
public class MylarXPlannerUtils {
	private MylarXPlannerUtils() {
		
	}
	
	public static void addNewMyTasksQuery(TaskRepository repository,
		String name) {
		
		XPlannerCustomQuery myTasksQuery = 
			new XPlannerCustomQuery(repository.getUrl(), name, 
				TasksUiPlugin.getTaskListManager().getTaskList());
		
		myTasksQuery.setMyCurrentTasks(true);
		NewXPlannerQueryWizard.addQuery(myTasksQuery, repository);
	}
			
}




 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.ui;

import java.net.MalformedURLException;
import java.net.URL;

import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.resource.ImageRegistry;
import org.eclipse.mylyn.internal.tasks.ui.TaskListImageDescriptor;
import org.eclipse.swt.graphics.Image;




	private static final String T_VIEW = "eview16"; //$NON-NLS-1$

	private static final URL baseURL = XPlannerMylynUIPlugin.getDefault() == null ? null :
		XPlannerMylynUIPlugin.getDefault().getBundle().getEntry("/icons/"); //$NON-NLS-1$ 

	public static final ImageDescriptor OVERLAY_XPLANNER = create(T_VIEW, "overlay-xplanner.gif"); //$NON-NLS-1$
	




/*******************************************************************************
 * Copyright (c) 2007 - 2007 CodeGear and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylar.xplanner.ui;

import org.eclipse.mylar.tasks.core.AbstractQueryHit;
import org.eclipse.mylar.tasks.core.AbstractRepositoryTask;
import org.eclipse.mylar.tasks.core.TaskList;

/**
 * Represents an XPlanner task returned as the result of a XPlanner query
 * 
 * @author Ravi Kumar 
 * @author Helen Bershadskaya 
 */
public class XPlannerQueryHit extends AbstractQueryHit {

	private XPlannerTask task = null;

	public XPlannerQueryHit(TaskList taskList, String description, String priority, 
			String repositoryUrl, String id, XPlannerTask task) {
		
		super(taskList, repositoryUrl, description, id);
		super.priority = priority;
		this.task = task;
	}

	@Override
	protected AbstractRepositoryTask createTask() {
		return task;  //TODO -- not sure if this is right, but corresponds to what we did before
	}

	/**
	 * @return null if there is no corresponding report
	 */
	public AbstractRepositoryTask getCorrespondingTask() {
		return task;
	}

	public void setCorrespondingTask(AbstractRepositoryTask task) {
		if (task instanceof XPlannerTask) {
			this.task = (XPlannerTask)task;
		}
	}

	public boolean isCompleted() {
		return task.isCompleted();
	}

	public String getPriority() {
		return task.getPriority();
	}

	public String getSummary() {
		return task.getSummary();
	}

	public void setDescription(String description) {
		task.setDescription(description);
	}

	public boolean isLocal() {
		return false;
	}
}




 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.ui;

import java.util.Arrays;
import java.util.List;

import org.eclipse.mylyn.tasks.core.AbstractRepositoryQuery;
import org.eclipse.mylar.tasks.core.TaskList;



/**
 * An XPlannerCustomQuery represents a query for tasks or user stories from a XPlanner repository.
 * 
 * @author Ravi Kumar  
 * @author Helen Bershadskaya 
 */
public class XPlannerCustomQuery extends AbstractRepositoryQuery {

	public static final int INVALID_ID = -1;
	public static final List<Integer> INVALID_IDS = Arrays.asList(new Integer[] {INVALID_ID});
	//private static final int MAX_HITS = 75;
  public static enum ContentIdType {PROJECT, ITERATION, USER_STORY};  

  private String queryName = null;

  private boolean myCurrentTasks = false;
  private ContentIdType contentIdType = ContentIdType.USER_STORY;  
    
	public XPlannerCustomQuery(String repositoryUrl, String queryName) {
		super(queryName);
		this.queryName = queryName;
		super.repositoryUrl = repositoryUrl;
	}

	public String getRepositoryKind() {
		return XPlannerMylynUIPlugin.REPOSITORY_KIND;
	}
	
	public String getQueryName() {




 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.ui;

import org.eclipse.osgi.util.NLS;


 * @author Helen Bershadskaya 
 */
public class Messages extends NLS {
	private static final String BUNDLE_NAME = "org.eclipse.mylyn.xplanner.ui.messages"; //$NON-NLS-1$

	public static String MylynXPlannerPlugin_CLIENT_DIALOG_TITLE;

	public static String MylynXPlannerPlugin_CLIENT_LABEL;

	public static String MylynXPlannerPlugin_XPLANNER_ERROR_TITLE;

	public static String MylynXPlannerPlugin_NOT_AVAILABLE_IN_SKU;

	public static String XPlannerOfflineTaskHandler_CANNOT_POST_DATA_TO_SERVER;

	public static String XPlannerRepositoryConnector_COULD_NOT_CONVERT_TASK_DATE;

	public static String XPlannerRepositoryConnector_ERROR_RETRIEVING_RESULTS;



	public static String XPlannerRepositoryUtils_TASK_DOWNLOAD_FAILED;

	public static String XPlannerClientFacade_AUTHENTICATION_FAILED;

	public static String XPlannerClientFacade_CHECK_CREDENTIALS;

	public static String XPlannerClientFacade_CONNECTION_FAILURE_ERROR;

	public static String XPlannerClientFacade_COULD_NOT_CONNECT_TO_REPOSITORY;

	public static String XPlannerClientFacade_INVALID_URL_EXCEPTION;

	public static String XPlannerClientFacade_NETWORK_CONNECTION_FAILURE;

	public static String XPlannerClientFacade_NO_REPOSITORY_FOUND;

	public static String XPlannerClientFacade_SERVER_CONNECTION_ERROR;

	public static String XPlannerClientFacade_USERNAME_PASSWORD_ERROR;

	public static String XPlannerClientFacade_VERIFY_VALID_REPOSITORY;

	public static String XPlannerTaskExternalizer_DESCRIPTION_NOT_STORED_EXCEPTION;





 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.ui;

import org.eclipse.mylyn.tasks.core.AbstractTask;
import org.eclipse.mylyn.xplanner.wsdl.soap.domain.DomainData;
import org.xplanner.soap.IterationData;
import org.xplanner.soap.UserStoryData;

import org.eclipse.mylar.xplanner.wsdl.soap.domain.DomainData;

/**
 * @author Ravi Kumar 
 * @author Helen Bershadskaya 
 */
public class XPlannerTask extends AbstractTask {

	private String key = null;


				return ""; //$NON-NLS-1$
			}
		}
		
		public static Kind fromString(String kindValue) {
			Kind kind = null;
		
			if (kindValue == null) {
				kind = null;
			}
			else if (kindValue.equals(TASK.toString())) {
				kind = TASK;
			}
			else if (kindValue.equals(USER_STORY.toString())) {
				kind = USER_STORY;
			}
			else if (kindValue.equals(ITERATION.toString())) {
				kind = ITERATION;
			}
			
			return kind;
		}

	}

	public void setKind(DomainData data) {

			tempKind = Kind.USER_STORY.toString();
		}
		
		setTaskKind(tempKind);
	}
	
	/**
	 * The handle is also the task's XPlanner url
	 */
	public XPlannerTask(String repositoryUrl, String id, String label) {
		super(repositoryUrl, id, label);
	}

	public String getConnectorKind() {
		return XPlannerMylynUIPlugin.REPOSITORY_KIND;
	}

	public boolean isLocal() {
		return false;
	}
	
	public String getKey() {
		return key;
	}

	public void setKey(String key) {
		this.key = key;
	}
	
	@Override
	public String getPriority() {
		String priority;
		
		if (taskData != null && taskData.getAttribute(RepositoryTaskAttribute.PRIORITY) != null) {
			priority = taskData.getAttributeValue(RepositoryTaskAttribute.PRIORITY);
		} 
		else {
			priority = super.getPriority();
		}
		
		return priority;
	}

}




 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.ui;

import org.eclipse.jface.viewers.IDecoration;
import org.eclipse.jface.viewers.ILabelProviderListener;
import org.eclipse.jface.viewers.ILightweightLabelDecorator;


/**
 * @author Ravi Kumar 
 * @author Helen Bershadskaya
 */
//HeB -- testing
public class XPlannerTaskDecorator {

	public void decorate(Object element, IDecoration decoration) {
		if (element instanceof XPlannerQueryHit) {
			XPlannerQueryHit hit = (XPlannerQueryHit) element;
			if (hit.getCorrespondingTask() != null) {
				decorate(hit.getCorrespondingTask(), decoration);
			}
		}
		if (element instanceof XPlannerTask) {
			XPlannerTask task = (XPlannerTask) element;
			if (XPlannerTask.Kind.ITERATION.toString().equals(task.getTaskKind())) {
				decoration.addOverlay(XPlannerImages.OVERLAY_ITERATION);
			} else if (XPlannerTask.Kind.USER_STORY.toString().equals(task.getTaskKind())) {
				decoration.addOverlay(XPlannerImages.OVERLAY_USER_STORY);
			} else if (XPlannerTask.Kind.TASK.toString().equals(task.getTaskKind())) {
				decoration.addOverlay(XPlannerImages.OVERLAY_TASK);
			}
		}
	}




 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.ui;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.wizard.IWizard;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.mylyn.tasks.core.*;
import org.eclipse.mylyn.tasks.ui.AbstractRepositoryConnectorUi;
import org.eclipse.mylyn.tasks.ui.wizards.AbstractRepositorySettingsPage;
import org.eclipse.mylyn.tasks.ui.wizards.NewWebTaskWizard;
import org.eclipse.mylyn.xplanner.ui.wizard.*;
import org.eclipse.mylar.xplanner.ui.wizard.EditXPlannerQueryWizard;
import org.eclipse.mylar.xplanner.ui.wizard.NewXPlannerQueryWizard;
import org.eclipse.mylar.xplanner.ui.wizard.XPlannerCustomQueryPage;
import org.eclipse.mylar.xplanner.ui.wizard.XPlannerRepositorySettingsPage;

/**
 * @author Ravi Kumar 

	}

	@Override
	public ImageDescriptor getTaskKindOverlay(AbstractTask task) {
		ImageDescriptor overlayImage;
		
		XPlannerTask.Kind kind = XPlannerTask.Kind.fromString(task.getTaskKind());
		if (kind.equals(XPlannerTask.Kind.TASK)) {
			overlayImage = XPlannerImages.OVERLAY_TASK;
		}
		else if (kind.equals(XPlannerTask.Kind.USER_STORY)) {
			overlayImage = XPlannerImages.OVERLAY_USER_STORY;
		}
		else if (kind.equals(XPlannerTask.Kind.ITERATION)) {
			overlayImage = XPlannerImages.OVERLAY_ITERATION;
		}
		else {
			overlayImage = super.getTaskKindOverlay(task);
		}
		
		return overlayImage;
	}

	@Override
	public WizardPage getSearchPage(TaskRepository repository, IStructuredSelection selection) {
		return new XPlannerCustomQueryPage(repository, null);
	} 

//				}
//			}
//		} catch (Exception e) {
//			MylynStatusHandler.fail(e, e.getMessage(), true);
//		}
//	
//	}

	}

	@Override
	public String getConnectorKind() {
		return XPlannerMylynUIPlugin.REPOSITORY_KIND;
	}

	@Override
	public String getRepositoryType() {
		return XPlannerMylarUIPlugin.REPOSITORY_KIND;
	}

	@Override

		return true;
	}
	
	@Override
	public String getTaskKindLabel(AbstractTask repositoryTask) {
		return repositoryTask == null ? super.getTaskKindLabel(repositoryTask) :
			repositoryTask.getTaskKind();
	}
	
	@Override
	public List<AbstractTaskContainer> getLegendItems() {
		List<AbstractTaskContainer> legendItems = new ArrayList<AbstractTaskContainer>();
		
		XPlannerTask task = new XPlannerTask("", XPlannerTask.Kind.TASK.name(), XPlannerTask.Kind.TASK.toString());
		task.setTaskKind(XPlannerTask.Kind.TASK.toString());		
		legendItems.add(task);

		XPlannerTask userStory = new XPlannerTask("", XPlannerTask.Kind.USER_STORY.name(), XPlannerTask.Kind.USER_STORY.toString());
		userStory.setTaskKind(XPlannerTask.Kind.USER_STORY.toString());		
		legendItems.add(userStory);

		XPlannerTask iteration = new XPlannerTask("", XPlannerTask.Kind.ITERATION.name(), XPlannerTask.Kind.ITERATION.toString());
		iteration.setTaskKind(XPlannerTask.Kind.ITERATION.toString());		
		legendItems.add(iteration);

		return legendItems;
	}

}




/*******************************************************************************
 * Copyright (c) 2007 - 2007 CodeGear and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylar.xplanner.ui;

import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.mylar.core.MylarStatusHandler;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.plugin.AbstractUIPlugin;
import org.osgi.framework.BundleContext;

/**
 * @author Ravi Kumar 
 * @author Helen Bershadskaya 
 */
public class XPlannerMylarUIPlugin extends AbstractUIPlugin {

	private static XPlannerMylarUIPlugin INSTANCE;

	public static final String PLUGIN_ID = "org.eclipse.mylar.xplanner.ui"; //$NON-NLS-1$

	public final static String REPOSITORY_KIND = "xplanner"; //$NON-NLS-1$

	public final static String XPLANNER_CLIENT_LABEL = Messages.MylarXPlannerPlugin_CLIENT_LABEL;

	public final static String TITLE_MESSAGE_DIALOG = Messages.MylarXPlannerPlugin_CLIENT_DIALOG_TITLE;

	public static final String DELIM_URL_PREFIX = "/do/view/"; //$NON-NLS-1$

	public final static String DELIM_URL_SUFFIX = "?oid="; //$NON-NLS-1$

	public final static String TASK_URL_PREFIX = DELIM_URL_PREFIX + "task" + DELIM_URL_SUFFIX; //$NON-NLS-1$

	public final static String USER_STORY_URL_PREFIX = DELIM_URL_PREFIX + "userstory" + DELIM_URL_SUFFIX; //$NON-NLS-1$

	public final static String ITERATION_URL_PREFIX = DELIM_URL_PREFIX + "iteration" + DELIM_URL_SUFFIX; //$NON-NLS-1$

	public final static IStatus NO_LICENSE_STATUS = new Status(IStatus.INFO, XPlannerMylarUIPlugin.PLUGIN_ID,
			0, Messages.MylarXPlannerPlugin_NOT_AVAILABLE_IN_SKU, null);

	public XPlannerMylarUIPlugin() {
		INSTANCE = this;
	}

	public void stop(BundleContext context) throws Exception {
		super.stop(context);
		INSTANCE = null;
		XPlannerServerFacade.getDefault().logOutFromAll();
	}

	public static void log(final Throwable e, final String message, boolean informUser) {
		if (Platform.isRunning() && informUser) {
			try {
				PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
					public void run() {
						Shell shell = null;
						if (PlatformUI.getWorkbench() != null
								&& PlatformUI.getWorkbench().getActiveWorkbenchWindow() != null) {
							shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
						}
						String displayMessage = message == null ? e.getMessage() : message + "\n" + e.getMessage(); //$NON-NLS-1$
						MessageDialog.openError(shell, Messages.MylarXPlannerPlugin_MYLAR_XPLANNER_ERROR_TITLE, displayMessage); 
					}
				});
			} 
			catch (Throwable t) {
				t.printStackTrace();
			}
		}
		else {
			MylarStatusHandler.log(e, message == null ? Messages.MylarXPlannerPlugin_MYLAR_XPLANNER_ERROR_TITLE : message);
		}
	}

	public static XPlannerMylarUIPlugin getDefault() {
		return INSTANCE;
	}

	/**
	 * Returns an image descriptor for the image file at the given plug-in
	 * relative path.
	 * 
	 * @param path
	 *            the path
	 * @return the image descriptor
	 */
	public static ImageDescriptor getImageDescriptor(String path) {
		return AbstractUIPlugin.imageDescriptorFromPlugin(PLUGIN_ID, path);
	}
}




/*******************************************************************************
 * Copyright (c) 2007 - 2007 CodeGear and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylar.xplanner.ui;

import java.net.Proxy;
import java.rmi.RemoteException;

import javax.security.auth.login.LoginException;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.Status;
import org.eclipse.mylar.tasks.core.AbstractAttributeFactory;
import org.eclipse.mylar.tasks.core.AbstractRepositoryConnector;
import org.eclipse.mylar.tasks.core.AbstractRepositoryTask;
import org.eclipse.mylar.tasks.core.ITask;
import org.eclipse.mylar.tasks.core.ITaskDataHandler;
import org.eclipse.mylar.tasks.core.RepositoryTaskData;
import org.eclipse.mylar.tasks.core.TaskList;
import org.eclipse.mylar.tasks.core.TaskRepository;
import org.eclipse.mylar.tasks.ui.TasksUiPlugin;
import org.eclipse.mylar.xplanner.core.XPlannerCorePlugin;
import org.eclipse.mylar.xplanner.core.service.XPlannerServer;
import org.xplanner.soap.TaskData;
import org.xplanner.soap.UserStoryData;

/**
 * @author Ravi Kumar
 * @author Helen Bershadskaya
 */
public class XPlannerOfflineTaskHandler implements ITaskDataHandler {
	private AbstractAttributeFactory attributeFactory = new XPlannerAttributeFactory();
	
	public XPlannerOfflineTaskHandler(TaskList taskList) {
		//TODO -- tasklist?
	}
	
	public RepositoryTaskData downloadTaskData(AbstractRepositoryTask repositoryTask, TaskRepository repository, Proxy proxySettings) 
		throws CoreException, LoginException {
		
		if (!(repositoryTask instanceof XPlannerTask)) {
			return null;
		}
		
		RepositoryTaskData repositoryTaskData = null;
		XPlannerTask xplannerTask = (XPlannerTask)repositoryTask;
		
		XPlannerServer server = XPlannerServerFacade.getDefault().getXPlannerServer(repository);
		repositoryTaskData = XPlannerRepositoryUtils.createRepositoryTaskData(repository, xplannerTask, server); 
		
		return repositoryTaskData;
	}

	public boolean initializeTaskData(TaskRepository repository, RepositoryTaskData data, IProgressMonitor monitor)
		throws CoreException {
		
		// currently don't create new tasks
		return false;
	}

	public AbstractAttributeFactory getAttributeFactory(String repositoryUrl, String repositoryKind, String taskKind) {
		return attributeFactory;
	}
	
	public String postTaskData(TaskRepository repository, final RepositoryTaskData repositoryTaskData) throws CoreException {
		String resultId = null;
		
		try {
			resultId = postChangesToRepository(repositoryTaskData);
		} 
		catch (Exception e) {
			throw new CoreException(new Status(Status.ERROR,
					XPlannerCorePlugin.ID, Status.ERROR, "Cannot post XPlanner task data to XPlanner server", null));
		}
		
		return resultId;
	}

	private String postChangesToRepository(RepositoryTaskData repositoryTaskData) throws CoreException {
		String error = null;
		
		TaskRepository repository = TasksUiPlugin.getRepositoryManager().getRepository(
				repositoryTaskData.getRepositoryKind(), repositoryTaskData.getRepositoryUrl());
		
		XPlannerServer server = XPlannerServerFacade.getDefault().getXPlannerServer(repository);
		if (server != null) {
			try {
				// first check if taskdata exists
				TaskData taskData = server.getTask(Integer.valueOf(repositoryTaskData.getId()).intValue());
				if (taskData != null) {
					taskData.setName(repositoryTaskData.getSummary());
					taskData.setDescription(XPlannerRepositoryUtils.getDescription(repositoryTaskData));
					taskData.setEstimatedHours(Double.valueOf(
							repositoryTaskData.getAttribute(XPlannerAttributeFactory.ATTRIBUTE_EST_HOURS_NAME).getValue()));
					taskData.setCompleted(XPlannerRepositoryUtils.isCompleted(repositoryTaskData));
					server.update(taskData);
				}
				else {
					// otherwise check if a user story exists
					UserStoryData userStory = server.getUserStory(Integer.valueOf(repositoryTaskData.getId()).intValue());
					if (userStory != null) {
						userStory.setName(repositoryTaskData.getSummary());
						userStory.setDescription(XPlannerRepositoryUtils.getDescription(repositoryTaskData));
						userStory.setActualHours(Double.valueOf(
								repositoryTaskData.getAttribute(XPlannerAttributeFactory.ATTRIBUTE_ACT_HOURS_NAME).getValue()));
						server.update(userStory);
					}
				}
			} 
			catch (NumberFormatException e) {
				XPlannerMylarUIPlugin.log(e.getCause(), "", false);
				error = e.getMessage();
			} 
			catch (RemoteException e) {
				XPlannerMylarUIPlugin.log(e.getCause(), "", false);
				error = e.getMessage();
			}
		}
		
		return error;
	}

	public RepositoryTaskData getTaskData(TaskRepository repository, String taskId) throws CoreException {
		RepositoryTaskData repositoryTaskData = null;
		
		XPlannerServer server = XPlannerServerFacade.getDefault().getXPlannerServer(repository);
		ITask existingTask = TasksUiPlugin.getTaskListManager().getTaskList().getTask(repository.getUrl(), taskId);
		if (existingTask instanceof XPlannerTask) {
			repositoryTaskData = XPlannerRepositoryUtils.createRepositoryTaskData(repository, 
				(XPlannerTask)existingTask, server);
		}
		else {
			AbstractRepositoryConnector connector = TasksUiPlugin.getRepositoryManager().getRepositoryConnector(
					repository.getKind());
			ITask newTask = connector.createTaskFromExistingKey(repository, taskId);
			repositoryTaskData = XPlannerRepositoryUtils.createRepositoryTaskData(repository, 
					(XPlannerTask)newTask, server);
		}
		return repositoryTaskData;
	}
	
}




 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.ui.editor;

import java.rmi.RemoteException;
import java.text.MessageFormat;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.mylyn.monitor.core.StatusHandler;
import org.eclipse.mylyn.tasks.core.RepositoryTaskData;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
import org.eclipse.mylyn.tasks.ui.editors.RepositoryTaskEditorInput;
import org.eclipse.mylyn.xplanner.core.service.XPlannerClient;
import org.eclipse.mylyn.xplanner.ui.*;
import org.eclipse.mylar.xplanner.ui.XPlannerServerFacade;
import org.eclipse.mylar.xplanner.ui.XPlannerTask;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.*;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Text;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorSite;
import org.eclipse.ui.forms.IManagedForm;
import org.eclipse.ui.forms.editor.FormEditor;
import org.eclipse.ui.forms.editor.FormPage;
import org.eclipse.ui.forms.widgets.*;
import org.xplanner.soap.*;
import org.eclipse.ui.forms.widgets.ScrolledForm;
import org.eclipse.ui.forms.widgets.Section;
import org.xplanner.soap.IterationData;
import org.xplanner.soap.PersonData;
import org.xplanner.soap.ProjectData;
import org.xplanner.soap.UserStoryData;

/**
 * @author Ravi Kumar


	private boolean isDirty = false;

	private XPlannerClient client;

	private UserStoryData userStoryData;


		}
		
		RepositoryTaskEditorInput  repositoryInput = (RepositoryTaskEditorInput) input;
		if (!XPlannerMylynUIPlugin.REPOSITORY_KIND.equals(repositoryInput.getRepository().getConnectorKind())) {
			return;
		}
		

		setSite(site);
		setInput(input);
		setPartName(this.input.getName());
		RepositoryTaskData taskData = repositoryInput.getTaskData();
		TaskRepository repository = TasksUiPlugin.getRepositoryManager().getRepository(taskData.getRepositoryKind(),
				taskData.getRepositoryUrl());
		try {
			client = XPlannerClientFacade.getDefault().getXPlannerClient(repository);
			String id = taskData.getId();
			if (id == null || id.trim().equals("")) {  //$NON-NLS-1$
				StatusHandler.log(Messages.XPlannerTaskEditor_NO_TASK_KEY_EXCEPTION,
					null);
			} 
			else {
				setUserStoryData(id);
			}
		}
		catch (CoreException e) {
			StatusHandler.log(e,	null);
		}
	}

	public void setUserStoryData(String key) {
		try {
			this.userStoryData = client.getUserStory(Integer.valueOf(key).intValue());
		} 
		catch (NumberFormatException e) {
			e.printStackTrace();

		return this.userStoryData;
	}
	
	public UserStoryData getUserStoryData(XPlannerTask task) throws Exception {
		UserStoryData userStoryDataFromTask = null;
		
		String key = task.getKey();
		if (key == null || key.trim().equals("")) {  //$NON-NLS-1$
			throw new Exception(Messages.XPlannerTaskEditor_NO_TASK_KEY_EXCEPTION);
		} 
		else {
			userStoryDataFromTask = server.getUserStory(Integer.valueOf(key).intValue());
		}
		
		return userStoryDataFromTask;
	}

	public boolean isDirty() {
		return isDirty;
	}

	  String projectName = NO_PROJECT_NAME;
	  
		try {
	    IterationData iteration = client.getIteration(userStoryData.getIterationId());
	    if (iteration != null) {
	      ProjectData project = client.getProject(iteration.getProjectId());
	      if (project != null) {
	        projectName = project.getName();
	      }  

	  String iterationName = NO_ITERATION_NAME;
	  
		try {
	    IterationData iteration = client.getIteration(userStoryData.getIterationId());
	    if (iteration != null) {
	      iterationName = iteration.getName();
	    }

		String acceptorName = NO_TRACKER_NAME;
		
		try {
		  PersonData personData = client.getPerson(getUserStoryData().getTrackerId());
		  if (personData != null) {
		  	acceptorName = personData.getName();
		  }




 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.ui.editor;

import org.eclipse.mylyn.monitor.core.StatusHandler;
import org.eclipse.mylyn.tasks.core.*;
import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
import org.eclipse.mylyn.tasks.ui.editors.*;
import org.eclipse.mylyn.xplanner.ui.XPlannerMylynUIPlugin;
import org.eclipse.mylyn.xplanner.ui.XPlannerTask;
import org.eclipse.mylar.tasks.ui.editors.TaskEditor;
import org.eclipse.mylar.tasks.ui.editors.TaskEditorInput;
import org.eclipse.mylar.xplanner.ui.XPlannerMylarUIPlugin;
import org.eclipse.mylar.xplanner.ui.XPlannerTask;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;


 * @author Ravi Kumar
 * @author Helen Bershadskaya
 */
public class XPlannerTaskEditorFactory extends AbstractTaskEditorFactory {

	public boolean canCreateEditorFor(AbstractTask task) {
	 * @see org.eclipse.mylar.internal.tasklist.ui.ITaskEditorFactory#canCreateEditorFor(org.eclipse.mylar.provisional.tasklist.ITask)
	 */
	public boolean canCreateEditorFor(ITask task) {
		return task instanceof XPlannerTask;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.mylar.internal.tasklist.ui.ITaskEditorFactory#createEditor(org.eclipse.mylar.internal.tasklist.ui.editors.MylarTaskEditor)
	 */
	public IEditorPart createEditor(TaskEditor parentEditor, IEditorInput editorInput) {
		IEditorPart editor = null;

		String kind = null;
		if (editorInput instanceof RepositoryTaskEditorInput) {
			RepositoryTaskData taskData = ((RepositoryTaskEditorInput)editorInput).getTaskData();
			kind = taskData.getTaskKind();
		}
		else if (editorInput instanceof TaskEditorInput) {
			AbstractTask task = ((TaskEditorInput)editorInput).getTask();
			kind = task.getTaskKind();
		}
		
	  if (XPlannerTask.Kind.TASK.toString().equals(kind)) {
		  editor = new XPlannerTaskEditor(parentEditor);
		  if (editor != null) {
		  	((XPlannerTaskEditor)editor).setParentEditor(parentEditor);
			  if (editor != null) {
			  	((XPlannerTaskEditor)editor).setParentEditor(parentEditor);
			  }
		  }
		  else if (XPlannerTask.Kind.USER_STORY.toString().equals(task.getTaskKind())) {
		  	editor = new XPlannerUserStoryEditor(parentEditor);
		  }
	  }
	  else if (XPlannerTask.Kind.USER_STORY.toString().equals(kind)) {
	  	editor = new XPlannerUserStoryEditor(parentEditor);
	  }
		
	  return editor;
	}

	public IEditorInput createEditorInput(AbstractTask task) {
	 * @see org.eclipse.mylar.internal.tasklist.ui.ITaskEditorFactory#createEditorInput(org.eclipse.mylar.provisional.tasklist.ITask)
	 */
	public IEditorInput createEditorInput(ITask task) {
		IEditorInput input = null;
		
		if (task instanceof XPlannerTask) {
			XPlannerTask xplannerTask = (XPlannerTask) task;
			
			final TaskRepository repository = TasksUiPlugin.getRepositoryManager().getRepository(
					xplannerTask.getConnectorKind(), xplannerTask.getRepositoryUrl());
			try {
				input = new RepositoryTaskEditorInput(repository, 
					xplannerTask.getTaskId(), xplannerTask.getUrl()); 
					xplannerTask.getTaskId());
			} 
			catch (Exception e) {
				StatusHandler.fail(e, Messages.XPlannerTaskEditorFactory_COULD_NOT_CREATE_EDITOR_INPUT, true);
			}
		
		}

		return input;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.mylar.internal.tasklist.ui.ITaskEditorFactory#getTitle()
	 */
	public String getTitle() {
		return Messages.XPlannerTaskEditorFactory_TITLE;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.mylar.internal.tasklist.ui.ITaskEditorFactory#notifyEditorActivationChange(org.eclipse.ui.IEditorPart)
	 */
	public void notifyEditorActivationChange(IEditorPart editor) {
	}

	/* (non-Javadoc)
	 * @see org.eclipse.mylar.internal.tasklist.ui.ITaskEditorFactory#providesOutline()
	 */
	public boolean providesOutline() {
		return true;
	}

		if (input instanceof RepositoryTaskEditorInput) {
			RepositoryTaskEditorInput existingInput = (RepositoryTaskEditorInput) input;
			return existingInput.getTaskData() != null
					&& XPlannerMylynUIPlugin.REPOSITORY_KIND.equals(existingInput.getRepository().getConnectorKind());
		} 
		return false;
	}

Lines 9-15 Link Here

(-)src/org/eclipse/mylyn/xplanner/ui/editor/messages.properties (-1 / +1 lines)
9	XPlannerUserStoryEditor_TRACKER_LABEL=Tracker:	9	XPlannerUserStoryEditor_TRACKER_LABEL=Tracker:
10	XPlannerTaskEditor_ACCEPTOR_TEXT=Acceptor :	10	XPlannerTaskEditor_ACCEPTOR_TEXT=Acceptor :
11	XPlannerTaskEditor_ESTIMATED_HOURS_TEXT=Estimated Hours :	11	XPlannerTaskEditor_ESTIMATED_HOURS_TEXT=Estimated Hours :
12	XPlannerTaskEditor_HelpSearchExpression=Mylar or XPlanner	12	XPlannerTaskEditor_HelpSearchExpression=Mylyn or XPlanner
13	XPlannerUserStoryEditor_NO_TRACKER_NAME=<no tracker name>	13	XPlannerUserStoryEditor_NO_TRACKER_NAME=<no tracker name>
14	XPlannerUserStoryEditor_PRIORITY_LABEL=Priority:	14	XPlannerUserStoryEditor_PRIORITY_LABEL=Priority:
15	XPlannerTaskEditorFactory_TITLE=XPlanner	15	XPlannerTaskEditorFactory_TITLE=XPlanner

Lines 5-11 Link Here

(-)src/org/eclipse/mylyn/xplanner/ui/editor/Messages.java (-2 / +2 lines)
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html	6	* http://www.eclipse.org/legal/epl-v10.html
7	*******************************************************************************/	7	*******************************************************************************/
8	package org.eclipse.mylar.xplanner.ui.editor;	8	package org.eclipse.mylyn.xplanner.ui.editor;
9		9
10	import org.eclipse.osgi.util.NLS;	10	import org.eclipse.osgi.util.NLS;
11		11
Lines 14-20 Link Here
14	* @author Helen Bershadskaya	14	* @author Helen Bershadskaya
15	*/	15	*/
16	public class Messages extends NLS {	16	public class Messages extends NLS {
17	private static final String BUNDLE_NAME = "org.eclipse.mylar.xplanner.ui.editor.messages"; //$NON-NLS-1$	17	private static final String BUNDLE_NAME = "org.eclipse.mylyn.xplanner.ui.editor.messages"; //$NON-NLS-1$
18		18
19	public static String XPlannerTaskEditor_ACCEPTOR_TEXT;	19	public static String XPlannerTaskEditor_ACCEPTOR_TEXT;
20		20




 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.ui.editor;

import java.text.MessageFormat;

import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.mylyn.tasks.core.*;
import org.eclipse.mylyn.tasks.ui.editors.AbstractRepositoryTaskEditor;
import org.eclipse.mylyn.xplanner.ui.*;
import org.eclipse.mylar.tasks.ui.editors.AbstractRepositoryTaskEditor;
import org.eclipse.mylar.xplanner.ui.XPlannerMylarUIPlugin;
import org.eclipse.mylar.xplanner.ui.XPlannerAttributeFactory;
import org.eclipse.mylar.xplanner.ui.XPlannerRepositoryUtils;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.*;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.*;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Text;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorSite;
import org.eclipse.ui.forms.editor.FormEditor;
import org.eclipse.ui.forms.widgets.*;
import org.eclipse.ui.forms.widgets.FormToolkit;
import org.eclipse.ui.forms.widgets.Section;

/**
 * @author Ravi Kumar

		submitButton.setEnabled(isValid);
	}

//HeB -- testing
	protected void createAttributeLayout(Composite composite) {
//		super.createAttributeLayout(composite);
//		FormToolkit toolkit = new FormToolkit(composite.getDisplay());
//		Section section = createSection(composite, Messages.XPlannerTaskEditor_ATTRIBUTES_TITLE);
//		section.setExpanded(true);
//		// Attributes Composite- this holds all the combo fields and text fields
//		Composite attributesComposite = toolkit.createComposite(section);
//		GridLayout attributesLayout = new GridLayout();
//		attributesComposite.setLayout(attributesLayout);
//		GridData attributesData = new GridData(GridData.FILL_BOTH);
//		attributesData.horizontalSpan = 1;
//		attributesData.grabExcessVerticalSpace = false;
//		attributesComposite.setLayoutData(attributesData);
//		section.setClient(attributesComposite);
	}
	
	@Override
	protected void addAttachContextButton(Composite buttonComposite, AbstractTask task) {
		// disabled, see bug 155151
	}



	@Override
	protected void createCustomAttributeLayout(Composite composite) {
		// make sure we only use one column
		if (composite.getLayout() instanceof GridLayout) {
			GridLayout layout = (GridLayout)composite.getLayout();
			layout.numColumns = 1;
		}

		createPartControlCustom(composite);
	}

	  // just in case, leave in method -- before had to get from editorInput
	public RepositoryTaskData getRepositoryTaskData() {
		return taskData;
	}

	protected void updateBug() {
		getRepositoryTaskData().setHasLocalChanges(true);
	}

	public boolean isDirty() {

	}

	public String getPluginId() {
		return XPlannerMylynUIPlugin.PLUGIN_ID;
	}
}




 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.ui.wizard;

import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.mylyn.xplanner.ui.XPlannerImages;
import org.eclipse.swt.graphics.Image;
import org.xplanner.soap.*;
import org.xplanner.soap.ProjectData;
import org.xplanner.soap.UserStoryData;


/**




 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.ui.wizard;

import java.net.MalformedURLException;
import java.net.URL;

import org.eclipse.core.runtime.*;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.tasks.ui.AbstractRepositoryConnectorUi;
import org.eclipse.mylyn.tasks.ui.wizards.AbstractRepositorySettingsPage;
import org.eclipse.mylyn.xplanner.ui.XPlannerMylynUIPlugin;
import org.eclipse.mylyn.xplanner.ui.XPlannerRepositoryUtils;
import org.eclipse.mylar.tasks.ui.wizards.AbstractRepositorySettingsPage;
import org.eclipse.mylar.xplanner.ui.XPlannerMylarUIPlugin;
import org.eclipse.mylar.xplanner.ui.XPlannerRepositoryUtils;
import org.eclipse.swt.widgets.Composite;




	public XPlannerRepositorySettingsPage(AbstractRepositoryConnectorUi connectorUi) {
		super(TITLE, DESCRIPTION, connectorUi);
		setNeedsProxy(true);
		setNeedsHttpAuth(true);
	}

	protected void createAdditionalControls(Composite parent) {

		public void run(IProgressMonitor monitor) throws CoreException {
			XPlannerRepositoryUtils.validateRepository(repository);
	
			setStatus(new Status(IStatus.OK, XPlannerMylynUIPlugin.PLUGIN_ID, IStatus.OK,
					Messages.XPlannerRepositorySettingsPage_VALID_SETTINGS_FOUND, null));
		}
	}

Lines 5-15 Link Here

(-)src/org/eclipse/mylyn/xplanner/ui/wizard/MultipleQueryPage.java (-2 / +2 lines)
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html	6	* http://www.eclipse.org/legal/epl-v10.html
7	*******************************************************************************/	7	*******************************************************************************/
8	package org.eclipse.mylar.xplanner.ui.wizard;	8	package org.eclipse.mylyn.xplanner.ui.wizard;
9		9
10	import java.util.List;	10	import java.util.List;
11		11
12	import org.eclipse.mylar.tasks.core.AbstractRepositoryQuery;	12	import org.eclipse.mylyn.tasks.core.AbstractRepositoryQuery;
13		13
14	/**	14	/**
15	* @author Ravi Kumar	15	* @author Ravi Kumar

Lines 5-13 Link Here

(-)src/org/eclipse/mylyn/xplanner/ui/wizard/ExistingXPlannerTaskWizardPage.java (-2 / +2 lines)
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html	6	* http://www.eclipse.org/legal/epl-v10.html
7	*******************************************************************************/	7	*******************************************************************************/
8	package org.eclipse.mylar.xplanner.ui.wizard;	8	package org.eclipse.mylyn.xplanner.ui.wizard;
9		9
10	import org.eclipse.mylar.internal.tasks.ui.wizards.ExistingTaskWizardPage;	10	import org.eclipse.mylyn.internal.tasks.ui.wizards.ExistingTaskWizardPage;
11		11
12	/**	12	/**
13	* @author Ravi Kumar	13	* @author Ravi Kumar




 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.ui.wizard;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.mylyn.tasks.core.*;
import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
import org.eclipse.mylyn.tasks.ui.wizards.AbstractEditQueryWizard;
import org.eclipse.mylyn.xplanner.ui.XPlannerCustomQuery;
import org.eclipse.mylar.tasks.ui.wizards.AbstractEditQueryWizard;
import org.eclipse.mylar.xplanner.ui.XPlannerCustomQuery;


/**

		}
		TasksUiPlugin.getTaskListManager().getTaskList().addQuery(query);
		
		AbstractRepositoryConnector connector = TasksUiPlugin.getRepositoryManager().getRepositoryConnector(repository.getConnectorKind());
		if (connector != null) {
			TasksUiPlugin.getSynchronizationManager().synchronize(
					connector, query, null, true);
		}
	}
	




 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.ui.wizard;

import java.rmi.RemoteException;
import java.util.HashMap;

import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.mylyn.xplanner.core.service.XPlannerClient;
import org.eclipse.mylyn.xplanner.ui.XPlannerMylynUIPlugin;
import org.xplanner.soap.*;
import org.xplanner.soap.ProjectData;
import org.xplanner.soap.UserStoryData;

/**
 * @author Ravi Kumar

		try {
			if (element instanceof IterationData) {
				IterationData iteration = (IterationData) element;
				parent = customQueryPage.getClient().getProject(iteration.getProjectId());
			}
			else if (element instanceof UserStoryData) {
				UserStoryData userStory = (UserStoryData) element;
				parent = customQueryPage.getClient().getIteration(userStory.getIterationId());
			}
		}
		catch (RemoteException e) {

	private ProjectData[] getProjects() {
		if (projects == null) {
			try {
				projects = customQueryPage.getClient().getProjects();
			}
			catch (RemoteException e) {
				e.printStackTrace();

		
		if (iterations == null) {
			try {
				iterations = customQueryPage.getClient().getIterations(project.getId());
				projectsToIterationsMap.put(project, iterations);
			}
			catch (RemoteException e) {

			userStories = iterationsToUserStoriesMap.get(iteration);
			if (userStories == null) {
				try {
					userStories = customQueryPage.getClient().getUserStories(iteration.getId());
					iterationsToUserStoriesMap.put(iteration, userStories);
				}
				catch (RemoteException e) {

		  customQueryPage.getProjectsViewer().replace(parent, index, element);
		  customQueryPage.getProjectsViewer().setChildCount(parent, getChildCount(parent));
		  try {
			  customQueryPage.getProjectsViewer().setChildCount(element, getChildCount(element));
			}
			catch (Exception e) {
				XPlannerMylynUIPlugin.log(e.getCause(), Messages.ProjectsViewerContentProvider_COULD_NOT_UPDATE_PROJECT_ELEMENT_CHILD_COUNT, true);
			}
		}  
	}

	private Object[] getXPlannerChildren(Object element) {
	  Object[] children = new Object[0];
	  
		if (element == null || element instanceof XPlannerClient) {
		  children = getProjects();	
		}
		else if (element instanceof ProjectData) {

Lines 30-32 Link Here

(-)src/org/eclipse/mylyn/xplanner/ui/wizard/messages.properties (+1 lines)
30	ExistingXPlannerTaskWizardPage_ENTER_XPLANNER_IDENTIFIER=Enter the XPlanner identifier for the iteration, user story or task.	30	ExistingXPlannerTaskWizardPage_ENTER_XPLANNER_IDENTIFIER=Enter the XPlanner identifier for the iteration, user story or task.
31	ProjectsViewerLabelProvider_NO_NAME=<no name>	31	ProjectsViewerLabelProvider_NO_NAME=<no name>
32	AbstractXPlannerQueryWizardPage_NEW_XPLANNER_QUERY=New XPlanner Query	32	AbstractXPlannerQueryWizardPage_NEW_XPLANNER_QUERY=New XPlanner Query
		33	ProjectsViewerContentProvider_COULD_NOT_UPDATE_PROJECT_ELEMENT_CHILD_COUNT=Could not update project element child count




 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.ui.wizard;
 
import java.util.HashSet;
import java.util.List;

import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jface.wizard.Wizard;
import org.eclipse.mylyn.internal.tasks.ui.TasksUiImages;
import org.eclipse.mylyn.tasks.core.*;
import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
import org.eclipse.mylar.tasks.core.TaskRepository;
import org.eclipse.mylar.tasks.ui.TasksUiPlugin;

/**
 * Wizard that allows the user to create an XPlanner query for tasks
 * server
 * 
 * @author Ravi Kumar
 * @author Helen Bershadskaya

			}
			
			// need to synchronize multiple queries with single call, otherwise get ConcurrencyModificationException
			AbstractRepositoryConnector connector = TasksUiPlugin.getRepositoryManager().getRepositoryConnector(repository.getConnectorKind());
			if (connector != null) {
				TasksUiPlugin.getSynchronizationManager().synchronize(
						connector, repository,
						new HashSet<AbstractRepositoryQuery>(queries), null, Job.LONG, 0, true);
			}
		}
		else {

  public static void addQuery(AbstractRepositoryQuery query, TaskRepository repository) {
		if (query != null) {
			TasksUiPlugin.getTaskListManager().getTaskList().addQuery(query);
			AbstractRepositoryConnector connector = TasksUiPlugin.getRepositoryManager().getRepositoryConnector(repository.getConnectorKind());
			if (connector != null) {
				TasksUiPlugin.getSynchronizationManager().synchronize(connector, query, null, true);
			}
		} 
  }




 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.ui.wizard;

import org.eclipse.jface.wizard.IWizardPage;
import org.eclipse.mylyn.tasks.core.AbstractRepositoryQuery;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.xplanner.ui.XPlannerCustomQuery;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;



/**
 * Wizard page that allows the user to select a query of tasks from the XPlanner server.
 * defined on the server.
 *
 * @author Ravi Kumar
 * @author Helen Bershadskaya




 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.ui.wizard;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.jface.wizard.Wizard;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.xplanner.ui.XPlannerCustomQuery;
import org.eclipse.mylyn.xplanner.ui.XPlannerMylynUIPlugin;


/**

		}
		catch (RuntimeException e) {
			if (e.getCause() instanceof CoreException) { 
				XPlannerMylynUIPlugin.log(e.getCause(), Messages.XPlannerQueryWizardUtils_COULD_NOT_CREATE_QUERY_PAGE_MESSAGE, true);
			}
			else {
				throw e;




 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.ui.wizard;

import org.eclipse.mylyn.tasks.core.AbstractRepositoryQuery;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.tasks.ui.search.AbstractRepositoryQueryPage;
import org.eclipse.mylyn.xplanner.ui.XPlannerCustomQuery;
import org.eclipse.ui.PlatformUI;



Lines 5-11 Link Here

(-)src/org/eclipse/mylyn/xplanner/ui/wizard/NewXPlannerTaskPage.java (-1 / +1 lines)
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html	6	* http://www.eclipse.org/legal/epl-v10.html
7	*******************************************************************************/	7	*******************************************************************************/
8	package org.eclipse.mylar.xplanner.ui.wizard;	8	package org.eclipse.mylyn.xplanner.ui.wizard;
9		9
10	import org.eclipse.jface.wizard.WizardPage;	10	import org.eclipse.jface.wizard.WizardPage;
11	import org.eclipse.swt.SWT;	11	import org.eclipse.swt.SWT;




 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.ui.wizard;
 
import java.rmi.RemoteException;
import java.util.*;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.jface.viewers.*;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.wizard.IWizardPage;
import org.eclipse.mylyn.tasks.core.AbstractRepositoryQuery;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.xplanner.core.service.XPlannerClient;
import org.eclipse.mylyn.xplanner.ui.XPlannerCustomQuery;
import org.eclipse.mylyn.xplanner.ui.XPlannerClientFacade;
import org.eclipse.mylar.xplanner.ui.XPlannerServerFacade;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.*;
import org.eclipse.swt.events.FocusEvent;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.*;
import org.xplanner.soap.*;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Text;
import org.xplanner.soap.IterationData;
import org.xplanner.soap.ProjectData;
import org.xplanner.soap.TaskData;
import org.xplanner.soap.UserStoryData;

/**
 * @author Ravi Kumar


	private static final boolean DEFAULT_SELECT_MY_CURRENT_TASKS = true;

	private final XPlannerClient client;

	private Text nameText;
	

	/**
	 * @param pageName
	 * @param title
	 * @param titleImage 
	 */
	public XPlannerCustomQueryPage(TaskRepository repository, XPlannerCustomQuery existingQuery) {
		super(repository, existingQuery);
		try {
			this.client = XPlannerClientFacade.getDefault().getXPlannerClient(repository);
			setPageComplete(false);
		}
		catch (CoreException e) {

	  setControl(dataComposite);
	}

	protected XPlannerClient getClient() {
		return this.client;
	}
	
	protected boolean isContentTypeTask() {

		projectsViewerGridData.widthHint = 200;
		
		projectsViewer.getTree().setLayoutData(projectsViewerGridData);
		projectsViewer.setInput(client);
		projectsViewer.refresh();
		projectsViewer.addSelectionChangedListener(new ISelectionChangedListener() {
			public void selectionChanged(SelectionChangedEvent e) {

		for (int contentId : contentIds) {
			try {
				if (contentIdType == XPlannerCustomQuery.ContentIdType.PROJECT) {
					selection.add(client.getProject(contentId));
				}
				else if (contentIdType == XPlannerCustomQuery.ContentIdType.ITERATION) {
					selection.add(client.getIteration(contentId));
				}
				else if (contentIdType == XPlannerCustomQuery.ContentIdType.USER_STORY) {
					selection.add(client.getUserStory(contentId));
				}
			}
			catch (RemoteException e) {

		return selection;
	}

	//TODO -- should be in client interface
	private boolean isUseAll() {
		return allTasksOrStoriesButton.getSelection();
	}

			
			// use all?
			if (!isUseAll()) {
				query.setPersonId(client.getCurrentPersonId());
			}
			else {
				query.setPersonId(XPlannerCustomQuery.INVALID_ID);

//			int userStoryId = ((UserStoryData)selectedElement).getId();
//			if (userStoryId != XPlannerCustomQuery.INVALID_ID) {
//				try {
//					userStory = client.getUserStory(userStoryId);
//				}
//				catch (RemoteException e) {
//					e.printStackTrace();

	
	public AbstractRepositoryQuery getQuery() {
		if (getExistingQuery() == null) {
			setExistingQuery(new XPlannerCustomQuery(getRepository().getUrl(), getNameText())); 
				TasksUiPlugin.getTaskListManager().getTaskList()));
		}
		
		applyChanges(getExistingQuery());

		if (isContentTypeTask()) {
			// if don't have existing query, create one
			if (getExistingQuery() == null) {
				setExistingQuery(new XPlannerCustomQuery(getRepository().getUrl(), getNameText())); 
					TasksUiPlugin.getTaskListManager().getTaskList()));
			}

			applyChanges(getExistingQuery());


		try {
			if (selectedElement instanceof ProjectData) {
				IterationData[] iterations = client.getIterations(
						((ProjectData)selectedElement).getId());
				for (IterationData iteration : iterations) {
					userStories.addAll(Arrays.asList(client.getUserStories(iteration.getId())));
				}
			}
			else if (selectedElement instanceof IterationData) {
				userStories.addAll(Arrays.asList(client.getUserStories(
						((IterationData)selectedElement).getId())));
			}
			else if (selectedElement instanceof UserStoryData) {

		}
		
		ArrayList<AbstractRepositoryQuery> queries = new ArrayList<AbstractRepositoryQuery>();
		int personId = client.getCurrentPersonId();
		for (UserStoryData userStory : userStories) {
			boolean createQuery = true;
			// if want user specific tasks, only create queries for stories with tasks for
			// that person
			if (!isUseAll()) {
				TaskData[] personUserStoryTasks = client.getUserStoryTasksForPerson(personId, userStory.getId());
				if (personUserStoryTasks == null || personUserStoryTasks.length == 0) {
					createQuery = false;
				}

				}	
				
				XPlannerCustomQuery query = new XPlannerCustomQuery(
					getRepository().getUrl(), queryName);	
					TasksUiPlugin.getTaskListManager().getTaskList());
				
				applyChanges(query);
				query.setQueryName(queryName);




<plugin>

   <extension
         id="org.eclipse.mylyn.xplanner.repository"
         name="%repositoryName"
         point="org.eclipse.mylyn.tasks.ui.repositories">

      <connectorCore
            class="org.eclipse.mylyn.xplanner.ui.XPlannerRepositoryConnector"
            id="org.eclipse.mylyn.xplanner.tasklist.repositories"
            name="%connectorName"
            type="xPlanner"/>
	  <connectorUi
         brandingIcon="icons/eview16/xplanner-logo.gif"
         class="org.eclipse.mylyn.xplanner.ui.XPlannerRepositoryUi"
         name="%connectorUiName"
         overlayIcon="icons/eview16/overlay-xplanner.gif"/>
            
      <taskListFactory
            class="org.eclipse.mylyn.xplanner.ui.XPlannerTaskListFactory"
            id="org.eclipse.mylyn.xplanner.tasklist.taskListFactory"/>
   </extension>  
   
   <extension point="org.eclipse.ui.decorators">
      <decorator
            class="org.eclipse.mylar.xplanner.ui.XPlannerTaskDecorator"
            id="org.eclipse.mylar.xplanner.ui.decorator.task"
            label="%decoratorLabelTask"
            lightweight="true"
            state="true">
         <description>%decoratorDescriptionTask</description>
         <enablement>
            <objectClass name="org.eclipse.mylar.tasks.core.ITaskListElement"/>
         </enablement>
      </decorator>
   </extension>
   <!--
   <extension
         point="org.eclipse.ui.editors">
      <editor
            class="org.eclipse.mylyn.xplanner.ui.XPlannerTaskEditor"
            default="false"
            id="org.eclipse.mylyn.xplanner.task.editor"
            name="%editorNameTask"/>
   </extension>
   -->
   <extension
         point="org.eclipse.mylyn.tasks.ui.editors">
      <editorFactory
            class="org.eclipse.mylyn.xplanner.ui.editor.XPlannerTaskEditorFactory"
            id="org.eclipse.mylyn.xplanner.ui.XPlannerTaskEditorFactory"/>
   </extension>

</plugin>

Lines 1-8 Link Here

(-)plugin.properties (-3 / +3 lines)
1	bundleName=Mylar Connector for XPlanner	1	bundleName=Mylyn XPlanner UI Plug-in
2	bundleVendor=Eclipse.org	2	bundleVendor=Eclipse.org
3	repositoryName=XPlanner Repository	3	repositoryName=XPlanner Repository
4	connectorName=XPlanner Repository Connector	4	connectorName=XPlanner Repository Connector
5	connectorUiName=XPlanner Repository UI	5	connectorUiName=XPlanner Repository UI
6	decoratorLabelTask=Mylar XPlanner Task Decorator	6	decoratorLabelTask=Mylyn XPlanner Task Decorator
7	decoratorDescriptionTask=Mylar XPlanner Task Decorator	7	decoratorDescriptionTask=Mylyn XPlanner Task Decorator
8	editorNameTask=XPlanner Task Editor	8	editorNameTask=XPlanner Task Editor

Lines 22-28 Link Here

(-).project (+2 lines)
22	</buildCommand>	22	</buildCommand>
23	</buildSpec>	23	</buildSpec>
24	<natures>	24	<natures>
		25	<nature>org.eclipse.jem.workbench.JavaEMFNature</nature>
25	<nature>org.eclipse.pde.PluginNature</nature>	26	<nature>org.eclipse.pde.PluginNature</nature>
26	<nature>org.eclipse.jdt.core.javanature</nature>	27	<nature>org.eclipse.jdt.core.javanature</nature>
		28	<nature>org.eclipse.jem.beaninfo.BeanInfoNature</nature>
27	</natures>	29	</natures>
28	</projectDescription>	30	</projectDescription>




Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: %bundleName
Bundle-SymbolicName: org.eclipse.mylyn.xplanner.ui;singleton:=true
Bundle-Version: 2.0.0.qualifier
Bundle-Activator: org.eclipse.mylyn.xplanner.ui.XPlannerMylynUIPlugin
Bundle-Vendor: %bundleVendor
Bundle-Localization: plugin
Require-Bundle: org.eclipse.ui,

 org.eclipse.search,
 org.eclipse.ui.forms,
 org.eclipse.help,
 org.eclipse.mylyn.xplanner.core,
 org.eclipse.mylyn.tasks.ui,
 org.eclipse.mylyn.context.core,
 org.eclipse.mylyn.tasks.core,
 org.eclipse.mylyn,
 org.eclipse.mylyn.monitor.core
Eclipse-LazyStart: true
Export-Package: org.eclipse.mylyn.xplanner.ui,
 org.eclipse.mylyn.xplanner.ui.wizard




/*******************************************************************************
 * Copyright (c) 2007 - 2007 CodeGear and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.ui;

import java.util.*;

import org.eclipse.mylyn.tasks.core.*;
import org.w3c.dom.Element;
import org.w3c.dom.Node;

/**
 * @author Ravi Kumar 
 * @author Helen Bershadskaya 
 */
public class XPlannerTaskListFactory extends AbstractTaskListFactory {

	private static final String TOKEN_SEPARATOR = ";"; //$NON-NLS-1$

	private static final String KEY_XPLANNER = "XPlanner"; //$NON-NLS-1$

	private static final String KEY_CUSTOM = "XPlannerCustom"; //$NON-NLS-1$

	private static final String KEY_XPLANNER_QUERY = KEY_XPLANNER + KEY_QUERY;

	private static final String KEY_XPLANNER_CUSTOM = KEY_XPLANNER + KEY_CUSTOM + KEY_QUERY;

	private static final String KEY_XPLANNER_ITEM = "XPlannerItem"; //$NON-NLS-1$

	private static final String KEY_QUERY_CONTENT_ID_TYPE = "QueryContentIdType"; //$NON-NLS-1$

	private static final String KEY_QUERY_IS_TASKS = "QueryIsTasks"; //$NON-NLS-1$

	private static final String KEY_QUERY_CONTENT_ID = "QueryConentId"; //$NON-NLS-1$

	private static final String KEY_QUERY_PERSON_ID = "QueryPersonId"; //$NON-NLS-1$

	private static final String KEY_QUERY_MY_CURRENT_TASKS = "QueryMyCurrentTasks"; //$NON-NLS-1$

	public boolean canReadQuery(Node node) {
		return node.getNodeName().equals(KEY_XPLANNER_QUERY) || node.getNodeName().equals(KEY_XPLANNER_CUSTOM);
	}

	public boolean canCreateElementFor(AbstractRepositoryQuery category) {
		return category instanceof XPlannerCustomQuery;
	}

	public boolean canCreateElementFor(AbstractTask task) {
		return task instanceof XPlannerTask;
	}

	@Override
	public AbstractRepositoryQuery createQuery(String repositoryUrl, String queryString, String label, Element element) {
		AbstractRepositoryQuery query = null;
		query = new XPlannerCustomQuery(repositoryUrl, label);
		initializeQuery((XPlannerCustomQuery)query, element);

		return query;
	}

	private void initializeQuery(XPlannerCustomQuery query, Element element) {
		String myCurrentTasks = element.getAttribute(KEY_QUERY_MY_CURRENT_TASKS);
		if (myCurrentTasks != null && Boolean.valueOf(myCurrentTasks)) {
			query.setMyCurrentTasks(true);
		}
		else {
			// selected content type
			String contentIdType = element.getAttribute(KEY_QUERY_CONTENT_ID_TYPE);
			if (contentIdType != null) {
				query.setContentIdType((XPlannerCustomQuery.ContentIdType.valueOf(contentIdType)));
			}

			// use tasks?
			String useTasks = element.getAttribute(KEY_QUERY_IS_TASKS);
			if (useTasks != null) {
			  query.setUseTasks(Boolean.valueOf(useTasks));
			}  
			
			// use all?
			String personId = element.getAttribute(KEY_QUERY_PERSON_ID);
			if (personId != null) {
			  query.setPersonId(Integer.valueOf(personId));
			}  
			
			// content id
			String contentIds = element.getAttribute(KEY_QUERY_CONTENT_ID);
			if (contentIds != null) {
				query.setContentIds(decodeIds(contentIds));
			}
		}	
	}
	
	private String encodeIds(List<Integer> contentIds) {
		StringBuilder result = new StringBuilder();
		for (Iterator<Integer> iter = contentIds.iterator(); iter.hasNext();) {
			Integer id = iter.next();
			result.append(id);
			if (iter.hasNext()) {
				result.append(TOKEN_SEPARATOR);
			}
		}

		return result.toString();
	}

	private List<Integer> decodeIds(String encoded) {
		if (encoded == null) {
			return XPlannerCustomQuery.INVALID_IDS;
		}
		
		StringTokenizer tokens = new StringTokenizer(encoded, TOKEN_SEPARATOR);
		ArrayList<Integer> ids = new ArrayList<Integer>();
		while (tokens.hasMoreTokens()) {
			ids.add(Integer.valueOf(tokens.nextToken()));
		}
		
		return ids;
	}

	
	public Set<String> getQueryElementNames() {
		Set<String> names = new HashSet<String>();
		names.add(KEY_XPLANNER_CUSTOM);
		return names;
	}

	public void setAdditionalAttributes(AbstractRepositoryQuery query, Element node) {
//		String queryTagName = getQueryTagNameForElement(query);

//		node.setAttribute(KEY_NAME, query.getSummary());
//		node.setAttribute(KEY_QUERY_STRING, query.getUrl());
//		node.setAttribute(KEY_REPOSITORY_URL, query.getRepositoryUrl());

		XPlannerCustomQuery xplannerCustomQuery = (XPlannerCustomQuery) query;
		
		// name
//		String queryName = xplannerCustomQuery.getQueryName();
//		node.setAttribute(KEY_QUERY_NAME, queryName);
		
		boolean isMyCurrentTasks = xplannerCustomQuery.isMyCurrentTasks();
		if (isMyCurrentTasks) {
			// show only my current tasks
			node.setAttribute(KEY_QUERY_MY_CURRENT_TASKS, Boolean.toString(true));
		}
		else {
			// don't show only my current tasks
			node.setAttribute(KEY_QUERY_MY_CURRENT_TASKS, Boolean.toString(false));
			
			// selected content type
			String contentIdType = xplannerCustomQuery.getContentIdType().name();
			node.setAttribute(KEY_QUERY_CONTENT_ID_TYPE, contentIdType);

			// is tasks
			boolean isUseTasks = xplannerCustomQuery.isUseTasks();
			node.setAttribute(KEY_QUERY_IS_TASKS, Boolean.toString(isUseTasks));
			
			// content id
			List<Integer> contentIds = xplannerCustomQuery.getContentIds();
			node.setAttribute(KEY_QUERY_CONTENT_ID, encodeIds(contentIds));
			
			// person id
			int personId = xplannerCustomQuery.getPersonId();
			node.setAttribute(KEY_QUERY_PERSON_ID, Integer.toString(personId));
		}
//		
//		for (AbstractTask hit : query.getHits()) {
//				try {
//					Element element = null;
//					for (ITaskListExternalizer externalizer : super.getDelegateExternalizers()) {
//						if (externalizer.canCreateElementFor(hit)) {
//							element = createQueryHitElement(hit, doc, node);
//						}
//					}
//					if (element == null) {
//						createQueryHitElement(hit, doc, node);
//					}	
//				} 
//				catch (Exception e) {
//					StatusManager.log(e, e.getMessage());
//				}
//		}
//		parent.appendChild(node);
//		return node;
	}

//	public Element createQueryElement(AbstractRepositoryQuery query, Document doc, Element parent) {
//		String queryTagName = getQueryTagNameForElement(query);
//		Element node = doc.createElement(queryTagName);
//
//		node.setAttribute(KEY_NAME, query.getSummary());
//		node.setAttribute(KEY_QUERY_STRING, query.getUrl());
//		node.setAttribute(KEY_REPOSITORY_URL, query.getRepositoryUrl());
//
//		XPlannerCustomQuery xplannerCustomQuery = (XPlannerCustomQuery) query;
//		
//		// name
//		String queryName = xplannerCustomQuery.getQueryName();
//		node.setAttribute(KEY_QUERY_NAME, queryName);
//		
//		boolean isMyCurrentTasks = xplannerCustomQuery.isMyCurrentTasks();
//		if (isMyCurrentTasks) {
//			// show only my current tasks
//			node.setAttribute(KEY_QUERY_MY_CURRENT_TASKS, Boolean.toString(true));
//		}
//		else {
//			// don't show only my current tasks
//			node.setAttribute(KEY_QUERY_MY_CURRENT_TASKS, Boolean.toString(false));
//			
//			// selected content type
//			String contentIdType = xplannerCustomQuery.getContentIdType().name();
//			node.setAttribute(KEY_QUERY_CONTENT_ID_TYPE, contentIdType);
//
//			// is tasks
//			boolean isUseTasks = xplannerCustomQuery.isUseTasks();
//			node.setAttribute(KEY_QUERY_IS_TASKS, Boolean.toString(isUseTasks));
//			
//			// content id
//			List<Integer> contentIds = xplannerCustomQuery.getContentIds();
//			node.setAttribute(KEY_QUERY_CONTENT_ID, encodeIds(contentIds));
//			
//			// person id
//			int personId = xplannerCustomQuery.getPersonId();
//			node.setAttribute(KEY_QUERY_PERSON_ID, Integer.toString(personId));
//		}
//		
//		for (AbstractTask hit : query.getHits()) {
//				try {
//					Element element = null;
//					for (ITaskListExternalizer externalizer : super.getDelegateExternalizers()) {
//						if (externalizer.canCreateElementFor(hit)) {
//							element = createQueryHitElement(hit, doc, node);
//						}
//					}
//					if (element == null) {
//						createQueryHitElement(hit, doc, node);
//					}	
//				} 
//				catch (Exception e) {
//					StatusManager.log(e, e.getMessage());
//				}
//		}
//		parent.appendChild(node);
//		return node;
//	}

	@Override
	public String getTaskElementName() {
		return KEY_XPLANNER_ITEM;
	}

	@Override
	public AbstractTask createTask(String repositoryUrl, String taskId, String summary, Element element) {
		return new XPlannerTask(repositoryUrl, taskId, summary);
	}

	@Override
	public String getQueryElementName(AbstractRepositoryQuery query) {
		if (query instanceof XPlannerCustomQuery) {
			return KEY_XPLANNER_CUSTOM;
		}
		return ""; //$NON-NLS-1$
	}

	@Override
	public boolean canCreate(AbstractRepositoryQuery category) {
		return category instanceof XPlannerCustomQuery;
	}

	@Override
	public boolean canCreate(AbstractTask task) {
		return task instanceof XPlannerTask;
	}

}




/*******************************************************************************
 * Copyright (c) 2007 - 2007 CodeGear and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.ui;

import java.net.*;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.mylyn.monitor.core.StatusHandler;
import org.eclipse.mylyn.tasks.core.ITaskRepositoryListener;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
import org.eclipse.mylyn.xplanner.core.XPlannerClientManager;
import org.eclipse.mylyn.xplanner.core.XPlannerCorePlugin;
import org.eclipse.mylyn.xplanner.core.service.XPlannerClient;
import org.eclipse.mylyn.xplanner.core.service.exceptions.AuthenticationException;
import org.eclipse.mylyn.xplanner.core.service.exceptions.ServiceUnavailableException;

/**
 * This class acts as a layer of indirection between clients in this project and
 * the server API implemented by the XPlanner Dashboard, and also abstracts some
 * Mylyn implementation details. It initializes an XPlannerClient object and serves
 * as the central location to get a reference to it.
 * 
 * @author Ravi Kumar 
 * @author Helen Bershadskaya 
 * 
 */
public class XPlannerClientFacade implements ITaskRepositoryListener {

	private XPlannerClientManager clientManager = null;

	private static XPlannerClientFacade instance = null;

	public XPlannerClientFacade() {
		TasksUiPlugin.getRepositoryManager().addListener(this);
		clientManager = XPlannerCorePlugin.getDefault().getClientManager();
	}

	/**
	 * Lazily creates client.
	 */
	public XPlannerClient getXPlannerClient(TaskRepository repository) throws CoreException {
		try {
			XPlannerRepositoryUtils.checkRepositoryValidated(repository.getUrl());
			String serverHostname = getServerHost(repository);
		XPlannerClient client = clientManager.getClient(serverHostname);
//TODO: add this check back once the listeners for client property change are hooked up
// Also handle the case when serviceDelegate in the cachedClient is null

//			if (client == null) {
				client = clientManager.createClient(serverHostname, repository.getUrl(), false,
						repository.getUserName(), repository.getPassword(), false, repository.getProxy(),
						repository.getHttpUser(), repository.getHttpPassword());
				clientManager.addClient(client);
//			}
			if (client == null) {
				throw new ServiceUnavailableException(serverHostname + " " + repository.getUrl()); //$NON-NLS-1$
			}
			return client;
		} 
		catch (CoreException ce) {
			StatusHandler.log(Messages.XPlannerClientFacade_SERVER_CONNECTION_ERROR, this);
			throw ce;
		}
		catch (ServiceUnavailableException sue) {
			throw sue;
		} 
		catch (RuntimeException e) {
			StatusHandler.log(Messages.XPlannerClientFacade_SERVER_CONNECTION_ERROR, this);
			throw e;
		}
	}

	public static XPlannerClientFacade getDefault() {
		if (instance == null) {
			instance = new XPlannerClientFacade();
		}
		return instance;
	}

	public void logOutFromAll() {
		try {
			XPlannerClient[] allClients = clientManager.getAllClients();
			for (int i = 0; i < allClients.length; i++) {
				allClients[i].logout();
			}
		} catch (Exception e) {
			// ignore
		}
	}

	public void repositoriesRead() {
		// ignore
	}

	public void repositoryAdded(TaskRepository repository) {
		if (repository.getConnectorKind().equals(XPlannerMylynUIPlugin.REPOSITORY_KIND)) {
			try {
				getXPlannerClient(repository);
			}
			catch (CoreException e) {
				StatusHandler.log(e.getMessage(), this); 
			}
		}
	}

	public void repositoryRemoved(TaskRepository repository) {
		if (repository.getConnectorKind().equals(XPlannerMylynUIPlugin.REPOSITORY_KIND)) {
			String serverHostname = getServerHost(repository);
			XPlannerClient client = clientManager.getClient(serverHostname);
			removeClient(client);
			XPlannerRepositoryUtils.removeValidatedRepositoryUrl(repository.getUrl());
		}
	}
	
	public void repositorySettingsChanged(TaskRepository repository) {
		repositoryRemoved(repository);
		repositoryAdded(repository);
	}

	public void refreshClientSettings(TaskRepository repository) {
		String serverHostname = getServerHost(repository);
		XPlannerClient client = clientManager.getClient(serverHostname);
		if (client != null) {
			client.refreshDetails();
		}
	}
	
	
	private void removeClient(XPlannerClient client) {
		if (client != null) {
			client.logout();
			clientManager.removeClient(client);
		}
	} 

	/**
	 * Validate the server URL and user credentials
	 * @param serverUrl Location of the XPlanner Server
	 * @param user Username
	 * @param password Password
	 * @param proxy Proxy
	 * @param httpUser http user name
	 * @param httpPassword http password
	 * @return String describing validation failure or null if the details are valid
	 */
	public void validateServerAndCredentials(String serverUrl, String user, 
		String password, Proxy proxy, String httpUser, String httpPassword) throws Exception {
		
		XPlannerRepositoryUtils.removeValidatedRepositoryUrl(serverUrl);
		clientManager.testConnection(serverUrl, user, password, proxy, httpUser, httpPassword);
		XPlannerRepositoryUtils.addValidatedRepositoryUrl(serverUrl);
	}

	private static String getServerHost(TaskRepository repository) {
		try {
			return new URL(repository.getUrl()).getHost();
		} catch (MalformedURLException ex) {
			throw new RuntimeException(Messages.XPlannerClientFacade_INVALID_URL_EXCEPTION+repository.getUrl(), ex);
		}
	}
	
	/**
	 * TODO: refactor
	 */
	public static void handleConnectionException(Exception e) {
		if (e instanceof ServiceUnavailableException) {
			StatusHandler.fail(e, Messages.XPlannerClientFacade_CONNECTION_FAILURE_ERROR
					+ Messages.XPlannerClientFacade_NETWORK_CONNECTION_FAILURE,
					true);
		} 
		else if (e instanceof AuthenticationException) {
			StatusHandler.fail(e, Messages.XPlannerClientFacade_AUTHENTICATION_FAILED
					+ Messages.XPlannerClientFacade_USERNAME_PASSWORD_ERROR, true);
		} 
		else if (e instanceof RuntimeException) {
			StatusHandler.fail(e, Messages.XPlannerClientFacade_NO_REPOSITORY_FOUND
					+ Messages.XPlannerClientFacade_VERIFY_VALID_REPOSITORY, true);
		} 
		else {
			StatusHandler.fail(e, Messages.XPlannerClientFacade_COULD_NOT_CONNECT_TO_REPOSITORY
					+ Messages.XPlannerClientFacade_CHECK_CREDENTIALS, true);
		}
	}	
}




/*******************************************************************************
 * Copyright (c) 2007 - 2007 CodeGear and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.ui;

import java.net.Proxy;
import java.rmi.RemoteException;
import java.util.HashSet;
import java.util.Set;

import javax.security.auth.login.LoginException;

import org.eclipse.core.runtime.*;
import org.eclipse.mylyn.tasks.core.*;
import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
import org.eclipse.mylyn.xplanner.core.XPlannerCorePlugin;
import org.eclipse.mylyn.xplanner.core.service.XPlannerClient;
import org.xplanner.soap.TaskData;
import org.xplanner.soap.UserStoryData;

/**
 * @author Ravi Kumar
 * @author Helen Bershadskaya
 */
public class XPlannerTaskDataHandler extends AbstractTaskDataHandler {
	private AbstractAttributeFactory attributeFactory = new XPlannerAttributeFactory();
	
	public XPlannerTaskDataHandler(TaskList taskList) {
		//TODO -- tasklist?
	}
	
	public RepositoryTaskData downloadTaskData(AbstractTask repositoryTask, TaskRepository repository, Proxy proxySettings) 
		throws CoreException, LoginException {
		
		if (!(repositoryTask instanceof XPlannerTask)) {
			return null;
		}
		
		RepositoryTaskData repositoryTaskData = null;
		XPlannerTask xplannerTask = (XPlannerTask)repositoryTask;
		
		XPlannerClient client = XPlannerClientFacade.getDefault().getXPlannerClient(repository);
		repositoryTaskData = XPlannerRepositoryUtils.createRepositoryTaskData(repository, xplannerTask, client); 
		
		return repositoryTaskData;
	}

	public boolean initializeTaskData(TaskRepository repository, RepositoryTaskData data, IProgressMonitor monitor)
		throws CoreException {
		
		// currently don't create new tasks
		return false;
	}

	public AbstractAttributeFactory getAttributeFactory(String repositoryUrl, String repositoryKind, String taskKind) {
		return attributeFactory;
	}
	
	public AbstractAttributeFactory getAttributeFactory(RepositoryTaskData taskData) {
		return getAttributeFactory(taskData.getRepositoryUrl(), taskData.getRepositoryKind(), taskData.getTaskKind());
	}

	public String postTaskData(TaskRepository repository, RepositoryTaskData taskData, IProgressMonitor monitor)
		throws CoreException {
		String resultId = null;
		
		try {
			resultId = postChangesToRepository(taskData);
		} 
		catch (Exception e) {
			throw new CoreException(new Status(Status.ERROR,
					XPlannerCorePlugin.ID, Status.ERROR, Messages.XPlannerOfflineTaskHandler_CANNOT_POST_DATA_TO_SERVER, null));
		}
		
		return resultId;
	}

	private String postChangesToRepository(RepositoryTaskData repositoryTaskData) throws CoreException {
		String error = null;
		
		TaskRepository repository = TasksUiPlugin.getRepositoryManager().getRepository(
				repositoryTaskData.getRepositoryKind(), repositoryTaskData.getRepositoryUrl());
		
		XPlannerClient client = XPlannerClientFacade.getDefault().getXPlannerClient(repository);
		if (client != null) {
			try {
				// first check if taskdata exists
				TaskData taskData = client.getTask(Integer.valueOf(repositoryTaskData.getId()).intValue());
				if (taskData != null) {
					taskData.setName(repositoryTaskData.getSummary());
					taskData.setDescription(XPlannerRepositoryUtils.getDescription(repositoryTaskData));
					taskData.setEstimatedHours(Double.valueOf(
							repositoryTaskData.getAttribute(XPlannerAttributeFactory.ATTRIBUTE_EST_HOURS_NAME).getValue()));
					taskData.setCompleted(XPlannerRepositoryUtils.isCompleted(repositoryTaskData));
					client.update(taskData);
				}
				else {
					// otherwise check if a user story exists
					UserStoryData userStory = client.getUserStory(Integer.valueOf(repositoryTaskData.getId()).intValue());
					if (userStory != null) {
						userStory.setName(repositoryTaskData.getSummary());
						userStory.setDescription(XPlannerRepositoryUtils.getDescription(repositoryTaskData));
						userStory.setActualHours(Double.valueOf(
								repositoryTaskData.getAttribute(XPlannerAttributeFactory.ATTRIBUTE_ACT_HOURS_NAME).getValue()));
						client.update(userStory);
					}
				}
			} 
			catch (NumberFormatException e) {
				XPlannerMylynUIPlugin.log(e.getCause(), "", false); //$NON-NLS-1$
				error = e.getMessage();
			} 
			catch (RemoteException e) {
				XPlannerMylynUIPlugin.log(e.getCause(), "", false); //$NON-NLS-1$
				error = e.getMessage();
			}
		}
		
		return error;
	}

	public RepositoryTaskData getTaskData(TaskRepository repository, String taskId, IProgressMonitor monitor)
		throws CoreException {
		
		return XPlannerRepositoryUtils.createRepositoryTaskData(repository, taskId);
	}
	
	public Set<String> getSubTaskIds(RepositoryTaskData taskData) {
		Set<String> subIds = new HashSet<String>();
		RepositoryTaskAttribute attribute = taskData.getAttribute(XPlannerAttributeFactory.Attribute.SUBTASK_IDS.getCommonAttributeKey());
		if (attribute != null) {
			subIds.addAll(attribute.getValues());
		}
		return subIds;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 - 2007 CodeGear and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.ui;

import org.eclipse.core.runtime.*;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.mylyn.monitor.core.StatusHandler;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.plugin.AbstractUIPlugin;
import org.osgi.framework.BundleContext;

/**
 * @author Ravi Kumar 
 * @author Helen Bershadskaya 
 */
public class XPlannerMylynUIPlugin extends AbstractUIPlugin {

	private static XPlannerMylynUIPlugin INSTANCE;

	public static final String PLUGIN_ID = "org.eclipse.mylyn.xplanner.ui"; //$NON-NLS-1$

	public final static String REPOSITORY_KIND = "xplanner"; //$NON-NLS-1$

	public final static String XPLANNER_CLIENT_LABEL = Messages.MylynXPlannerPlugin_CLIENT_LABEL;

	public final static String TITLE_MESSAGE_DIALOG = Messages.MylynXPlannerPlugin_CLIENT_DIALOG_TITLE;

	public static final String DELIM_URL_PREFIX = "/do/view/"; //$NON-NLS-1$

	public final static String DELIM_URL_SUFFIX = "?oid="; //$NON-NLS-1$

	public final static String TASK_URL_PREFIX = DELIM_URL_PREFIX + "task" + DELIM_URL_SUFFIX; //$NON-NLS-1$

	public final static String USER_STORY_URL_PREFIX = DELIM_URL_PREFIX + "userstory" + DELIM_URL_SUFFIX; //$NON-NLS-1$

	public final static String ITERATION_URL_PREFIX = DELIM_URL_PREFIX + "iteration" + DELIM_URL_SUFFIX; //$NON-NLS-1$

	public final static IStatus NO_LICENSE_STATUS = new Status(IStatus.INFO, XPlannerMylynUIPlugin.PLUGIN_ID,
			0, Messages.MylynXPlannerPlugin_NOT_AVAILABLE_IN_SKU, null);

	public XPlannerMylynUIPlugin() {
		INSTANCE = this;
	}

	public void stop(BundleContext context) throws Exception {
		super.stop(context);
		INSTANCE = null;
		XPlannerClientFacade.getDefault().logOutFromAll();
	}

	public static void log(final Throwable e, final String message, boolean informUser) {
		if (Platform.isRunning() && informUser) {
			try {
				PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
					public void run() {
						Shell shell = null;
						if (PlatformUI.getWorkbench() != null
								&& PlatformUI.getWorkbench().getActiveWorkbenchWindow() != null) {
							shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
						}
						String displayMessage = message == null ? e.getMessage() : message + "\n" + e.getMessage(); //$NON-NLS-1$
						MessageDialog.openError(shell, Messages.MylynXPlannerPlugin_XPLANNER_ERROR_TITLE, displayMessage); 
					}
				});
			} 
			catch (Throwable t) {
				t.printStackTrace();
			}
		}
		else {
			StatusHandler.log(e, message == null ? Messages.MylynXPlannerPlugin_XPLANNER_ERROR_TITLE : message);
		}
	}

	public static XPlannerMylynUIPlugin getDefault() {
		return INSTANCE;
	}

	/**
	 * Returns an image descriptor for the image file at the given plug-in
	 * relative path.
	 * 
	 * @param path
	 *            the path
	 * @return the image descriptor
	 */
	public static ImageDescriptor getImageDescriptor(String path) {
		return AbstractUIPlugin.imageDescriptorFromPlugin(PLUGIN_ID, path);
	}
}




/*******************************************************************************
 * Copyright (c) 2007 - 2007 CodeGear and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.ui;

import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.xplanner.ui.wizard.NewXPlannerQueryWizard;

/**
 * @author Ravi Kumar
 * @author Helen Bershadskaya
 */
public class MylynXPlannerUtils {
	private MylynXPlannerUtils() {
		
	}
	
	public static void addNewMyTasksQuery(TaskRepository repository,
		String name) {
		
		XPlannerCustomQuery myTasksQuery = 
			new XPlannerCustomQuery(repository.getUrl(), name);
		
		myTasksQuery.setMyCurrentTasks(true);
		NewXPlannerQueryWizard.addQuery(myTasksQuery, repository);
	}
			
}




 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.tests;

import junit.framework.TestCase;

import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.mylyn.tasks.core.*;
import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
import org.eclipse.mylyn.xplanner.core.service.XPlannerClient;
import org.eclipse.mylyn.xplanner.ui.XPlannerRepositoryConnector;
import org.eclipse.mylyn.xplanner.ui.XPlannerTask;
import org.eclipse.mylar.xplanner.ui.XPlannerTask;
import org.xplanner.soap.TaskData;
import org.xplanner.soap.UserStoryData;

public class XPlannerRepositoryConnectorTest extends TestCase {
	private static XPlannerClient client;
	
	protected void setUp() throws Exception {
		super.setUp();
		if (client == null) { // only create data once per run
			client = XPlannerTestUtils.getXPlannerClient();
			XPlannerTestUtils.clearTestData(client);
			XPlannerTestUtils.setUpTestData(client);
		}
	}


	public void testCreateTaskFromExistingKeyForUserStory() throws Exception {
		TaskRepository repository = XPlannerTestUtils.getRepository();
		AbstractRepositoryConnector connector = 
			TasksUiPlugin.getRepositoryManager().getRepositoryConnector(repository.getConnectorKind());
		UserStoryData testUserStory = XPlannerTestUtils.findTestUserStory(client);

		assertTrue(testUserStory != null);
		
		AbstractTask repositoryTask = 
			connector.createTaskFromExistingId(repository, "" + testUserStory.getId(), new NullProgressMonitor());
		
		assertTrue(repositoryTask instanceof XPlannerTask);
		assertTrue(((XPlannerTask)repositoryTask).getSummary().equals(testUserStory.getName()));

	public void testCreateTaskFromExistingKeyForTask() throws Exception {
		TaskRepository repository = XPlannerTestUtils.getRepository();
		AbstractRepositoryConnector connector = 
			TasksUiPlugin.getRepositoryManager().getRepositoryConnector(repository.getConnectorKind());
		TaskData testTask = XPlannerTestUtils.findTestTask(client);

		assertTrue(testTask != null);
		
		AbstractTask repositoryTask = 
			connector.createTaskFromExistingId(repository, "" + testTask.getId(), new NullProgressMonitor());
		
		assertTrue(repositoryTask instanceof XPlannerTask);
		assertTrue(((XPlannerTask)repositoryTask).getSummary().equals(testTask.getName()));

	public void testUpdateTaskDetailsCompleted() throws Exception {
		TaskRepository repository = XPlannerTestUtils.getRepository();
		AbstractRepositoryConnector connector = 
			TasksUiPlugin.getRepositoryManager().getRepositoryConnector(repository.getConnectorKind());
		
		assertTrue(connector instanceof XPlannerRepositoryConnector);
		XPlannerRepositoryConnector xplannerConnector = (XPlannerRepositoryConnector) connector;
		TaskData testTask = XPlannerTestUtils.findTestTask(client);
		XPlannerTask repositoryTask = XPlannerTestUtils.getTestXPlannerTask(client);

		assertTrue(testTask != null);
		assertTrue(repositoryTask != null);

		
		// mark testTask as completed
		testTask.setCompleted(true);
		client.update(testTask);
		
		xplannerConnector.updateTaskDetails(repository.getUrl(), repositoryTask, testTask, false);
		assertTrue(repositoryTask.isCompleted());
		
		//restore testTask's completion state
		testTask.setCompleted(originalCompleted);
		client.update(testTask);
	}

}




 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.tests;

import java.rmi.RemoteException;
import java.util.Set;

import junit.framework.TestCase;

import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.mylyn.tasks.core.*;
import org.eclipse.mylyn.tasks.ui.TaskFactory;
import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
import org.eclipse.mylyn.tasks.ui.search.SearchHitCollector;
import org.eclipse.mylyn.xplanner.core.service.XPlannerClient;
import org.eclipse.mylyn.xplanner.ui.XPlannerCustomQuery;
import org.eclipse.mylar.xplanner.core.service.XPlannerServer;
import org.eclipse.mylar.xplanner.ui.XPlannerCustomQuery;

public class XPlannerCustomQueryTest extends TestCase {

	private static XPlannerClient client;
	
	protected void setUp() throws Exception {
		super.setUp();
		if (client == null) { // only create data once per run
			client = XPlannerTestUtils.getXPlannerClient();
			XPlannerTestUtils.clearTestData(client);
			XPlannerTestUtils.setUpTestData(client);
		}
	}


	public void testNoItemsQuery() {
		TaskList taskList = XPlannerTestUtils.getTaskList();
		XPlannerCustomQuery query = new XPlannerCustomQuery(XPlannerTestUtils.SERVER_URL,
			"no items");
		query.setPersonId(-1);
		 
		Set<AbstractTask> hits = performTestQuery(taskList, query);
		assert(hits.size() == 0);
	}

	public void testAdminItemsQuery() {
		TaskList taskList = XPlannerTestUtils.getTaskList();
		XPlannerCustomQuery query = new XPlannerCustomQuery(
			XPlannerTestUtils.SERVER_URL,	"admin items");
		try {
			query.setPersonId(XPlannerTestUtils.getAdminId(client));
			Set<AbstractTask> hits = performTestQuery(taskList, query);
			assert(hits.size() == 1);
		}
		catch (RemoteException e) {

		
	}

	private Set<AbstractTask> performTestQuery(TaskList taskList, XPlannerCustomQuery query) {
		TaskRepository repository = XPlannerTestUtils.getRepository();
		AbstractRepositoryConnector connector = 
			TasksUiPlugin.getRepositoryManager().getRepositoryConnector(repository.getConnectorKind());
		
		TaskFactory taskFactory = new TaskFactory(repository, false, false);
		SearchHitCollector collector = new SearchHitCollector(taskList, repository, query, taskFactory);
		connector.performQuery(query, repository, new NullProgressMonitor(), collector);
		
		Set<AbstractTask> hits = collector.getTasks();
		return hits;
	}
	




 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.tests;

import junit.framework.TestCase;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.mylyn.tasks.core.*;
import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
import org.eclipse.mylyn.xplanner.core.service.XPlannerClient;
import org.eclipse.mylyn.xplanner.ui.*;
import org.eclipse.mylar.xplanner.ui.XPlannerAttributeFactory;
import org.eclipse.mylar.xplanner.ui.XPlannerRepositoryUtils;
import org.eclipse.mylar.xplanner.ui.XPlannerTask;
import org.xplanner.soap.TaskData;
import org.xplanner.soap.UserStoryData;

public class XPlannerRepositoryUtilsTest extends TestCase {

	private static XPlannerClient client;
	
	protected void setUp() throws Exception {
		super.setUp();
		if (client == null) { // only create data once per run
			client = XPlannerTestUtils.getXPlannerClient();
			XPlannerTestUtils.clearTestData(client);
			XPlannerTestUtils.setUpTestData(client);
		}
	}



	public void testSetupTaskAttributes() {
		try {
			TaskData taskData =  XPlannerTestUtils.findTestTask(client);
			XPlannerTask task = XPlannerTestUtils.getTestXPlannerTask(client);
			RepositoryTaskData repositoryTaskData = 
				TasksUiPlugin.getTaskDataManager().getNewTaskData(task.getRepositoryUrl(),
				task.getTaskId()); 
			XPlannerRepositoryUtils.setupTaskAttributes(taskData, repositoryTaskData);
			
			assert(taskData.getDescription().equals(


	public void testSetupUserStoryAttributes() {
		try {
			UserStoryData userStory =  XPlannerTestUtils.findTestUserStory(client);
			XPlannerTask task = XPlannerTestUtils.getTestXPlannerUserStoryTask(client);
			RepositoryTaskData repositoryTaskData = 
				TasksUiPlugin.getTaskDataManager().getNewTaskData(task.getRepositoryUrl(),
					task.getTaskId()); 
			XPlannerRepositoryUtils.setupUserStoryAttributes(userStory, repositoryTaskData);
			
			assert(userStory.getName().equals(

	}

	public void testIsCompleted() {
		XPlannerTask xplannerTask;
		try {
			XPlannerTask task = XPlannerTestUtils.getTestXPlannerTask(client);
			RepositoryTaskData repositoryTaskData = 
				TasksUiPlugin.getTaskDataManager().getNewTaskData(task.getRepositoryUrl(),
					task.getTaskId()); 
			assert(!XPlannerRepositoryUtils.isCompleted(repositoryTaskData));
		}
		catch (Exception e) {

Lines 5-11 Link Here

(-)src/org/eclipse/mylyn/xplanner/tests/AllXPlannerTests.java (-2 / +2 lines)
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html	6	* http://www.eclipse.org/legal/epl-v10.html
7	*******************************************************************************/	7	*******************************************************************************/
8	package org.eclipse.mylar.xplanner.tests;	8	package org.eclipse.mylyn.xplanner.tests;
9		9
10	import junit.framework.Test;	10	import junit.framework.Test;
11	import junit.framework.TestSuite;	11	import junit.framework.TestSuite;
Lines 17-23 Link Here
17	public class AllXPlannerTests {	17	public class AllXPlannerTests {
18		18
19	public static Test suite() {	19	public static Test suite() {
20	TestSuite suite = new TestSuite("Test for mylar.xplanner.tests");	20	TestSuite suite = new TestSuite("Test for mylyn.xplanner.tests");
21		21
22	// $JUnit-BEGIN$	22	// $JUnit-BEGIN$
23	suite.addTestSuite(XPlannerRepositoryUtilsTest.class);	23	suite.addTestSuite(XPlannerRepositoryUtilsTest.class);




 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/
package org.eclipse.mylyn.xplanner.tests;

import java.rmi.RemoteException;
import java.util.Calendar;
import java.util.Date;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.mylyn.tasks.core.*;
import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
import org.eclipse.mylyn.xplanner.core.service.XPlannerClient;
import org.eclipse.mylyn.xplanner.ui.*;
import org.xplanner.soap.*;
import org.eclipse.mylar.xplanner.ui.XPlannerMylarUIPlugin;
import org.eclipse.mylar.xplanner.ui.XPlannerServerFacade;
import org.eclipse.mylar.xplanner.ui.XPlannerTask;
import org.xplanner.soap.IterationData;
import org.xplanner.soap.PersonData;
import org.xplanner.soap.ProjectData;
import org.xplanner.soap.TaskData;
import org.xplanner.soap.UserStoryData;

/**
 * Requirements for tests:

		
		repository = TasksUiPlugin.getRepositoryManager().getRepository(SERVER_URL);
		if (repository == null) {
			repository = new TaskRepository(XPlannerMylynUIPlugin.REPOSITORY_KIND, SERVER_URL);
			repository.setAuthenticationCredentials(USER, PASSWORD);
			TasksUiPlugin.getRepositoryManager().addRepository(repository, TasksUiPlugin.getDefault().getRepositoriesFilePath());
			TasksUiPlugin.getTaskListManager().resetTaskList();

			repository, TasksUiPlugin.getDefault().getRepositoriesFilePath());
	}
	
	public static XPlannerClient getXPlannerClient() throws CoreException {
		TaskRepository repository = getRepository();

		return XPlannerClientFacade.getDefault().getXPlannerClient(repository);
	}
	
	public static void clearTestData(XPlannerClient client) throws Exception {
		if (client != null) {
			ProjectData testProject = findTestProject(client);
			if (testProject != null) {
				client.removeProject(testProject.getId());
			}
		}
	}
	
	public static void setUpTestData(XPlannerClient client) throws Exception {
		if (client != null) {
			ProjectData testProject = getTestProject(client);
			IterationData testIteration = getTestIteration(client, testProject);
			UserStoryData testUserStory = getTestUserStory(client, testIteration);
			getTestTask(client, testUserStory);
		}
	}
	
	public static ProjectData findTestProject(XPlannerClient client) throws RemoteException {
		ProjectData testProject = null;
		
		ProjectData[] projects = client.getProjects();
		for (int i = 0; i < projects.length && testProject == null; i++) {
			if (TEST_PROJECT_NAME.equals(projects[i].getName())) {
				testProject = projects[i];

		return testProject;
	}
	
	private static ProjectData getTestProject(XPlannerClient client) throws RemoteException {
		ProjectData testProject = findTestProject(client);
		
		if (testProject == null) {
			testProject = new ProjectData();
			testProject.setName(TEST_PROJECT_NAME);
			testProject.setDescription(TEST_PROJECT_NAME);
			testProject = client.addProject(testProject);
		}
		
		return testProject;
	}

	public static IterationData findTestIteration(XPlannerClient client, ProjectData testProject) throws RemoteException {
		IterationData testIteration = null;

		IterationData[] iterations = client.getIterations(testProject.getId());
		if (iterations != null) {
			for (int i = 0; i < iterations.length && testIteration == null; i++) {
				if (TEST_ITERATION_NAME.equals(iterations[i].getName())) {

		return testIteration;
	}
	
	private static IterationData getTestIteration(XPlannerClient client, ProjectData project) throws RemoteException {
		IterationData testIteration = findTestIteration(client, project);
		
		if (testIteration == null) {
			testIteration = new IterationData();

    	testIteration.setEndDate(endDate);
    	testIteration.setName(TEST_ITERATION_NAME);
    	testIteration.setDescription(TEST_ITERATION_NAME);
    	testIteration = client.addIteration(testIteration);
    	
			client.refreshDetails();
		}
		
		return testIteration;
	}

	public static UserStoryData findTestUserStory(XPlannerClient client, IterationData testIteration) throws RemoteException {
		UserStoryData testUserStory = null;
		
		UserStoryData[] userStories = client.getUserStories(testIteration.getId());
		if (userStories != null) {
			for (int i = 0; i < userStories.length && testUserStory == null; i++) {
				if (TEST_USER_STORY_NAME.equals(userStories[i].getName())) {

		return testUserStory;
	}
	
	private static UserStoryData getTestUserStory(XPlannerClient client, IterationData iteration) throws RemoteException {
		UserStoryData testUserStory = findTestUserStory(client, iteration);
		
		if (testUserStory == null) {
			testUserStory = new UserStoryData();

			testUserStory.setRemainingHours(0);
			testUserStory.setPriority(5);
		  
			testUserStory = client.addUserStory(testUserStory);
			
			client.refreshDetails();
		}
		
		return testUserStory;
	}

	public static TaskData findTestTask(XPlannerClient client, UserStoryData testUserStory) throws RemoteException {
		TaskData testTask = null;
		
		TaskData[] tasks = client.getTasks(testUserStory.getId());
		for (int i = 0; i < tasks.length && testTask == null; i++) {
			if (TEST_TASK_NAME.equals(tasks[i].getName())) {
				testTask = tasks[i];

		return testTask;
	}

	public static int getAdminId(XPlannerClient client) throws RemoteException {
		int adminId = -1;
		
		PersonData[] people = client.getPeople();
		for (int i = 0; i < people.length && adminId == -1; i++) {
			if (USER.equals(people[i].getUserId())) {
				adminId = people[i].getId();

		return adminId;
	}
	
	private static TaskData getTestTask(XPlannerClient client, UserStoryData userStory) throws RemoteException {
		TaskData testTask = findTestTask(client, userStory);
		
		if (testTask == null) {
			testTask = new TaskData();

    	testTask.setEstimatedHours(24.0);
    	testTask.setActualHours(7.0);
    	testTask.setDispositionName("planned");  //$NON-NLS-1$
    	testTask.setAcceptorId(getAdminId(client));
    	
    	Calendar taskCreate = Calendar.getInstance();
    	taskCreate.setTime(new Date());
		  testTask.setCreatedDate(taskCreate);
		  
			testTask = client.addTask(testTask);
			
			client.refreshDetails();
		}
		
		return testTask;

		return taskList;
	}
	
	public static UserStoryData findTestUserStory(XPlannerClient client) throws RemoteException {
		UserStoryData testUserStory = null;
		
		ProjectData testProject = findTestProject(client);
		if (testProject != null) {
			IterationData testIteration = findTestIteration(client, testProject);
			if (testIteration != null) {
				testUserStory = findTestUserStory(client, testIteration);
			}
		}
		
		return testUserStory;
	}
	
	public static TaskData findTestTask(XPlannerClient client) throws RemoteException {
		TaskData testTask = null;

		UserStoryData testUserStory = findTestUserStory(client);
		if (testUserStory != null) {
			testTask = findTestTask(client, testUserStory);
		}
		
		return testTask;

	/**
	 * setUpTestData() needs to be called before this method
	 */
	public static XPlannerTask getTestXPlannerTask(XPlannerClient client) throws Exception {
		TaskRepository repository = getRepository();
		AbstractRepositoryConnector connector = 
			TasksUiPlugin.getRepositoryManager().getRepositoryConnector(repository.getConnectorKind());
		
		TaskData testTask = findTestTask(client);
		AbstractTask task = connector.createTaskFromExistingId(repository, "" + testTask.getId(), new NullProgressMonitor());
		return (XPlannerTask) task;
	}

	/**
	 * setUpTestData() needs to be called before this method
	 */
	public static XPlannerTask getTestXPlannerUserStoryTask(XPlannerClient client) throws Exception {
		TaskRepository repository = getRepository();
		AbstractRepositoryConnector connector = 
			TasksUiPlugin.getRepositoryManager().getRepositoryConnector(repository.getConnectorKind());
		
		UserStoryData testUserStory = findTestUserStory(client);
		AbstractTask task = connector.createTaskFromExistingId(repository, "" + testUserStory.getId(), new NullProgressMonitor());
		return (XPlannerTask) task;
	}
	




Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: @bundleName
Bundle-SymbolicName: org.eclipse.mylyn.xplanner.tests
Bundle-Version: 1.1.0.qualifer
Bundle-Localization: plugin
Require-Bundle: org.junit,
 org.eclipse.core.runtime,
 org.eclipse.ui,
 org.eclipse.mylyn.tasks.core,
 org.eclipse.mylyn.tasks.ui,
 org.eclipse.mylyn.xplanner.core,
 org.eclipse.mylyn.xplanner.ui,
 org.eclipse.search

Return to bug 130240

Lines 226-238 Link Here

(-)src/org/xplanner/soap/XPlanner/XPlannerProxy.java (-2 / +2 lines)
226	xPlanner.removeUserStory(id);	226	xPlanner.removeUserStory(id);
227	}	227	}
228		228
229	public org.xplanner.soap.TaskData[] getCurrentTasksForPerson(int personId) throws java.rmi.RemoteException, org.eclipse.mylar.xplanner.wsdl.db.QueryException{	229	public org.xplanner.soap.TaskData[] getCurrentTasksForPerson(int personId) throws java.rmi.RemoteException, org.eclipse.mylyn.xplanner.wsdl.db.QueryException{
230	if (xPlanner == null)	230	if (xPlanner == null)
231	_initXPlannerProxy();	231	_initXPlannerProxy();
232	return xPlanner.getCurrentTasksForPerson(personId);	232	return xPlanner.getCurrentTasksForPerson(personId);
233	}	233	}
234		234
235	public org.xplanner.soap.TaskData[] getPlannedTasksForPerson(int personId) throws java.rmi.RemoteException, org.eclipse.mylar.xplanner.wsdl.db.QueryException{	235	public org.xplanner.soap.TaskData[] getPlannedTasksForPerson(int personId) throws java.rmi.RemoteException, org.eclipse.mylyn.xplanner.wsdl.db.QueryException{
236	if (xPlanner == null)	236	if (xPlanner == null)
237	_initXPlannerProxy();	237	_initXPlannerProxy();
238	return xPlanner.getPlannedTasksForPerson(personId);	238	return xPlanner.getPlannedTasksForPerson(personId);

Lines 1-10 Link Here

(-)feature.xml (-15 / +8 lines)
1	<?xml version="1.0" encoding="UTF-8"?>	1	<?xml version="1.0" encoding="UTF-8"?>
2	<feature	2	<feature
3	id="org.eclipse.mylar.xplanner_feature"	3	id="org.eclipse.mylyn.xplanner_feature"
4	label="%featureLabel"	4	label="%featureLabel"
5	version="2.0.0.qualifier"	5	version="2.0.0.qualifier"
6	provider-name="Eclipse.org"	6	provider-name="Eclipse.org"
7	plugin="org.eclipse.mylar.xplanner.ui">	7	plugin="org.eclipse.mylyn.xplanner.ui">
8		8
9	<description>	9	<description>
10	%featureDescription	10	%featureDescription
Lines 214-244 Link Here
214	</license>	214	</license>
215		215
216	<url>	216	<url>
217	<update label="Mylar for Eclipse 3.2" url="http://download.eclipse.org/technology/mylar/update-site/e3.2"/>	217	<update label="Mylyn for Eclipse 3.3" url="http://download.eclipse.org/tools/mylyn/update/e3.3"/>
218	</url>	218	</url>
219		219
220	<requires>	220	<requires>
221	<import plugin="org.eclipse.ui"/>	221	<import feature="org.eclipse.mylyn_feature" version="2.0.0.v20070514" match="equivalent"/>
222	<import plugin="org.eclipse.ui.forms"/>	222	<import feature="org.eclipse.rcp" version="3.2.2.r322_v20070104-8pcviKVqd8J7C1U" match="compatible"/>
223	<import plugin="org.eclipse.core.runtime"/>	223	<import feature="org.eclipse.platform" version="3.2.2.r322_v20070119-RQghndJN8IM0MsK" match="compatible"/>
224	<import plugin="org.eclipse.mylar.context.core"/>
225	<import plugin="org.eclipse.mylar.tasks.ui"/>
226	<import plugin="org.eclipse.mylar.tasks.core"/>
227	<import plugin="org.eclipse.search"/>
228	<import plugin="org.eclipse.mylar.monitor.core"/>
229	<import plugin="org.eclipse.mylar" version="2.0.0.v20070216" match="greaterOrEqual"/>
230	<import feature="org.eclipse.mylar_feature" version="2.0.0.v20070216" match="greaterOrEqual"/>
231	</requires>	224	</requires>
232		225
233	<plugin	226	<plugin
234	id="org.eclipse.mylar.xplanner.ui"	227	id="org.eclipse.mylyn.xplanner.core"
235	download-size="0"	228	download-size="0"
236	install-size="0"	229	install-size="0"
237	version="0.0.0"	230	version="0.0.0"
238	unpack="false"/>	231	unpack="false"/>
239		232
240	<plugin	233	<plugin
241	id="org.eclipse.mylar.xplanner.core"	234	id="org.eclipse.mylyn.xplanner.ui"
242	download-size="0"	235	download-size="0"
243	install-size="0"	236	install-size="0"
244	version="0.0.0"	237	version="0.0.0"

Lines 5-17 Link Here

(-)src/org/eclipse/mylyn/xplanner/core/XPlannerServerListener.java (-2 / +2 lines)
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html	6	* http://www.eclipse.org/legal/epl-v10.html
7	*******************************************************************************/	7	*******************************************************************************/
8	package org.eclipse.mylar.xplanner.core;	8	package org.eclipse.mylyn.xplanner.core;
9		9
10	/**	10	/**
11	* @author Ravi Kumar	11	* @author Ravi Kumar
12	* @author Helen Bershadskaya	12	* @author Helen Bershadskaya
13	*/	13	*/
14	import org.eclipse.mylar.xplanner.core.service.XPlannerServer;	14	import org.eclipse.mylyn.xplanner.core.service.XPlannerServer;
15		15
16		16
17	public interface XPlannerServerListener {	17	public interface XPlannerServerListener {

Removed Link Here

(-)src/org/eclipse/mylyn/xplanner/core/ServerManager.java (-260 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 - 2007 CodeGear and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*******************************************************************************/
8	package org.eclipse.mylar.xplanner.core;
9
10	/**
11	* @author Ravi Kumar
12	* @author Helen Bershadskaya
13	*/
14	import java.io.BufferedInputStream;
15	import java.io.BufferedOutputStream;
16	import java.io.File;
17	import java.io.FileInputStream;
18	import java.io.FileOutputStream;
19	import java.io.IOException;
20	import java.io.ObjectInputStream;
21	import java.io.ObjectOutputStream;
22	import java.net.URL;
23	import java.rmi.RemoteException;
24	import java.util.ArrayList;
25	import java.util.HashMap;
26	import java.util.Iterator;
27	import java.util.List;
28	import java.util.Map;
29
30	import org.apache.axis.AxisFault;
31	import org.eclipse.mylar.xplanner.core.service.CachedXPlannerServer;
32	import org.eclipse.mylar.xplanner.core.service.XPlannerServer;
33	import org.eclipse.mylar.xplanner.core.service.exceptions.AuthenticationException;
34	import org.eclipse.mylar.xplanner.core.service.exceptions.ServiceUnavailableException;
35	import org.xml.sax.SAXException;
36
37
38	/**
39	* @author Helen Bershadskaya
40	* @author Ravi Kumar
41	*/
42	public class ServerManager {
43
44	private final File cacheLocation;
45
46	private Map<String, XPlannerServer> serverByName = new HashMap<String, XPlannerServer>();
47
48	// TODO Use a decent listener list
49	private List<XPlannerServerListener> listeners = new ArrayList<XPlannerServerListener>();
50
51	public ServerManager(File cacheLocation) {
52	this.cacheLocation = cacheLocation;
53	}
54
55	protected void start() {
56	// On first load the cache may not exist
57	cacheLocation.mkdirs();
58
59	File[] servers = this.cacheLocation.listFiles();
60	for (int i = 0; i < servers.length; i++) {
61	File serverCache = servers[i];
62	File serverFile = new File(serverCache, "server.ser"); //$NON-NLS-1$
63
64	ObjectInputStream ois = null;
65	try {
66	ois = new ObjectInputStream(new BufferedInputStream(new FileInputStream(serverFile)));
67	XPlannerServer server = (XPlannerServer) ois.readObject();
68	// TODO reconnect the services depending on user preferences
69
70	serverByName.put(serverCache.getName(), server);
71	ois.close();
72	} catch (IOException e) {
73	e.printStackTrace();
74	} catch (ClassNotFoundException e) {
75	e.printStackTrace();
76	} finally {
77	if (ois != null) {
78	try {
79	ois.close();
80	} catch (IOException e) {
81	}
82	}
83	}
84	}
85	}
86
87	protected void stop() {
88	for (Iterator<XPlannerServer> iServers = serverByName.values().iterator(); iServers.hasNext();) {
89	XPlannerServer server = iServers.next();
90
91	ObjectOutputStream oos = null;
92	try {
93	File cacheDir = new File(cacheLocation, server.getName());
94	cacheDir.mkdirs();
95
96	oos = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(new File(cacheDir, "server.ser")))); //$NON-NLS-1$
97	oos.writeObject(server);
98	} catch (IOException e) {
99	e.printStackTrace();
100	} finally {
101	if (oos != null) {
102	try {
103	oos.close();
104	} catch (IOException e) {
105	}
106	}
107	}
108	}
109	}
110
111	/**
112	* Tests the connection to a server. If the URL is invalid ot the username
113	* and password are invalid this method will return with a exceptions carrying
114	* the failure reason.
115	* @param baseUrl Base URL of the XPlanner installation
116	* @param username username to connect with
117	* @param password Password to connect with
118	* @return Short string describing the server information
119	* @throws AuthenticationException URL was valid but username and password were incorrect
120	* @throws ServiceUnavailableException URL was not valid
121	*/
122	public String testConnection(String baseUrl, String username, String password) throws AuthenticationException, ServiceUnavailableException {
123	if (baseUrl == null \|\| baseUrl.length() == 0) {
124	throw new AuthenticationException(Messages.ServerManager_SERVER_URL_CANNOT_BE_EMPTY);
125	}
126
127	XPlannerServer server = null;
128
129	try {
130	new URL(baseUrl).openConnection(); // tests url validity
131
132	server = createServer("Connection Test", baseUrl, false, username, password); //$NON-NLS-1$
133
134	server.getTask(-1);
135	}
136	catch (RemoteException re) {
137	if (re instanceof AxisFault) {
138	String message = re.getMessage().trim();
139	if (message.startsWith("(401)")) { //$NON-NLS-1$
140	message = Messages.ServerManager_INVALID_USERNAME_PASSWORD;
141	}
142	else if (re.getCause() instanceof SAXException) {
143	message = ""; //$NON-NLS-1$
144	}
145	else {
146	message = message.startsWith(";") ? message.substring(1).trim() : message; //$NON-NLS-1$
147	}
148	throw new AuthenticationException(message);
149	}
150	else {
151	throw new ServiceUnavailableException(re.getMessage());
152	}
153	}
154	catch (Exception e) {
155	throw new ServiceUnavailableException(e.getMessage());
156	}
157	finally {
158	if (server != null) {
159	removeServer(server);
160	}
161	}
162
163	return "XPlanner"; //$NON-NLS-1$
164	}
165
166	public XPlannerServer getServer(String name) {
167	return (XPlannerServer) serverByName.get(name);
168	}
169
170	public XPlannerServer[] getAllServers() {
171	return (XPlannerServer[]) serverByName.values().toArray(new XPlannerServer[serverByName.size()]);
172	}
173
174	public XPlannerServer createServer(String name, String baseUrl, boolean hasSlowConnection, String username, String password) {
175	if (baseUrl.charAt(baseUrl.length() - 1) == '/') {
176	baseUrl = baseUrl.substring(0, baseUrl.length() - 1);
177	}
178
179	XPlannerServer server = new CachedXPlannerServer(name, baseUrl, hasSlowConnection, username, password);
180	return server;
181	}
182
183	public void addServer(XPlannerServer server) {
184	if (serverByName.containsKey(server.getName())) {
185	// TODO: add this check back once the listeners for server property change are hooked up
186	// Also handle the case when serviceDelegate in the cachedServer is null
187	// throw new RuntimeException("A server with that name already exists");
188	removeServer(server);
189	}
190	serverByName.put(server.getName(), server);
191	fireServerAddded(server);
192	}
193
194	public void removeServer(XPlannerServer server) {
195	serverByName.remove(server.getName());
196
197	File serverCache = new File(this.cacheLocation, server.getName());
198	if (serverCache.exists()) {
199	recursiveDelete(serverCache);
200	}
201	fireServerRemoved(server);
202	}
203
204	/**
205	* TODO need to make this a bit smarter. Perhaps have an object to hold connectino info
206	* @param name
207	* @param baseURL
208	* @param username
209	* @param password
210	*/
211	public void updateServerDetails(String name, String baseURL, boolean hasSlowConnection, String username, String password) {
212	CachedXPlannerServer server = (CachedXPlannerServer) serverByName.get(name);
213	// TODO we should really have a modify event
214
215	fireServerRemoved(server);
216
217	// TODO need to flush the server cache since we are possibly a different person
218	server.setBaseURL(baseURL);
219	server.setSlowConnection(hasSlowConnection);
220	server.setCurrentUserName(username);
221	server.setCurrentPassword(password);
222
223	fireServerAddded(server);
224	}
225
226	public void addServerListener(XPlannerServerListener listener) {
227	listeners.add(listener);
228	}
229
230	public void removeServerListener(XPlannerServerListener listener) {
231	listeners.remove(listener);
232	}
233
234	private void fireServerRemoved(XPlannerServer server) {
235	for (Iterator<XPlannerServerListener> iListeners = listeners.iterator(); iListeners.hasNext();) {
236	XPlannerServerListener listener = (XPlannerServerListener)iListeners.next();
237	listener.serverRemoved(server);
238	}
239	}
240
241	private void fireServerAddded(XPlannerServer server) {
242	for (Iterator<XPlannerServerListener> iListeners = listeners.iterator(); iListeners.hasNext();) {
243	XPlannerServerListener listener = (XPlannerServerListener)iListeners.next();
244	listener.serverAdded(server);
245	}
246	}
247
248	private void recursiveDelete(File baseFile) {
249	if (baseFile.isFile()) {
250	baseFile.delete();
251	} else {
252	File[] children = baseFile.listFiles();
253	for (int i = 0; i < children.length; i++) {
254	File file = children[i];
255	recursiveDelete(file);
256	}
257	baseFile.delete();
258	}
259	}
260	}

Lines 1-13 Link Here

(-)build.properties (-6 / +1 lines)
1	source.. = src/, src-gen/	1	source.. = src/, src-gen/
2	output.. = bin/	2	output.. = bin/
3	source.plugin.jar = src/,\
4	src-gen/
5	output.plugin.jar = bin/
6	bin.includes = .,\	3	bin.includes = .,\
7	lib/,\	4	lib/,\
8	META-INF/,\	5	META-INF/,\
9	schema/,\	6	schema/,\
10	plugin.jar,\
11	plugin.properties,\	7	plugin.properties,\
12	plugin.xml,\	8	plugin.xml,\
13	about.html	9	about.html
Lines 15-21 Link Here
15	lib/,\	11	lib/,\
16	META-INF/,\	12	META-INF/,\
17	schema/,\	13	schema/,\
18	plugin.jar,\
19	plugin.properties,\	14	plugin.properties,\
20	plugin.xml,\	15	plugin.xml,\
21	about.html,\	16	about.html,\

Lines 1-9 Link Here

(-)schema/serviceProviderFactory.exsd (-3 / +3 lines)
1	<?xml version='1.0' encoding='UTF-8'?>	1	<?xml version='1.0' encoding='UTF-8'?>
2	<!-- Schema file written by PDE -->	2	<!-- Schema file written by PDE -->
3	<schema targetNamespace="org.eclipse.mylar.xplanner.core">	3	<schema targetNamespace="org.eclipse.mylyn.xplanner.core">
4	<annotation>	4	<annotation>
5	<appInfo>	5	<appInfo>
6	<meta.schema plugin="org.eclipse.mylar.xplanner.core" id="serviceProviderFactory" name="Service provider factory"/>	6	<meta.schema plugin="org.eclipse.mylyn.xplanner.core" id="serviceProviderFactory" name="Service provider factory"/>
7	</appInfo>	7	</appInfo>
8	<documentation>	8	<documentation>
9	[Enter description of this extension point.]	9	[Enter description of this extension point.]
Lines 65-71 Link Here
65	Class that implements the XPlanner Core service interface	65	Class that implements the XPlanner Core service interface
66	</documentation>	66	</documentation>
67	<appInfo>	67	<appInfo>
68	<meta.attribute kind="java" basedOn=":org.eclipse.mylar.xplanner.core.service.XPlannerServiceFactory"/>	68	<meta.attribute kind="java" basedOn=":org.eclipse.mylyn.xplanner.core.service.XPlannerServiceFactory"/>
69	</appInfo>	69	</appInfo>
70	</annotation>	70	</annotation>
71	</attribute>	71	</attribute>

Lines 373-379 Link Here

(-)src/org/xplanner/soap/XPlanner/XPlannerSoapBindingStub.java (-11 / +12 lines)
373	oper.setUse(org.apache.axis.constants.Use.ENCODED);	373	oper.setUse(org.apache.axis.constants.Use.ENCODED);
374	oper.addFault(new org.apache.axis.description.FaultDesc(	374	oper.addFault(new org.apache.axis.description.FaultDesc(
375	new javax.xml.namespace.QName("http://xplanner.org:8080/soap/XPlanner", "fault"), //$NON-NLS-1$ //$NON-NLS-2$	375	new javax.xml.namespace.QName("http://xplanner.org:8080/soap/XPlanner", "fault"), //$NON-NLS-1$ //$NON-NLS-2$
376	"org.eclipse.mylar.xplanner.wsdl.db.QueryException", //$NON-NLS-1$	376	"org.eclipse.mylyn.xplanner.wsdl.db.QueryException", //$NON-NLS-1$
377	new javax.xml.namespace.QName("http://db.xplanner.technoetic.com", "QueryException"), //$NON-NLS-1$ //$NON-NLS-2$	377	new javax.xml.namespace.QName("http://db.xplanner.technoetic.com", "QueryException"), //$NON-NLS-1$ //$NON-NLS-2$
378	true	378	true
379	));	379	));
Lines 390-396 Link Here
390	oper.setUse(org.apache.axis.constants.Use.ENCODED);	390	oper.setUse(org.apache.axis.constants.Use.ENCODED);
391	oper.addFault(new org.apache.axis.description.FaultDesc(	391	oper.addFault(new org.apache.axis.description.FaultDesc(
392	new javax.xml.namespace.QName("http://xplanner.org:8080/soap/XPlanner", "fault"), //$NON-NLS-1$ //$NON-NLS-2$	392	new javax.xml.namespace.QName("http://xplanner.org:8080/soap/XPlanner", "fault"), //$NON-NLS-1$ //$NON-NLS-2$
393	"org.eclipse.mylar.xplanner.wsdl.db.QueryException", //$NON-NLS-1$	393	"org.eclipse.mylyn.xplanner.wsdl.db.QueryException", //$NON-NLS-1$
394	new javax.xml.namespace.QName("http://db.xplanner.technoetic.com", "QueryException"), //$NON-NLS-1$ //$NON-NLS-2$	394	new javax.xml.namespace.QName("http://db.xplanner.technoetic.com", "QueryException"), //$NON-NLS-1$ //$NON-NLS-2$
395	true	395	true
396	));	396	));
Lines 540-553 Link Here
540	java.lang.Class simplelistdf = org.apache.axis.encoding.ser.SimpleListDeserializerFactory.class;	540	java.lang.Class simplelistdf = org.apache.axis.encoding.ser.SimpleListDeserializerFactory.class;
541	qName = new javax.xml.namespace.QName("http://db.xplanner.technoetic.com", "QueryException"); //$NON-NLS-1$ //$NON-NLS-2$	541	qName = new javax.xml.namespace.QName("http://db.xplanner.technoetic.com", "QueryException"); //$NON-NLS-1$ //$NON-NLS-2$
542	cachedSerQNames.add(qName);	542	cachedSerQNames.add(qName);
543	cls = org.eclipse.mylar.xplanner.wsdl.db.QueryException.class;	543	cls = org.eclipse.mylyn.xplanner.wsdl.db.QueryException.class;
544	cachedSerClasses.add(cls);	544	cachedSerClasses.add(cls);
545	cachedSerFactories.add(beansf);	545	cachedSerFactories.add(beansf);
546	cachedDeserFactories.add(beandf);	546	cachedDeserFactories.add(beandf);
547		547
548	qName = new javax.xml.namespace.QName("http://domain.soap.xplanner.technoetic.com", "DomainData"); //$NON-NLS-1$ //$NON-NLS-2$	548	qName = new javax.xml.namespace.QName("http://domain.soap.xplanner.technoetic.com", "DomainData"); //$NON-NLS-1$ //$NON-NLS-2$
549	cachedSerQNames.add(qName);	549	cachedSerQNames.add(qName);
550	cls = org.eclipse.mylar.xplanner.wsdl.soap.domain.DomainData.class;	550	cls = org.eclipse.mylyn.xplanner.wsdl.soap.domain.DomainData.class;
551	cachedSerClasses.add(cls);	551	cachedSerClasses.add(cls);
552	cachedSerFactories.add(beansf);	552	cachedSerFactories.add(beansf);
553	cachedDeserFactories.add(beandf);	553	cachedDeserFactories.add(beandf);
Lines 1391-1397 Link Here
1391	_call.setSOAPActionURI(""); //$NON-NLS-1$	1391	_call.setSOAPActionURI(""); //$NON-NLS-1$
1392	_call.setSOAPVersion(org.apache.axis.soap.SOAPConstants.SOAP11_CONSTANTS);	1392	_call.setSOAPVersion(org.apache.axis.soap.SOAPConstants.SOAP11_CONSTANTS);
1393	_call.setOperationName(new javax.xml.namespace.QName("http://soap.xplanner.technoetic.com", "getTask")); //$NON-NLS-1$ //$NON-NLS-2$	1393	_call.setOperationName(new javax.xml.namespace.QName("http://soap.xplanner.technoetic.com", "getTask")); //$NON-NLS-1$ //$NON-NLS-2$
1394		1394	_call.setTimeout(new Integer(30000));
		1395
1395	setRequestHeaders(_call);	1396	setRequestHeaders(_call);
1396	setAttachments(_call);	1397	setAttachments(_call);
1397	try { java.lang.Object _resp = _call.invoke(new java.lang.Object[] {new java.lang.Integer(id)});	1398	try { java.lang.Object _resp = _call.invoke(new java.lang.Object[] {new java.lang.Integer(id)});
Lines 1608-1614 Link Here
1608	}	1609	}
1609	}	1610	}
1610		1611
1611	public org.xplanner.soap.TaskData[] getCurrentTasksForPerson(int personId) throws java.rmi.RemoteException, org.eclipse.mylar.xplanner.wsdl.db.QueryException {	1612	public org.xplanner.soap.TaskData[] getCurrentTasksForPerson(int personId) throws java.rmi.RemoteException, org.eclipse.mylyn.xplanner.wsdl.db.QueryException {
1612	if (super.cachedEndpoint == null) {	1613	if (super.cachedEndpoint == null) {
1613	throw new org.apache.axis.NoEndPointException();	1614	throw new org.apache.axis.NoEndPointException();
1614	}	1615	}
Lines 1639-1653 Link Here
1639	if (axisFaultException.detail instanceof java.rmi.RemoteException) {	1640	if (axisFaultException.detail instanceof java.rmi.RemoteException) {
1640	throw (java.rmi.RemoteException) axisFaultException.detail;	1641	throw (java.rmi.RemoteException) axisFaultException.detail;
1641	}	1642	}
1642	if (axisFaultException.detail instanceof org.eclipse.mylar.xplanner.wsdl.db.QueryException) {	1643	if (axisFaultException.detail instanceof org.eclipse.mylyn.xplanner.wsdl.db.QueryException) {
1643	throw (org.eclipse.mylar.xplanner.wsdl.db.QueryException) axisFaultException.detail;	1644	throw (org.eclipse.mylyn.xplanner.wsdl.db.QueryException) axisFaultException.detail;
1644	}	1645	}
1645	}	1646	}
1646	throw axisFaultException;	1647	throw axisFaultException;
1647	}	1648	}
1648	}	1649	}
1649		1650
1650	public org.xplanner.soap.TaskData[] getPlannedTasksForPerson(int personId) throws java.rmi.RemoteException, org.eclipse.mylar.xplanner.wsdl.db.QueryException {	1651	public org.xplanner.soap.TaskData[] getPlannedTasksForPerson(int personId) throws java.rmi.RemoteException, org.eclipse.mylyn.xplanner.wsdl.db.QueryException {
1651	if (super.cachedEndpoint == null) {	1652	if (super.cachedEndpoint == null) {
1652	throw new org.apache.axis.NoEndPointException();	1653	throw new org.apache.axis.NoEndPointException();
1653	}	1654	}
Lines 1678-1685 Link Here
1678	if (axisFaultException.detail instanceof java.rmi.RemoteException) {	1679	if (axisFaultException.detail instanceof java.rmi.RemoteException) {
1679	throw (java.rmi.RemoteException) axisFaultException.detail;	1680	throw (java.rmi.RemoteException) axisFaultException.detail;
1680	}	1681	}
1681	if (axisFaultException.detail instanceof org.eclipse.mylar.xplanner.wsdl.db.QueryException) {	1682	if (axisFaultException.detail instanceof org.eclipse.mylyn.xplanner.wsdl.db.QueryException) {
1682	throw (org.eclipse.mylar.xplanner.wsdl.db.QueryException) axisFaultException.detail;	1683	throw (org.eclipse.mylyn.xplanner.wsdl.db.QueryException) axisFaultException.detail;
1683	}	1684	}
1684	}	1685	}
1685	throw axisFaultException;	1686	throw axisFaultException;

Added Link Here

(-)src/org/eclipse/mylyn/xplanner/core/service/soap/client-config.wsdd (+14 lines)
1	<?xml version="1.0" encoding="UTF-8"?>
2	<deployment name="defaultClientConfig"
3	xmlns="http://xml.apache.org/axis/wsdd/"
4	xmlns:java="http://xml.apache.org/axis/wsdd/providers/java">
5	<!--
6	<transport name="http" pivot="java:org.apache.axis.transport.http.CommonsHTTPSender" />
7	<transport name="https" pivot="java:org.apache.axis.transport.http.CommonsHTTPSender"/>
8	-->
9	<transport name="http" pivot="java:org.xplanner.soap.XPlannerHttpSender" />
10	<transport name="https" pivot="java:org.xplanner.soap.XPlannerHttpSender"/>
11
12	<transport name="local" pivot="java:org.apache.axis.transport.local.LocalSender"/>
13
14	</deployment>

Lines 5-18 Link Here

(-)src/org/eclipse/mylyn/xplanner/ui/XPlannerAttributeFactory.java (-9 / +67 lines)
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html	6	* http://www.eclipse.org/legal/epl-v10.html
7	*******************************************************************************/	7	*******************************************************************************/
8	package org.eclipse.mylar.xplanner.ui;	8	package org.eclipse.mylyn.xplanner.ui;
9		9
10	import java.text.DateFormat;	10	import java.text.DateFormat;
11	import java.text.SimpleDateFormat;	11	import java.text.SimpleDateFormat;
12	import java.util.Date;	12	import java.util.*;
13		13
14	import org.eclipse.mylar.tasks.core.AbstractAttributeFactory;	14	import org.eclipse.mylyn.tasks.core.AbstractAttributeFactory;
15	import org.eclipse.mylar.tasks.core.RepositoryTaskAttribute;	15	import org.eclipse.mylyn.tasks.core.RepositoryTaskAttribute;
16		16
17		17
18	/**	18	/**
Lines 37-50 Link Here
37	public static final String ATTRIBUTE_USER_STORY_NAME = "userStoryName"; //$NON-NLS-1$	37	public static final String ATTRIBUTE_USER_STORY_NAME = "userStoryName"; //$NON-NLS-1$
38	public static final String ATTRIBUTE_TASK_COMPLETED = "completed"; //$NON-NLS-1$	38	public static final String ATTRIBUTE_TASK_COMPLETED = "completed"; //$NON-NLS-1$
39		39
40	@Override	40	public static final String ATTRIBUTE_SUBTASK_IDS = "attribute.xplanner.subtask_ids";
41	public boolean getIsHidden(String key) {	41	public static final String ATTRIBUTE_SUBTASK_KEYS = "attribute.xplanner.subtask_keys";
42	return false;	42
		43	private static Map<String, Attribute> commonKeyToAttributesMap = new HashMap<String, Attribute>();
		44
		45	public enum Attribute {
		46	DESCRIPTION("Description:", RepositoryTaskAttribute.DESCRIPTION, false), //$NON-NLS-1$
		47	OWNER("Acceptor:", RepositoryTaskAttribute.USER_ASSIGNED, true), //$NON-NLS-1$
		48	PRIORITY("Priority:", RepositoryTaskAttribute.PRIORITY, true), //$NON-NLS-1$
		49	STATUS("Status:", RepositoryTaskAttribute.STATUS, true), //$NON-NLS-1$
		50	NAME("Name:", RepositoryTaskAttribute.SUMMARY, false), //$NON-NLS-1$
		51	CREATED_ON("Created:", RepositoryTaskAttribute.DATE_CREATION, true), //$NON-NLS-1$
		52	MODIFIED_TIME("Last Update:", RepositoryTaskAttribute.DATE_MODIFIED, true), //$NON-NLS-1$
		53	SUBTASK_IDS("Subtask ids:", XPlannerAttributeFactory.ATTRIBUTE_SUBTASK_IDS, true),
		54	SUBTASK_KEYS("Sub-Tasks:", XPlannerAttributeFactory.ATTRIBUTE_SUBTASK_KEYS, true),
		55
		56	;
		57
		58	private final boolean isReadOnly;
		59
		60	private final String displayName;
		61
		62	private final String commonAttributeKey;
		63
		64	Attribute(String displayName, String commonAttributeKey, boolean readonly) {
		65	this.displayName = displayName;
		66	this.commonAttributeKey = commonAttributeKey;
		67	this.isReadOnly = readonly;
		68
		69	commonKeyToAttributesMap.put(commonAttributeKey, this);
		70	}
		71
		72	public String getCommonAttributeKey() {
		73	return commonAttributeKey;
		74	}
		75
		76	public String getDisplayName() {
		77	return displayName;
		78	}
		79
		80	public boolean isReadOnly() {
		81	return isReadOnly;
		82	}
		83
		84	@Override
		85	public String toString() {
		86	return getDisplayName();
		87	}
		88	}
		89
		90
		91	static {
		92	// make sure hash maps get initialized when class is loaded
		93	Attribute.values();
43	}	94	}
44		95
45	@Override	96	@Override
46	public String getName(String key) {	97	public String getName(String key) {
47	return key;	98	Attribute attribute = commonKeyToAttributesMap.get(key);
		99	return (attribute != null) ? attribute.getDisplayName() : key;
48	}	100	}
49		101
50	@Override	102	@Override
Lines 53-61 Link Here
53	}	105	}
54		106
55	@Override	107	@Override
56	public boolean isReadOnly(String key) {	108	public boolean isHidden(String key) {
57	return false;	109	return false;
58	}	110	}
		111
		112	@Override
		113	public boolean isReadOnly(String key) {
		114	Attribute attribute = commonKeyToAttributesMap.get(key);
		115	return (attribute != null) ? attribute.isReadOnly() : false;
		116	}
59		117
60	public Date getDateForAttributeType(String attributeKey, String dateString) {	118	public Date getDateForAttributeType(String attributeKey, String dateString) {
61	if(dateString == null \|\| dateString.equals("")) { //$NON-NLS-1$	119	if(dateString == null \|\| dateString.equals("")) { //$NON-NLS-1$

Lines 1-19 Link Here

(-)src/org/eclipse/mylyn/xplanner/ui/messages.properties (-15 / +17 lines)
1	MylarXPlannerPlugin_CLIENT_LABEL=XPlanner (supports 0.7 and later)	1	MylynXPlannerPlugin_CLIENT_LABEL=XPlanner (supports 0.7 and later)
2	MylarXPlannerPlugin_CLIENT_DIALOG_TITLE=Mylar XPlanner Client	2	MylynXPlannerPlugin_CLIENT_DIALOG_TITLE=Mylyn XPlanner Client
3	MylarXPlannerPlugin_NOT_AVAILABLE_IN_SKU=Mylar XPlanner plugin features are not available in this SKU	3	MylynXPlannerPlugin_NOT_AVAILABLE_IN_SKU=Mylyn XPlanner plugin features are not available in this SKU
4	MylarXPlannerPlugin_MYLAR_XPLANNER_ERROR_TITLE=Mylar XPlanner Error	4	MylynXPlannerPlugin_XPLANNER_ERROR_TITLE=Mylyn XPlanner Error
5	XPlannerServerFacade_SERVER_CONNECTION_ERROR=Error connecting to XPlanner Server	5	XPlannerClientFacade_SERVER_CONNECTION_ERROR=Error connecting to XPlanner Server
6	XPlannerServerFacade_CONNECTION_FAILURE_ERROR=XPlanner Connection Failure.\n\n	6	XPlannerClientFacade_CONNECTION_FAILURE_ERROR=XPlanner Connection Failure.\n\n
7	XPlannerServerFacade_INVALID_URL_EXCEPTION=Invalid url	7	XPlannerClientFacade_INVALID_URL_EXCEPTION=Invalid url
8	XPlannerServerFacade_NETWORK_CONNECTION_FAILURE=Please check your network connection and XPlanner server settings in the Task Repositories view.	8	XPlannerClientFacade_NETWORK_CONNECTION_FAILURE=Please check your network connection and XPlanner server settings in the Task Repositories view.
9	XPlannerRepositoryConnector_NEW_TASK_DESCRIPTION=New Task	9	XPlannerRepositoryConnector_NEW_TASK_DESCRIPTION=New Task
10	XPlannerRepositoryConnector_PerformQueryFailure=Mylar XPlanner query failure: {0}	10	XPlannerRepositoryConnector_PerformQueryFailure=Mylyn XPlanner query failure: {0}
11	XPlannerRepositoryConnector_ERROR_RETRIEVING_RESULTS=Error while retrieving results from: {0}	11	XPlannerRepositoryConnector_ERROR_RETRIEVING_RESULTS=Error while retrieving results from: {0}
		12	XPlannerRepositoryConnector_COULD_NOT_CONVERT_TASK_DATE=Could not convert task date using format
12	XPlannerRepositoryConnector_ERROR_UPDATING_TASK=Error updating task	13	XPlannerRepositoryConnector_ERROR_UPDATING_TASK=Error updating task
13	XPlannerServerFacade_AUTHENTICATION_FAILED=XPlanner Authentication Failed.\n\n	14	XPlannerClientFacade_AUTHENTICATION_FAILED=XPlanner Authentication Failed.\n\n
14	XPlannerServerFacade_USERNAME_PASSWORD_ERROR=Please check your XPlanner username and password in the Task Repositories view	15	XPlannerClientFacade_USERNAME_PASSWORD_ERROR=Please check your XPlanner username and password in the Task Repositories view
15	XPlannerServerFacade_NO_REPOSITORY_FOUND=No XPlanner repository found.\n\n	16	XPlannerClientFacade_NO_REPOSITORY_FOUND=No XPlanner repository found.\n\n
16	XPlannerServerFacade_VERIFY_VALID_REPOSITORY=Please verify that a vaild XPlanner repository exists in the Task Repositories view	17	XPlannerClientFacade_VERIFY_VALID_REPOSITORY=Please verify that a vaild XPlanner repository exists in the Task Repositories view
17	XPlannerRepositoryConnector_VERSION_SUPPORT=0.7 and higher	18	XPlannerRepositoryConnector_VERSION_SUPPORT=0.7 and higher
18	XPlannerRepositoryConnector_ErrorDialogTitle=XPlanner Query Error	19	XPlannerRepositoryConnector_ErrorDialogTitle=XPlanner Query Error
19	XPlannerRepositoryUtils_TASK_DOWNLOAD_FAILED=Task download failed. Ensure proper repository configuration of {0} in {1}.	20	XPlannerRepositoryUtils_TASK_DOWNLOAD_FAILED=Task download failed. Ensure proper repository configuration of {0} in {1}.
Lines 21-28 Link Here
21	XPlannerRepositoryUtils_NO_PROJECT_NAME=<no project name>	22	XPlannerRepositoryUtils_NO_PROJECT_NAME=<no project name>
22	XPlannerRepositoryUtils_NO_ITERATION_NAME=<no iteration name>	23	XPlannerRepositoryUtils_NO_ITERATION_NAME=<no iteration name>
23	XPlannerRepositoryUtils_NO_USER_STORY_NAME=<no user story name>	24	XPlannerRepositoryUtils_NO_USER_STORY_NAME=<no user story name>
24	XPlannerServerFacade_COULD_NOT_CONNECT_TO_REPOSITORY=Could not connect to XPlanner repository.\n\n	25	XPlannerClientFacade_COULD_NOT_CONNECT_TO_REPOSITORY=Could not connect to XPlanner repository.\n\n
25	XPlannerTaskExternalizer_FAILED_TO_LOAD_HITS_EXCEPTION=Failed to load all hits	26	XPlannerTaskExternalizer_FAILED_TO_LOAD_HITS_EXCEPTION=Failed to load all hits
26	XPlannerTaskExternalizer_HANDLE_NOT_STORED_EXCEPTION=Handle not stored for task	27	XPlannerTaskExternalizer_HANDLE_NOT_STORED_EXCEPTION=Handle not stored for task
		28	XPlannerOfflineTaskHandler_CANNOT_POST_DATA_TO_SERVER=Cannot post XPlanner task data to XPlanner server
27	XPlannerTaskExternalizer_DESCRIPTION_NOT_STORED_EXCEPTION=Description not stored for task	29	XPlannerTaskExternalizer_DESCRIPTION_NOT_STORED_EXCEPTION=Description not stored for task
28	XPlannerServerFacade_CHECK_CREDENTIALS=Please check your credentials in the Task Repositories view	30	XPlannerClientFacade_CHECK_CREDENTIALS=Please check your credentials in the Task Repositories view

Removed Link Here

(-)src/org/eclipse/mylyn/xplanner/ui/MylarXPlannerUtils.java (-34 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 - 2007 CodeGear and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*******************************************************************************/
8	package org.eclipse.mylar.xplanner.ui;
9
10	import org.eclipse.mylar.tasks.core.TaskRepository;
11	import org.eclipse.mylar.tasks.ui.TasksUiPlugin;
12	import org.eclipse.mylar.xplanner.ui.wizard.NewXPlannerQueryWizard;
13
14	/**
15	* @author Ravi Kumar
16	* @author Helen Bershadskaya
17	*/
18	public class MylarXPlannerUtils {
19	private MylarXPlannerUtils() {
20
21	}
22
23	public static void addNewMyTasksQuery(TaskRepository repository,
24	String name) {
25
26	XPlannerCustomQuery myTasksQuery =
27	new XPlannerCustomQuery(repository.getUrl(), name,
28	TasksUiPlugin.getTaskListManager().getTaskList());
29
30	myTasksQuery.setMyCurrentTasks(true);
31	NewXPlannerQueryWizard.addQuery(myTasksQuery, repository);
32	}
33
34	}

Lines 3-56 Link Here

(-)plugin.xml (-26 / +13 lines)
3	<plugin>	3	<plugin>
4		4
5	<extension	5	<extension
6	id="org.eclipse.mylar.xplanner.repository"	6	id="org.eclipse.mylyn.xplanner.repository"
7	name="%repositoryName"	7	name="%repositoryName"
8	point="org.eclipse.mylar.tasks.ui.repositories">	8	point="org.eclipse.mylyn.tasks.ui.repositories">
9		9
10	<connectorCore	10	<connectorCore
11	class="org.eclipse.mylar.xplanner.ui.XPlannerRepositoryConnector"	11	class="org.eclipse.mylyn.xplanner.ui.XPlannerRepositoryConnector"
12	id="org.eclipse.mylar.xplanner.tasklist.repositories"	12	id="org.eclipse.mylyn.xplanner.tasklist.repositories"
13	name="%connectorName"	13	name="%connectorName"
14	type="xPlanner"/>	14	type="xPlanner"/>
15	<connectorUi	15	<connectorUi
16	brandingIcon="icons/eview16/xplanner-logo.gif"	16	brandingIcon="icons/eview16/xplanner-logo.gif"
17	class="org.eclipse.mylar.xplanner.ui.XPlannerRepositoryUi"	17	class="org.eclipse.mylyn.xplanner.ui.XPlannerRepositoryUi"
18	name="%connectorUiName"	18	name="%connectorUiName"
19	overlayIcon="icons/eview16/overlay-xplanner.gif"/>	19	overlayIcon="icons/eview16/overlay-xplanner.gif"/>
20		20
21	<externalizer	21	<taskListFactory
22	class="org.eclipse.mylar.xplanner.ui.XPlannerTaskExternalizer"	22	class="org.eclipse.mylyn.xplanner.ui.XPlannerTaskListFactory"
23	id="org.eclipse.mylar.xplanner.tasklist.externalizer"/>	23	id="org.eclipse.mylyn.xplanner.tasklist.taskListFactory"/>
24	</extension>	24	</extension>
25		25
26	<extension point="org.eclipse.ui.decorators">
27	<decorator
28	class="org.eclipse.mylar.xplanner.ui.XPlannerTaskDecorator"
29	id="org.eclipse.mylar.xplanner.ui.decorator.task"
30	label="%decoratorLabelTask"
31	lightweight="true"
32	state="true">
33	<description>%decoratorDescriptionTask</description>
34	<enablement>
35	<objectClass name="org.eclipse.mylar.tasks.core.ITaskListElement"/>
36	</enablement>
37	</decorator>
38	</extension>
39	<!--	26	<!--
40	<extension	27	<extension
41	point="org.eclipse.ui.editors">	28	point="org.eclipse.ui.editors">
42	<editor	29	<editor
43	class="org.eclipse.mylar.xplanner.ui.XPlannerTaskEditor"	30	class="org.eclipse.mylyn.xplanner.ui.XPlannerTaskEditor"
44	default="false"	31	default="false"
45	id="org.eclipse.mylar.xplanner.task.editor"	32	id="org.eclipse.mylyn.xplanner.task.editor"
46	name="%editorNameTask"/>	33	name="%editorNameTask"/>
47	</extension>	34	</extension>
48	-->	35	-->
49	<extension	36	<extension
50	point="org.eclipse.mylar.tasks.ui.editors">	37	point="org.eclipse.mylyn.tasks.ui.editors">
51	<editorFactory	38	<editorFactory
52	class="org.eclipse.mylar.xplanner.ui.editor.XPlannerTaskEditorFactory"	39	class="org.eclipse.mylyn.xplanner.ui.editor.XPlannerTaskEditorFactory"
53	id="org.eclipse.mylar.xplanner.ui.XPlannerTaskEditorFactory"/>	40	id="org.eclipse.mylyn.xplanner.ui.XPlannerTaskEditorFactory"/>
54	</extension>	41	</extension>
55		42
56	</plugin>	43	</plugin>

Lines 1-9 Link Here

(-)META-INF/MANIFEST.MF (-9 / +10 lines)
1	Manifest-Version: 1.0	1	Manifest-Version: 1.0
2	Bundle-ManifestVersion: 2	2	Bundle-ManifestVersion: 2
3	Bundle-Name: %bundleName	3	Bundle-Name: %bundleName
4	Bundle-SymbolicName: org.eclipse.mylar.xplanner.ui;singleton:=true	4	Bundle-SymbolicName: org.eclipse.mylyn.xplanner.ui;singleton:=true
5	Bundle-Version: 2.0.0.qualifier	5	Bundle-Version: 2.0.0.qualifier
6	Bundle-Activator: org.eclipse.mylar.xplanner.ui.XPlannerMylarUIPlugin	6	Bundle-Activator: org.eclipse.mylyn.xplanner.ui.XPlannerMylynUIPlugin
7	Bundle-Vendor: %bundleVendor	7	Bundle-Vendor: %bundleVendor
8	Bundle-Localization: plugin	8	Bundle-Localization: plugin
9	Require-Bundle: org.eclipse.ui,	9	Require-Bundle: org.eclipse.ui,
Lines 13-23 Link Here
13	org.eclipse.search,	13	org.eclipse.search,
14	org.eclipse.ui.forms,	14	org.eclipse.ui.forms,
15	org.eclipse.help,	15	org.eclipse.help,
16	org.eclipse.mylar.xplanner.core,	16	org.eclipse.mylyn.xplanner.core,
17	org.eclipse.mylar.tasks.ui,	17	org.eclipse.mylyn.tasks.ui,
18	org.eclipse.mylar.context.core,	18	org.eclipse.mylyn.context.core,
19	org.eclipse.mylar.tasks.core,	19	org.eclipse.mylyn.tasks.core,
20	org.eclipse.mylar	20	org.eclipse.mylyn,
		21	org.eclipse.mylyn.monitor.core
21	Eclipse-LazyStart: true	22	Eclipse-LazyStart: true
22	Export-Package: org.eclipse.mylar.xplanner.ui,	23	Export-Package: org.eclipse.mylyn.xplanner.ui,
23	org.eclipse.mylar.xplanner.ui.wizard	24	org.eclipse.mylyn.xplanner.ui.wizard

Lines 1-13 Link Here

(-)META-INF/MANIFEST.MF (-6 / +7 lines)
1	Manifest-Version: 1.0	1	Manifest-Version: 1.0
2	Bundle-ManifestVersion: 2	2	Bundle-ManifestVersion: 2
3	Bundle-Name: @bundleName	3	Bundle-Name: @bundleName
4	Bundle-SymbolicName: org.eclipse.mylar.xplanner.tests	4	Bundle-SymbolicName: org.eclipse.mylyn.xplanner.tests
5	Bundle-Version: 1.0.0	5	Bundle-Version: 1.1.0.qualifer
6	Bundle-Localization: plugin	6	Bundle-Localization: plugin
7	Require-Bundle: org.junit,	7	Require-Bundle: org.junit,
8	org.eclipse.core.runtime,	8	org.eclipse.core.runtime,
9	org.eclipse.ui,	9	org.eclipse.ui,
10	org.eclipse.mylar.tasks.core,	10	org.eclipse.mylyn.tasks.core,
11	org.eclipse.mylar.tasks.ui,	11	org.eclipse.mylyn.tasks.ui,
12	org.eclipse.mylar.xplanner.core,	12	org.eclipse.mylyn.xplanner.core,
13	org.eclipse.mylar.xplanner.ui	13	org.eclipse.mylyn.xplanner.ui,
		14	org.eclipse.search