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.osgi.util.NLS;
  26 import org.eclipse.ui.PlatformUI;
  27 import org.simantics.Simantics;
  28 import org.simantics.browsing.ui.common.ErrorLogger;
  29 import org.simantics.db.Resource;
  30 import org.simantics.db.Session;
  31 import org.simantics.db.WriteGraph;
  32 import org.simantics.db.common.request.DelayedWriteRequest;
  33 import org.simantics.db.exception.DatabaseException;
  34 import org.simantics.db.layer0.util.Layer0Utils;
  35 import org.simantics.db.layer0.util.RemoverUtil;
  36 import org.simantics.issues.common.AllActiveIssues;
  37 import org.simantics.issues.ontology.IssueResource;
  38
  39 import gnu.trove.map.hash.THashMap;
  40
  41 /**
  42  * @author Tuukka Lehtonen
  43  */
  44 public class PurgeResolvedIssues extends AbstractHandler {
  45
  46     @Override
  47     public Object execute(ExecutionEvent event) throws ExecutionException {
  48         try {
  49             PlatformUI.getWorkbench().getProgressService().busyCursorWhile(new IRunnableWithProgress() {
  50                 @Override
  51                 public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
  52                     try {
  53                         purgeResolvedIssues(monitor);
  54                     } catch (DatabaseException e) {
  55                         throw new InvocationTargetException(e);
  56                     } finally {
  57                         monitor.done();
  58                     }
  59                 }
  60             });
  61         } catch (InvocationTargetException e) {
  62             ErrorLogger.defaultLogError(e.getCause());
  63         } catch (InterruptedException e) {
  64             ErrorLogger.defaultLogError(e);
  65         }
  66         return null;
  67     }
  68
  69     private void purgeResolvedIssues(IProgressMonitor monitor) throws DatabaseException {
  70         Session session = Simantics.getSession();
  71         final Resource project = Simantics.getProjectResource();
  72         if (project == null)
  73             return;
  74
  75         final SubMonitor mon = SubMonitor.convert(monitor, Messages.PurgeResolvedIssues_MonitorPurgingResolvedIssues, 100);
  76
  77         session.syncRequest(new DelayedWriteRequest() {
  78             @Override
  79             public void perform(WriteGraph graph) throws DatabaseException {
  80                 graph.markUndoPoint();
  81                 IssueResource ISSUE = IssueResource.getInstance(graph);
  82                 Set<Resource> toBeRemoved = new HashSet<>();
  83                 Map<Resource, Boolean> sourceIsContinuous = new THashMap<>();
  84                 for (Resource activeIssue : graph.syncRequest(new AllActiveIssues(project))) {
  85                     if (graph.hasStatement(activeIssue, ISSUE.Resolved)) {
  86                         Resource managedBy = graph.getPossibleObject(activeIssue, ISSUE.IssueSource_Manages_Inverse);
  87                         if (managedBy != null) {
  88                             Boolean isContinuous = sourceIsContinuous.get(managedBy);
  89                             if (isContinuous == null) {
  90                                 isContinuous = graph.isInstanceOf(managedBy, ISSUE.ContinuousIssueSource);
  91                                 sourceIsContinuous.put(managedBy, isContinuous);
  92                             }
  93                             if (isContinuous)
  94                                 continue;
  95                         }
  96                         toBeRemoved.add(activeIssue);
  97                     }
  98                 }
  99
 100                 mon.setTaskName(NLS.bind(Messages.PurgeResolvedIssues_PurgingResolvedBatchIssues, toBeRemoved.size()));
 101                 mon.setWorkRemaining(toBeRemoved.size());
 102                 StringBuilder sb = new StringBuilder();
 103                 sb.append(NLS.bind(Messages.PurgeResolvedIssues_PurgedResolvedBatchIssues, toBeRemoved.size()));
 104                 for (Resource remove : toBeRemoved) {
 105                     // sb.append(NameUtils.getSafeLabel(graph, remove) + " ");
 106                     RemoverUtil.remove(graph, remove);
 107                     mon.worked(1);
 108                 }
 109                 Layer0Utils.addCommentMetadata(graph, sb.toString());
 110             }
 111         });
 112     }
 113
 114 }