Subversion Repositories XServices

/*

 *   Mylyn Connector for Serena Business Mashups

 * 	 Copyright 2010 Brian Rosenberger (Brutex Network)

 *

 *   Licensed under the Apache License, Version 2.0 (the "License");

 *   you may not use this file except in compliance with the License.

 *   You may obtain a copy of the License at

 *

 *       http://www.apache.org/licenses/LICENSE-2.0

 *

 *   Unless required by applicable law or agreed to in writing, software

 *   distributed under the License is distributed on an "AS IS" BASIS,

 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 *   See the License for the specific language governing permissions and

 *   limitations under the License.

 *

 *   Serena, TeamTrack and Serena Business Mashup are

 * 	 registered trademarks of SERENA Software Inc.

 */

package net.brutex.mylyn.sbmconnector.core;

import java.util.Date;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import net.brutex.mylyn.sbmconnector.SBMConnectorPlugin;

import net.brutex.mylyn.sbmconnector.core.model.SBMStaticFields;

import net.brutex.mylyn.sbmconnector.ui.SBMQueryComposite;

import net.brutex.mylyn.sbmconnector.ui.SBMRepositoryQueryPage;

import net.brutex.mylyn.sbmconnector.ui.SBMRepositorySettingsPage;

import net.brutex.sbm.wsclient.TTItem;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Status;

import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector;

import org.eclipse.mylyn.tasks.core.IRepositoryQuery;

import org.eclipse.mylyn.tasks.core.ITask;

import org.eclipse.mylyn.tasks.core.TaskRepository;

import org.eclipse.mylyn.tasks.core.data.AbstractTaskDataHandler;

import org.eclipse.mylyn.tasks.core.data.TaskAttribute;

import org.eclipse.mylyn.tasks.core.data.TaskData;

import org.eclipse.mylyn.tasks.core.data.TaskDataCollector;

import org.eclipse.mylyn.tasks.core.data.TaskMapper;

import org.eclipse.mylyn.tasks.core.sync.ISynchronizationSession;

public class SBMRepositoryConnector extends AbstractRepositoryConnector {

	private SBMTicketDataHandler datahandler;

	private static Map<TaskRepository, SBMClient> clients = new HashMap<TaskRepository, SBMClient>();

	public SBMRepositoryConnector() {

		this.datahandler = new SBMTicketDataHandler(this);

	}

	public static synchronized SBMClient getClient(TaskRepository repository) {

		SBMClient client = clients.get(repository);

		if (client == null) {

			client = new SBMClient(repository);

			clients.put(repository, client);

		}

		return client;

	}

	@Override

	public boolean canCreateNewTask(TaskRepository repository) {

		return false;

	}

	@Override

	public boolean canCreateTaskFromKey(TaskRepository repository) {

		return false;

	}

	@Override

	public boolean canSynchronizeTask(TaskRepository taskRepository, ITask task) {

		return true;

	}

	@Override

	public String getConnectorKind() {

		return SBMConnectorPlugin.CONNECTOR_KIND;

	}

	@Override

	public String getLabel() {

		return SBMConnectorPlugin.LABEL;

	}

	@Override

	public String getRepositoryUrlFromTaskUrl(String taskFullUrl) {

		// TODO Auto-generated method stub

		return null;

	}

	@Override

	public TaskData getTaskData(TaskRepository taskRepository, String taskId,

			IProgressMonitor monitor) throws CoreException {

		monitor.beginTask("Loading SBM Ticket", IProgressMonitor.UNKNOWN);

		TaskData data = null;

		try {

			SBMClient client = getClient(taskRepository);

			TTItem item = client.getTTItem(taskId);

			data = datahandler.convert(taskRepository, item, monitor, null);

		} finally {

			monitor.done();

		}

		return data;

	}

	@Override

	public String getTaskIdFromTaskUrl(String taskFullUrl) {

		// TODO Auto-generated method stub

		return null;

	}

	@Override

	public String getTaskUrl(String repositoryUrl, String taskId) {

		// TODO Auto-generated method stub

		return "http://something/I/havent/implemented/yet?"+taskId;

	}

