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);
        }

        
}