001// License: GPL. For details, see LICENSE file. 002package org.openstreetmap.josm.actions; 003 004import static org.openstreetmap.josm.gui.help.HelpUtil.ht; 005import static org.openstreetmap.josm.tools.I18n.tr; 006 007import java.awt.event.ActionEvent; 008import java.awt.event.KeyEvent; 009import java.io.IOException; 010import java.util.Collection; 011import java.util.HashSet; 012import java.util.Set; 013import java.util.Stack; 014import java.util.stream.Collectors; 015 016import javax.swing.JOptionPane; 017import javax.swing.SwingUtilities; 018 019import org.openstreetmap.josm.data.APIDataSet; 020import org.openstreetmap.josm.data.osm.DataSet; 021import org.openstreetmap.josm.data.osm.DefaultNameFormatter; 022import org.openstreetmap.josm.data.osm.Node; 023import org.openstreetmap.josm.data.osm.OsmPrimitive; 024import org.openstreetmap.josm.data.osm.Relation; 025import org.openstreetmap.josm.data.osm.Way; 026import org.openstreetmap.josm.data.osm.event.AbstractDatasetChangedEvent; 027import org.openstreetmap.josm.data.osm.event.DataSetListenerAdapter; 028import org.openstreetmap.josm.data.osm.event.DatasetEventManager; 029import org.openstreetmap.josm.data.osm.event.DatasetEventManager.FireMode; 030import org.openstreetmap.josm.data.osm.visitor.OsmPrimitiveVisitor; 031import org.openstreetmap.josm.gui.MainApplication; 032import org.openstreetmap.josm.gui.Notification; 033import org.openstreetmap.josm.gui.PleaseWaitRunnable; 034import org.openstreetmap.josm.gui.io.UploadSelectionDialog; 035import org.openstreetmap.josm.gui.layer.OsmDataLayer; 036import org.openstreetmap.josm.io.OsmServerBackreferenceReader; 037import org.openstreetmap.josm.io.OsmTransferException; 038import org.openstreetmap.josm.tools.CheckParameterUtil; 039import org.openstreetmap.josm.tools.ExceptionUtil; 040import org.openstreetmap.josm.tools.Shortcut; 041import org.openstreetmap.josm.tools.Utils; 042import org.xml.sax.SAXException; 043 044/** 045 * Uploads the current selection to the server. 046 * @since 2250 047 */ 048public class UploadSelectionAction extends AbstractUploadAction implements DataSetListenerAdapter.Listener { 049 private final transient DataSetListenerAdapter dataChangedAdapter = new DataSetListenerAdapter(this); 050 051 /** 052 * Constructs a new {@code UploadSelectionAction}. 053 */ 054 public UploadSelectionAction() { 055 super( 056 tr("Upload selection..."), 057 "uploadselection", 058 tr("Upload all changes in the current selection to the OSM server."), 059 // CHECKSTYLE.OFF: LineLength 060 Shortcut.registerShortcut("file:uploadSelection", tr("File: {0}", tr("Upload selection")), KeyEvent.VK_U, Shortcut.ALT_CTRL_SHIFT), 061 // CHECKSTYLE.ON: LineLength 062 true); 063 setHelpId(ht("/Action/UploadSelection")); 064 DatasetEventManager.getInstance().addDatasetListener(dataChangedAdapter, FireMode.IMMEDIATELY); 065 } 066 067 @Override 068 protected void updateEnabledState() { 069 updateEnabledStateOnCurrentSelection(); 070 } 071 072 @Override 073 protected void updateEnabledState(Collection<? extends OsmPrimitive> selection) { 074 updateEnabledStateOnModifiableSelection(selection); 075 OsmDataLayer editLayer = getLayerManager().getEditLayer(); 076 if (isEnabled() && editLayer != null && !editLayer.isUploadable()) { 077 setEnabled(false); 078 } 079 if (isEnabled() && selection.parallelStream().noneMatch(OsmPrimitive::isModified)) { 080 setEnabled(false); 081 } 082 } 083 084 protected Set<OsmPrimitive> getDeletedPrimitives(DataSet ds) { 085 return ds.allPrimitives().parallelStream() 086 .filter(p -> p.isDeleted() && !p.isNew() && p.isVisible() && p.isModified()) 087 .collect(Collectors.toSet()); 088 } 089 090 protected Set<OsmPrimitive> getModifiedPrimitives(Collection<OsmPrimitive> primitives) { 091 return primitives.parallelStream() 092 .filter(p -> p.isNewOrUndeleted() || (p.isModified() && !p.isIncomplete())) 093 .collect(Collectors.toSet()); 094 } 095 096 @Override 097 public void actionPerformed(ActionEvent e) { 098 OsmDataLayer editLayer = getLayerManager().getEditLayer(); 099 if (!isEnabled() || !editLayer.isUploadable()) 100 return; 101 if (editLayer.isUploadDiscouraged() && UploadAction.warnUploadDiscouraged(editLayer)) { 102 return; 103 } 104 Collection<OsmPrimitive> modifiedCandidates = getModifiedPrimitives(editLayer.data.getAllSelected()); 105 Collection<OsmPrimitive> deletedCandidates = getDeletedPrimitives(editLayer.getDataSet()); 106 if (modifiedCandidates.isEmpty() && deletedCandidates.isEmpty()) { 107 new Notification(tr("No changes to upload.")).setIcon(JOptionPane.INFORMATION_MESSAGE).show(); 108 return; 109 } 110 UploadSelectionDialog dialog = new UploadSelectionDialog(); 111 dialog.populate( 112 modifiedCandidates, 113 deletedCandidates 114 ); 115 dialog.setVisible(true); 116 if (dialog.isCanceled()) 117 return; 118 Collection<OsmPrimitive> toUpload = new UploadHullBuilder().build(dialog.getSelectedPrimitives()); 119 if (toUpload.isEmpty()) { 120 new Notification(tr("No changes to upload.")).setIcon(JOptionPane.INFORMATION_MESSAGE).show(); 121 return; 122 } 123 uploadPrimitives(editLayer, toUpload); 124 } 125 126 /** 127 * Replies true if there is at least one non-new, deleted primitive in 128 * <code>primitives</code> 129 * 130 * @param primitives the primitives to scan 131 * @return true if there is at least one non-new, deleted primitive in 132 * <code>primitives</code> 133 */ 134 protected boolean hasPrimitivesToDelete(Collection<OsmPrimitive> primitives) { 135 return primitives.parallelStream().anyMatch(p -> p.isDeleted() && p.isModified() && !p.isNew()); 136 } 137 138 /** 139 * Uploads the primitives in <code>toUpload</code> to the server. Only 140 * uploads primitives which are either new, modified or deleted. 141 * 142 * Also checks whether <code>toUpload</code> has to be extended with 143 * deleted parents in order to avoid precondition violations on the server. 144 * 145 * @param layer the data layer from which we upload a subset of primitives 146 * @param toUpload the primitives to upload. If null or empty returns immediately 147 */ 148 public void uploadPrimitives(OsmDataLayer layer, Collection<OsmPrimitive> toUpload) { 149 if (Utils.isEmpty(toUpload)) return; 150 UploadHullBuilder builder = new UploadHullBuilder(); 151 toUpload = builder.build(toUpload); 152 if (hasPrimitivesToDelete(toUpload)) { 153 // runs the check for deleted parents and then invokes 154 // processPostParentChecker() 155 // 156 MainApplication.worker.submit(new DeletedParentsChecker(layer, toUpload)); 157 } else { 158 processPostParentChecker(layer, toUpload); 159 } 160 } 161 162 protected void processPostParentChecker(OsmDataLayer layer, Collection<OsmPrimitive> toUpload) { 163 APIDataSet ds = new APIDataSet(toUpload); 164 UploadAction action = new UploadAction(); 165 action.uploadData(layer, ds); 166 } 167 168 /** 169 * Computes the collection of primitives to upload, given a collection of candidate 170 * primitives. 171 * Some of the candidates are excluded, i.e. if they aren't modified. 172 * Other primitives are added. A typical case is a primitive which is new and and 173 * which is referred by a modified relation. In order to upload the relation the 174 * new primitive has to be uploaded as well, even if it isn't included in the 175 * list of candidate primitives. 176 * 177 */ 178 static class UploadHullBuilder implements OsmPrimitiveVisitor { 179 private Set<OsmPrimitive> hull; 180 181 UploadHullBuilder() { 182 hull = new HashSet<>(); 183 } 184 185 @Override 186 public void visit(Node n) { 187 if (n.isNewOrUndeleted() || n.isModified() || n.isDeleted()) { 188 // upload new nodes as well as modified and deleted ones 189 hull.add(n); 190 } 191 } 192 193 @Override 194 public void visit(Way w) { 195 if (w.isNewOrUndeleted() || w.isModified() || w.isDeleted()) { 196 // upload new ways as well as modified and deleted ones 197 hull.add(w); 198 for (Node n: w.getNodes()) { 199 // we upload modified nodes even if they aren't in the current selection. 200 n.accept(this); 201 } 202 } 203 } 204 205 @Override 206 public void visit(Relation r) { 207 if (r.isNewOrUndeleted() || r.isModified() || r.isDeleted()) { 208 hull.add(r); 209 for (OsmPrimitive p : r.getMemberPrimitives()) { 210 // add new relation members. Don't include modified 211 // relation members. r shouldn't refer to deleted primitives, 212 // so wont check here for deleted primitives here 213 // 214 if (p.isNewOrUndeleted()) { 215 p.accept(this); 216 } 217 } 218 } 219 } 220 221 /** 222 * Builds the "hull" of primitives to be uploaded given a base collection 223 * of osm primitives. 224 * 225 * @param base the base collection. Must not be null. 226 * @return the "hull" 227 * @throws IllegalArgumentException if base is null 228 */ 229 public Set<OsmPrimitive> build(Collection<OsmPrimitive> base) { 230 CheckParameterUtil.ensureParameterNotNull(base, "base"); 231 hull = new HashSet<>(); 232 for (OsmPrimitive p: base) { 233 p.accept(this); 234 } 235 return hull; 236 } 237 } 238 239 class DeletedParentsChecker extends PleaseWaitRunnable { 240 private boolean canceled; 241 private Exception lastException; 242 private final Collection<OsmPrimitive> toUpload; 243 private final OsmDataLayer layer; 244 private OsmServerBackreferenceReader reader; 245 246 /** 247 * Constructs a new {@code DeletedParentsChecker}. 248 * @param layer the data layer for which a collection of selected primitives is uploaded 249 * @param toUpload the collection of primitives to upload 250 */ 251 DeletedParentsChecker(OsmDataLayer layer, Collection<OsmPrimitive> toUpload) { 252 super(tr("Checking parents for deleted objects")); 253 this.toUpload = toUpload; 254 this.layer = layer; 255 } 256 257 @Override 258 protected void cancel() { 259 this.canceled = true; 260 synchronized (this) { 261 if (reader != null) { 262 reader.cancel(); 263 } 264 } 265 } 266 267 @Override 268 protected void finish() { 269 if (canceled) 270 return; 271 if (lastException != null) { 272 ExceptionUtil.explainException(lastException); 273 return; 274 } 275 SwingUtilities.invokeLater(() -> processPostParentChecker(layer, toUpload)); 276 } 277 278 /** 279 * Replies the collection of deleted OSM primitives for which we have to check whether 280 * there are dangling references on the server. 281 * 282 * @return primitives to check 283 */ 284 protected Set<OsmPrimitive> getPrimitivesToCheckForParents() { 285 return toUpload.parallelStream().filter(p -> p.isDeleted() && !p.isNewOrUndeleted()).collect(Collectors.toSet()); 286 } 287 288 @Override 289 protected void realRun() throws SAXException, IOException, OsmTransferException { 290 try { 291 Stack<OsmPrimitive> toCheck = new Stack<>(); 292 toCheck.addAll(getPrimitivesToCheckForParents()); 293 Set<OsmPrimitive> checked = new HashSet<>(); 294 while (!toCheck.isEmpty()) { 295 if (canceled) return; 296 OsmPrimitive current = toCheck.pop(); 297 synchronized (this) { 298 reader = new OsmServerBackreferenceReader(current).setAllowIncompleteParentWays(true); 299 } 300 getProgressMonitor().subTask(tr("Reading parents of ''{0}''", current.getDisplayName(DefaultNameFormatter.getInstance()))); 301 DataSet ds = reader.parseOsm(getProgressMonitor().createSubTaskMonitor(1, false)); 302 synchronized (this) { 303 reader = null; 304 } 305 checked.add(current); 306 getProgressMonitor().subTask(tr("Checking for deleted parents in the local dataset")); 307 for (OsmPrimitive p: ds.allPrimitives()) { 308 if (canceled) return; 309 if (p instanceof Node || (p instanceof Way && !(current instanceof Node))) continue; 310 OsmPrimitive myDeletedParent = layer.data.getPrimitiveById(p); 311 // our local dataset includes a deleted parent of a primitive we want 312 // to delete. Include this parent in the collection of uploaded primitives 313 if (myDeletedParent != null && myDeletedParent.isDeleted()) { 314 if (!toUpload.contains(myDeletedParent)) { 315 toUpload.add(myDeletedParent); 316 } 317 if (!checked.contains(myDeletedParent)) { 318 toCheck.push(myDeletedParent); 319 } 320 } 321 } 322 } 323 } catch (OsmTransferException e) { 324 if (canceled) 325 // ignore exception 326 return; 327 lastException = e; 328 } 329 } 330 } 331 332 @Override 333 public void destroy() { 334 super.destroy(); 335 DatasetEventManager.getInstance().removeDatasetListener(dataChangedAdapter); 336 337 } 338 339 @Override 340 public void processDatasetEvent(AbstractDatasetChangedEvent event) { 341 updateEnabledStateOnCurrentSelection(); 342 } 343}