	@Override

	public boolean hasTaskChanged(TaskRepository taskRepository, ITask task,

			TaskData taskData) {

		TaskAttribute attribute = taskData.getRoot().getAttribute(

				SBMStaticFields.LASTMODIFIEDDATE.getValue());

		if (attribute != null) {

			Date dataModificationDate = taskData.getAttributeMapper()

					.getDateValue(attribute);

			if (dataModificationDate != null) {

				Date taskModificationDate = task.getModificationDate();

				if (taskModificationDate != null) {

					return !taskModificationDate.equals(dataModificationDate);

				}

			}

		}

		return true;

	}

	@Override

	public IStatus performQuery(TaskRepository repository,

			IRepositoryQuery query, TaskDataCollector collector,

			ISynchronizationSession session, IProgressMonitor monitor) {

		SBMClient client = new SBMClient(repository);

		// do we use a report or a query?

		if (query.getAttribute(SBMRepositoryQueryPage.SQL_QUERY_NAME).equals(

				query.getAttribute(SBMRepositoryQueryPage.REPORT_OR_QUERY))) {

			monitor.subTask("Calculating query result size ...");

			try {

				List<String> idlist = client.getResultCount(

						getQueryTable(repository),

						query.getAttribute("sql_where"));

				int countItem = idlist.size();

				monitor.beginTask("", countItem);

				monitor.subTask("Loading " + countItem + " items ...");

				// List<TTItem> list = client.getTTItemsByTable(

				// getQueryTable(repository), query.getAttribute("sql_where"),

				// true);

				monitor.worked(1);

				int i = 1;

				for (String id : idlist) {

					if (id != null) {

						monitor.subTask("Loading item " + i + "/" + countItem

								+ " ...");

						TTItem ttitem = client.getTTItem("[" + id + "]");

						TaskData data = datahandler.convert(repository, ttitem,

								monitor, query);

						collector.accept(data);

					}

					monitor.worked(1);

					if (monitor.isCanceled())

						return Status.CANCEL_STATUS;

					i++;

				}

			} catch (CoreException e) {

				IStatus status = new Status(IStatus.ERROR,

						SBMConnectorPlugin.PLUGIN_ID, e.getMessage(), e);

				// StatusManager.getManager().handle(status,

				// StatusManager.BLOCK);

				return status;

			} finally {

				monitor.done();

			}

		} else {

			// use report

			monitor.beginTask("Loading Report", 0);

			try {

				List<TTItem> list = client.getTTItemsByReport(query

						.getAttribute(SBMRepositoryQueryPage.REPORT));

				for(TTItem i:list) {

					TaskData data = datahandler.convert(repository, i,

							monitor, query);

					collector.accept(data);

				}

			} catch (CoreException e) {

				IStatus status = new Status(IStatus.ERROR,

						SBMConnectorPlugin.PLUGIN_ID, e.getMessage(), e);

				// StatusManager.getManager().handle(status,

				// StatusManager.BLOCK);

				return status;

			} finally {

				monitor.done();

			}

		}

		return Status.OK_STATUS;

	}

	@Override

	public void updateRepositoryConfiguration(TaskRepository taskRepository,

			IProgressMonitor monitor) throws CoreException {

		// TODO Auto-generated method stub

	}

	@Override

	public void updateTaskFromTaskData(TaskRepository taskRepository,

			ITask task, TaskData taskData) {

		getTaskMapping(taskData).applyTo(task);

	}

	@Override

	public TaskMapper getTaskMapping(TaskData taskData) {

		return new TaskMapper(taskData);

	}

	@Override

	public AbstractTaskDataHandler getTaskDataHandler() {

		return datahandler;

	}

	public boolean canDeleteTask(TaskRepository repository, ITask task) {

		return false;

	}

	@Override

	public boolean hasRepositoryDueDate(TaskRepository taskRepository,

			ITask task, TaskData taskData) {

		// TODO Auto-generated method stub

		return false;

	}

	private String getQueryTable(TaskRepository repository) {

		return repository

				.getProperty(SBMRepositorySettingsPage.STRING_SOLUTIONTABLE);

	}

}