bundles/org.simantics.issues.ui/src/org/simantics/issues/ui/handler/PurgeResolvedIssues.java

   1 /*******************************************************************************
   2  * Copyright (c) 2007, 2011 Association for Decentralized Information Management
   3  * in Industry THTH ry.
   4  * All rights reserved. This program and the accompanying materials
   5  * are made available under the terms of the Eclipse Public License v1.0
   6  * which accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors:
  10  *     VTT Technical Research Centre of Finland - initial API and implementation
  11  *******************************************************************************/
  12 package org.simantics.issues.ui.handler;
  13
  14 import java.lang.reflect.InvocationTargetException;
  15 import java.util.HashSet;
  16 import java.util.Map;
  17 import java.util.Set;
  18
  19 import org.eclipse.core.commands.AbstractHandler;
  20 import org.eclipse.core.commands.ExecutionEvent;
  21 import org.eclipse.core.commands.ExecutionException;
  22 import org.eclipse.core.runtime.IProgressMonitor;
  23 import org.eclipse.core.runtime.SubMonitor;
  24 import org.eclipse.jface.operation.IRunnableWithProgress;
  25 import org.eclipse.ui.PlatformUI;
  26 import org.simantics.Simantics;
  27 import org.simantics.browsing.ui.common.ErrorLogger;
  28 import org.simantics.db.Resource;
  29 import org.simantics.db.Session;
  30 import org.simantics.db.WriteGraph;
  31 import org.simantics.db.common.request.DelayedWriteRequest;
  32 import org.simantics.db.exception.DatabaseException;
  33 import org.simantics.db.layer0.util.Layer0Utils;
  34 import org.simantics.db.layer0.util.RemoverUtil;
  35 import org.simantics.issues.common.AllActiveIssues;
  36 import org.simantics.issues.ontology.IssueResource;
  37
  38 import gnu.trove.map.hash.THashMap;
  39
  40 /**
  41  * @author Tuukka Lehtonen
  42  */
  43 public class PurgeResolvedIssues extends AbstractHandler {
  44
  45     @Override
  46     public Object execute(ExecutionEvent event) throws ExecutionException {
  47         try {
  48             PlatformUI.getWorkbench().getProgressService().busyCursorWhile(new IRunnableWithProgress() {
  49                 @Override
  50                 public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
  51                     try {
  52                         purgeResolvedIssues(monitor);
  53                     } catch (DatabaseException e) {
  54                         throw new InvocationTargetException(e);
  55                     } finally {
  56                         monitor.done();
  57                     }
  58                 }
  59             });
  60         } catch (InvocationTargetException e) {
  61             ErrorLogger.defaultLogError(e.getCause());
  62         } catch (InterruptedException e) {
  63             ErrorLogger.defaultLogError(e);
  64         }
  65         return null;
  66     }
  67
  68     private void purgeResolvedIssues(IProgressMonitor monitor) throws DatabaseException {
  69         Session session = Simantics.getSession();
  70         final Resource project = Simantics.getProjectResource();
  71         if (project == null)
  72             return;
  73
  74         final SubMonitor mon = SubMonitor.convert(monitor, "Purging resolved issues...", 100);
  75
  76         session.syncRequest(new DelayedWriteRequest() {
  77             @Override
  78             public void perform(WriteGraph graph) throws DatabaseException {
  79                 graph.markUndoPoint();
  80                 IssueResource ISSUE = IssueResource.getInstance(graph);
  81                 Set<Resource> toBeRemoved = new HashSet<Resource>();
  82                 Map<Resource, Boolean> sourceIsContinuous = new THashMap<Resource, Boolean>();
  83                 for (Resource activeIssue : graph.syncRequest(new AllActiveIssues(project))) {
  84                     if (graph.hasStatement(activeIssue, ISSUE.Resolved)) {
  85                         Resource managedBy = graph.getPossibleObject(activeIssue, ISSUE.IssueSource_Manages_Inverse);
  86                         if (managedBy != null) {
  87                             Boolean isContinuous = sourceIsContinuous.get(managedBy);
  88                             if (isContinuous == null) {
  89                                 isContinuous = graph.isInstanceOf(managedBy, ISSUE.ContinuousIssueSource);
  90                                 sourceIsContinuous.put(managedBy, isContinuous);
  91                             }
  92                             if (isContinuous)
  93                                 continue;
  94                         }
  95                         toBeRemoved.add(activeIssue);
  96                     }
  97                 }
  98
  99                 mon.setTaskName("Purging " + toBeRemoved.size() + " resolved batch issues...");
 100                 mon.setWorkRemaining(toBeRemoved.size());
 101                 StringBuilder sb = new StringBuilder();
 102                 sb.append("Purged " + toBeRemoved.size() + " resolved batch issue(s)");
 103                 for (Resource remove : toBeRemoved) {
 104                     //sb.append(NameUtils.getSafeLabel(graph, remove) + " ");
 105                     RemoverUtil.remove(graph, remove);
 106                     mon.worked(1);
 107                 }
 108                 Layer0Utils.addCommentMetadata(graph, sb.toString());
 109             }
 110         });
 111     }
 112
 113 }