gvSIG projects pool

            ViewDocument view = (ViewDocument) doc;

                if (layer instanceof FLyrVect) {

//                    if( layerStore!=null && StringUtils.equals(layerStore.getFullName(), storeFullName)){

                    if (layerStore != null && layerStore.getParameters().isTheSameStore(store.getParameters())) { //StringUtils.equals(layerStore.getFullName(),store.getFullName() )) {

                        } catch (Exception ex) {

                            LOGGER.warn("Can't refresh store from layer '" + layer.getName() + "'.", ex);

//            if( StringUtils.equals(featureStore.getFullName(), storeFullName)){

            if( featureStore.getParameters().isTheSameStore(store.getParameters())){

                    if ( layerStore!=null && layerStore.getParameters().isTheSameStore(store.getParameters()) ) { //StringUtils.equals(layerStore.getFullName(),store.getFullName() )) {

          label="_Online_Download" 

_Area=\u00c1rea

_Synchronization_zone=Zona de sincronizaci\u00f3n

_Only_changes_zone=Solo zona de cambios

_Changes_zone_and_working_area=Zona de cambios y \u00e1rea de trabajo

_Show_working_area_selector=Mostrar el selector de \u00e1rea

_Online=gvSIG online

_Online_Download=Descargar

_Select_a_Online_project=Seleccione un proyecto de gvSIG online

_Working_area=\u00c1rea de trabajo

_Downloading_data=Descargando datos

_Downloading_data_from_area=Descargando datos del \u00e1rea

_There_are_selected_entities_that_have_conflicts=Hay entidades seleccionadas con conflictos

_There_are_selected_corrupted_or_disconnected_entities=Hay entidades seleccionadas corruptas o desconectadas

_Not_in_local=No en local

_Area=Area

_Synchronization_zone=Synchronization zone

_Only_changes_zone=Only changes zone

_Changes_zone_and_working_area=Changes zone and working area

_Show_working_area_selector=Show working area selector

_Online=gvSIG online

_Online_Download=Download

_Select_a_Online_project=Select a gvSIG online project

_Working_area=Working area

_Downloading_data=Downloading data

_Downloading_data_from_area=Downloading data from area

_There_are_selected_entities_that_have_conflicts=There are selected entities that have conflicts

_There_are_selected_corrupted_or_disconnected_entities=Selected entities are corrupt or offline

_Not_in_local=Not in local

    <build>

        <plugins>

            <plugin>

                <groupId>org.apache.maven.plugins</groupId>

                <artifactId>maven-surefire-plugin</artifactId>

                <configuration>

                    <!-- Skip test execution ? -->

                    <skipTests>false</skipTests>

                    <!-- Ignore test execution failure ? -->

                    <testFailureIgnore>true</testFailureIgnore>

                    <excludes>

                        <exclude>**/TestCheckoutAlternativo.java</exclude>

                    </excludes>                        

                </configuration>

            </plugin>

            <!-- Skip test compilation ? -->

            <plugin>

                <groupId>org.apache.maven.plugins</groupId>

                <artifactId>maven-compiler-plugin</artifactId>

                <executions>

                    <execution>

                        <id>default-testCompile</id>

                        <phase>process-test-sources</phase>

                        <goals>

                            <goal>testCompile</goal>

                        </goals>

                        <configuration>

                            <skip>false</skip>

                        </configuration>

                    </execution>

                </executions>

            </plugin>

            <plugin>

                <groupId>org.apache.maven.plugins</groupId>

                <artifactId>maven-jar-plugin</artifactId>

                <configuration>

                </configuration>

                <executions>

                    <!-- Generates a jar file only with the test classes -->

                    <execution>

                        <goals>

                            <goal>test-jar</goal>

                        </goals>

                    </execution>

                </executions>

            </plugin>

        </plugins>

    </build>

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright (c) 2007-2024 gvSIG Association

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.tools.patch;

import java.util.ArrayList;

import java.util.List;

import java.util.Objects;

import junit.framework.TestCase;

import org.apache.commons.lang3.tuple.ImmutablePair;

import org.apache.commons.lang3.tuple.Pair;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.util.ListBuilder;

/**

 *

 * @author fdiaz

 */

public class PatchGeneratorTest01 extends TestCase {

    public static int OP_INSERT = 1;

    public static int OP_DELETE = 2;

    public static int OP_MODIFY = 3;

    public static int OP_CONFLICT = 4;

    public static class TestItem {

        private final int id;

        private final String content;

        private final int revision;

        public TestItem(int id, String content, int revision) {

            this.id = id;

            this.content = content;

            this.revision = revision;

        }

        public int getId() {

            return id;

        }

        public String getContent() {

            return content;

        }

        public int getRevision() {

            return revision;

        }

        @Override

        public boolean equals(Object obj) {

            if(!(obj instanceof TestItem)){

                return false;

            }

            TestItem other = (TestItem)obj;

            if(other.hashCode() != this.hashCode()) {

                return false;

            }

//            if(id != other.getId()){

//                return false;

//            }

//            if(!StringUtils.equals(content, other.getContent())){

//                return false;

//            }

//            if(revision != other.getRevision()){

//                return false;

//            }

            return true;

        }

        @Override

        public int hashCode() {

            int hash = 3;

            hash = 13 * hash + this.id;

            hash = 13 * hash + Objects.hashCode(this.content);

            hash = 13 * hash + this.revision;

            return hash;

        }

    }

    public static class TestPatchHandler implements PatchGeneratorImpl.PatchHandler<TestItem> {

        private final List<TestItem> localChanges;

        private final List<Pair<Integer,TestItem>> remoteChanges;

        public TestPatchHandler(List<TestItem> localChanges) {

            this.localChanges = localChanges;

            this.remoteChanges = new ArrayList<>();

        }

        @Override

        public int compareId(TestItem r, TestItem l) {

            return Integer.compare(r.getId(), l.getId());

        }

        @Override

        public boolean isNew(TestItem l) {

            return l.getId() < 0;

        }

        @Override

        public boolean isLocalChange(TestItem l) {

            return localChanges.contains(l);

        }

        @Override

        public boolean isRemoteChange(TestItem r, TestItem l) {

            return r.getRevision() != l.getRevision();

        }

        @Override

        public void addRemoteChangeDelete(TestItem r, boolean conflict) {

            if(conflict){

                this.remoteChanges.add(new ImmutablePair<>(OP_CONFLICT, r));

            } else {

                this.remoteChanges.add(new ImmutablePair<>(OP_DELETE, r));

            }

        }

        @Override

        public void addRemoteChangeModify(TestItem r, boolean conflict) {

            //FIXME: Ver que pasa con el conflicto

            if(conflict){

                this.remoteChanges.add(new ImmutablePair<>(OP_CONFLICT, r));

            } else {

                this.remoteChanges.add(new ImmutablePair<>(OP_MODIFY, r));

            }

        }

        @Override

        public void addRemoteChangeInsert(TestItem r) {

            this.remoteChanges.add(new ImmutablePair<>(OP_INSERT, r));

        }

        public List<Pair<Integer,TestItem>> getRemoteChanges() {

            return this.remoteChanges;

        }

    }

    public PatchGeneratorTest01(String testName) {

        super(testName);

    }

    public void test01RemoteDelete() {

        List<TestItem> localChanges = ListBuilder.create(

        );

        TestPatchHandler handler = new TestPatchHandler(localChanges);

        PatchGenerator patch = PatchGenerator.create(handler);

        List<TestItem> remote = ListBuilder.create(

            new TestItem(1, "A", 1),

            new TestItem(3, "C", 1),

            new TestItem(4, "D", 1)

        );

        List<TestItem> local = ListBuilder.create(

            new TestItem(1, "A", 1),

            new TestItem(2, "B", 1),

            new TestItem(3, "C", 1),

            new TestItem(4, "D", 1)

        );

        patch.generate(remote.iterator(), local.iterator(), SimpleTaskStatus.FAKE_STATUS);

        List<Pair<Integer, TestItem>> remoteChanges = handler.getRemoteChanges();

        assertEquals(1, remoteChanges.size());

        assertEquals(OP_DELETE, remoteChanges.get(0).getLeft().intValue());

        assertEquals(2, remoteChanges.get(0).getRight().id);

    }

    public void test02LocalDelete() {

        List<TestItem> localChanges = ListBuilder.create(

        );

        TestPatchHandler handler = new TestPatchHandler(localChanges);

        PatchGenerator patch = PatchGenerator.create(handler);

        List<TestItem> remote = ListBuilder.create(

            new TestItem(1, "A", 1),

            new TestItem(2, "B", 1),

            new TestItem(3, "C", 1),

            new TestItem(4, "D", 1)

        );

        List<TestItem> local = ListBuilder.create(

            new TestItem(1, "A", 1),

            new TestItem(3, "C", 1),

            new TestItem(4, "D", 1)

        );

        patch.generate(remote.iterator(), local.iterator(), SimpleTaskStatus.FAKE_STATUS);

        List<Pair<Integer, TestItem>> remoteChanges = handler.getRemoteChanges();

        assertEquals(0, remoteChanges.size());

    }

    public void test03LocalNew() {

        List<TestItem> localChanges = ListBuilder.create(

            new TestItem(-1, "E", 1)

        );

        TestPatchHandler handler = new TestPatchHandler(localChanges);

        PatchGenerator patch = PatchGenerator.create(handler);

        List<TestItem> remote = ListBuilder.create(

            new TestItem(1, "A", 1),

            new TestItem(2, "B", 1),

            new TestItem(3, "C", 1),

            new TestItem(4, "D", 1)

        );

        List<TestItem> local = ListBuilder.create(

            new TestItem(1, "A", 1),

            new TestItem(3, "C", 1),

            new TestItem(4, "D", 1)

        );

        patch.generate(remote.iterator(), local.iterator(), SimpleTaskStatus.FAKE_STATUS);

        List<Pair<Integer, TestItem>> remoteChanges = handler.getRemoteChanges();

        assertEquals(0, remoteChanges.size());

    }

    public void test04RemoteModify() {

        List<TestItem> localChanges = ListBuilder.create(

            new TestItem(-1, "E", 1)

        );

        TestPatchHandler handler = new TestPatchHandler(localChanges);

        PatchGenerator patch = PatchGenerator.create(handler);

        List<TestItem> remote = ListBuilder.create(

            new TestItem(1, "A", 1),

            new TestItem(2, "B2", 2),

            new TestItem(3, "C", 1),

            new TestItem(4, "D", 1)

        );

        List<TestItem> local = ListBuilder.create(

            new TestItem(1, "A", 1),

            new TestItem(2, "B", 1),

            new TestItem(3, "C", 1),

            new TestItem(4, "D", 1)

        );

        patch.generate(remote.iterator(), local.iterator(), SimpleTaskStatus.FAKE_STATUS);

        List<Pair<Integer, TestItem>> remoteChanges = handler.getRemoteChanges();

        assertEquals(1, remoteChanges.size());

        assertEquals(OP_MODIFY, remoteChanges.get(0).getLeft().intValue());

        assertEquals(2, remoteChanges.get(0).getRight().id);

    }

    public void test05Conflict() {

        List<TestItem> localChanges = ListBuilder.create(

            new TestItem(-1, "E", 1),

            new TestItem(2, "B3", 1)

        );

        TestPatchHandler handler = new TestPatchHandler(localChanges);

        PatchGenerator patch = PatchGenerator.create(handler);

        List<TestItem> remote = ListBuilder.create(

            new TestItem(1, "A", 1),

            new TestItem(2, "B2", 2),

            new TestItem(3, "C", 1),

            new TestItem(4, "D", 1)

        );

        List<TestItem> local = ListBuilder.create(

            new TestItem(1, "A", 1),

            new TestItem(2, "B3", 1),

            new TestItem(3, "C", 1),

            new TestItem(4, "D", 1)

        );

        patch.generate(remote.iterator(), local.iterator(), SimpleTaskStatus.FAKE_STATUS);

        List<Pair<Integer, TestItem>> remoteChanges = handler.getRemoteChanges();

        assertEquals(1, remoteChanges.size());

        assertEquals(OP_CONFLICT, remoteChanges.get(0).getLeft().intValue());

        assertEquals(2, remoteChanges.get(0).getRight().id);

    }

    public void test06RemoteNew() {

        List<TestItem> localChanges = ListBuilder.create(

            new TestItem(-1, "E", 1)

        );

        TestPatchHandler handler = new TestPatchHandler(localChanges);

        PatchGenerator patch = PatchGenerator.create(handler);

        List<TestItem> remote = ListBuilder.create(

            new TestItem(1, "A", 1),

            new TestItem(2, "B", 1),

            new TestItem(3, "C", 1),

            new TestItem(4, "D", 1),

            new TestItem(5, "E", 1)

        );

        List<TestItem> local = ListBuilder.create(

            new TestItem(1, "A", 1),

            new TestItem(2, "B", 1),

            new TestItem(3, "C", 1),

            new TestItem(4, "D", 1)

        );

        patch.generate(remote.iterator(), local.iterator(), SimpleTaskStatus.FAKE_STATUS);

        List<Pair<Integer, TestItem>> remoteChanges = handler.getRemoteChanges();

        assertEquals(1, remoteChanges.size());

        assertEquals(OP_INSERT, remoteChanges.get(0).getLeft().intValue());

        assertEquals(5, remoteChanges.get(0).getRight().id);

    }

    public void test07All() {

        List<TestItem> localChanges = ListBuilder.create(

            new TestItem(-1, "E", 1),

            new TestItem(4, "DD", 1)

        );

        TestPatchHandler handler = new TestPatchHandler(localChanges);

        PatchGenerator patch = PatchGenerator.create(handler);

        List<TestItem> remote = ListBuilder.create(

            new TestItem(2, "B", 1),

            new TestItem(3, "C2", 2),

            new TestItem(4, "D2", 2),

            new TestItem(5, "E", 1)

        );

        List<TestItem> local = ListBuilder.create(

            new TestItem(1, "A", 1),

            new TestItem(3, "C", 1),

            new TestItem(4, "DD", 1)

        );

        patch.generate(remote.iterator(), local.iterator(), SimpleTaskStatus.FAKE_STATUS);

        List<Pair<Integer, TestItem>> remoteChanges = handler.getRemoteChanges();

        assertEquals(4, remoteChanges.size());

        assertEquals(OP_DELETE, remoteChanges.get(0).getLeft().intValue());

        assertEquals(1, remoteChanges.get(0).getRight().id);

        assertEquals(OP_MODIFY, remoteChanges.get(1).getLeft().intValue());

        assertEquals(3, remoteChanges.get(1).getRight().id);

        assertEquals(OP_CONFLICT, remoteChanges.get(2).getLeft().intValue());

        assertEquals(4, remoteChanges.get(2).getRight().id);

        assertEquals(OP_INSERT, remoteChanges.get(3).getLeft().intValue());

        assertEquals(5, remoteChanges.get(3).getRight().id);

    }

}

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright (c) 2007-2024 gvSIG Association

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.tools.patch;

import java.util.Iterator;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.task.UserCancelTaskException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author fdiaz

 */

class PatchGeneratorImpl<T> implements PatchGenerator<T> {

    public static final Logger LOGGER = LoggerFactory.getLogger(PatchGeneratorImpl.class);

    private final PatchHandler handler;

    PatchGeneratorImpl(PatchHandler handler) {

        this.handler = handler;

    }

    @Override

    public void generate(Iterator<T> r, Iterator<T> l, SimpleTaskStatus status) {

        I18nManager i18n = ToolsLocator.getI18nManager();

        if (status == null) {

            status = ToolsLocator.getTaskStatusManager().createDefaultSimpleTaskStatus(i18n.getTranslation("_Generating_patch"));

            status.setAutoremove(true);

            status.add();

        } else {

            status.push();

        }

        try {

            T remoteItem = null;

            T localItem = null;

            if (r.hasNext()) {

                remoteItem = r.next();

            }

            if (l.hasNext()) {

                localItem = l.next();

            }

            while (true) {

                if (status.isCancellationRequested()) {

                    throw new UserCancelTaskException();

                }

                if (localItem == null) {

                    if (remoteItem == null) {

                        break;

                    } else {

                        //nuevo en REMOTO

                        handler.addRemoteChangeInsert(remoteItem);

                        if (r.hasNext()) {

                            remoteItem = r.next();

                        } else {

                            remoteItem = null;

                        }

                    }

                } else if (handler.isNew(localItem)) {

                    //nuevo en LOCAL, do nothing

                    if (l.hasNext()) {

                        localItem = l.next();

                    } else {

                        localItem = null;

                    }

                } else if (remoteItem == null || (remoteItem != null && handler.compareId(remoteItem, localItem) > 0)) {

                    //Hay un borrado remoto, 

                    if (handler.isLocalChange(localItem)) {

                        handler.addRemoteChangeDelete(localItem, true);

                    } else {

                        handler.addRemoteChangeDelete(localItem, false);

                    }

                    if (l.hasNext()) {

                        localItem = l.next();

                    } else {

                        localItem = null;

                    }

                } else if (remoteItem != null && handler.compareId(remoteItem, localItem) < 0) {

                    //Hay un borrado local o un insert remoto

                    if (handler.isLocalChange(remoteItem)) {

                        //Do nothing

                    } else {

                        handler.addRemoteChangeInsert(remoteItem);

                    }

                    if (r.hasNext()) {

                        remoteItem = r.next();

                    } else {

                        remoteItem = null;

                    }

                } else if (remoteItem != null) { // && handler.compare(remoteItem, localItem)!=0) { //same element, but changed

                    if (handler.isLocalChange(localItem)) {

                        if (handler.isRemoteChange(remoteItem, localItem)) {

                            //conflicto

                            handler.addRemoteChangeModify(remoteItem, true);

                        } else {

                            //Hay modificaci?n local, do nothing

                        }

                    } else {

                        if (handler.isRemoteChange(remoteItem, localItem)) {

                            //cambio remoto sin conflicto

                            handler.addRemoteChangeModify(remoteItem, false);

                        } else {

                            //No es modificacion ni en local ni en remoto, no ha cambios. Do nothing

                        }

                    }

                    if (l.hasNext()) {

                        localItem = l.next();

                    } else {

                        localItem = null;

                    }

                    if (r.hasNext()) {

                        remoteItem = r.next();

                    } else {

                        remoteItem = null;

                    }

                } else {

                    if (l.hasNext()) {

                        localItem = l.next();

                    } else {

                        localItem = null;

                    }

                    if (r.hasNext()) {

                        remoteItem = r.next();

                    } else {

                        remoteItem = null;

                    }

                }

            }

            status.terminate();

        } catch (UserCancelTaskException ex) {

            status.cancel();

            throw ex;

        } catch (Exception ex) {

            status.abort();

            throw ex;

        } finally {

            status.pop();

        }

    }

}

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright (c) 2007-2024 gvSIG Association

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.tools.patch;

import java.util.Iterator;

import org.gvsig.tools.task.SimpleTaskStatus;

/**

 *

 * @author fdiaz

 */

public interface PatchGenerator<T> {

    public static PatchGenerator create(PatchHandler handler) {

        return new PatchGeneratorImpl(handler);

    }

    void generate(Iterator<T> r, Iterator<T> l, SimpleTaskStatus status);

    public interface PatchHandler<T> {

        public int compareId(T r, T l);

        public boolean isNew(T l);

        public boolean isLocalChange(T l);

        public boolean isRemoteChange(T r, T l);

        public void addRemoteChangeDelete(T r, boolean conflict);

        public void addRemoteChangeModify(T r, boolean conflict);

        public void addRemoteChangeInsert(T r);

    }

}

        while (geoms.hasNext()) {

            Geometry g = geoms.next();

            if (g != null) {

                cells.addAll(calculateCell(cellSize, g));

            }

                            ((EditableFeature)feature).set(FEATURECODE_FIELD_NAME, workspace.createUniqueCodeLong(store.getName()));

                            feature.set(FEATURECODE_FIELD_NAME, workspace.createUniqueCodeLong(store.getName()));

import java.util.logging.Level;

import org.gvsig.expressionevaluator.GeometryExpressionBuilder;

import org.gvsig.fmap.dal.feature.FeatureQuery;

import org.gvsig.fmap.geom.GeometryException;

import org.gvsig.json.JsonObjectBuilder;

import org.gvsig.online.lib.api.workingcopy.WorkingArea;

import org.gvsig.tools.patch.PatchGenerator;

import org.gvsig.online.lib.api.workingcopy.OnlineChanges;

    public static final String CONFIG_CURRENT_WORKINGAREA = "CURRENT_WORKINGAREA";

    private WorkingArea currentWorkingArea;

                CONFIG_ENTITY_LABEL_TEMPLATE,

                CONFIG_CURRENT_WORKINGAREA

        this.currentWorkingArea = (WorkingAreaImpl) Json.toObject(vars.get(CONFIG_CURRENT_WORKINGAREA));

//        this.refreshCodeGeneratorSequence();

    public final long createUniqueCodeLong(String entityName) {

        if(!this.codeGenerator.isInitialized(entityName)){

            this.refreshCodeGeneratorSequence(entityName);

        }

        return this.codeGenerator.generateCodelong(entityName);

            entity.setState(STATE_LOCAL_UNMODIFIED);

            Feature previousChange = null;

                previousChange = changesStore.findFirst(WorkspaceChangesTable.FEATUREID + " = '" + featureCode + "'"); // and " + WorkspaceChangesTable.OPERATION+ " = " + operation);

                                //TODO: Migrar a VCSGIS

                                if(previousChange != null ) {

                                    WorkspaceChangeRow change = new WorkspaceChangeRow(this, previousChange);

                                    if(change.getStatus() == STATE_CONFLICT){

                                        change.setStatus(STATE_LOCAL_MODIFIED);

                                        change.update(changesStore);

                                    }

                                }

    public OnlineChanges<OnlineWorkingcopyChange> getLocalChanges() {

    public OnlineChanges<OnlineWorkingcopyChange> getLocalChanges(List<OnlineEntity> entities) {

    public OnlineChanges<OnlineRemoteChange> getRemoteChanges() {

    public OnlineChanges<OnlineRemoteChange> getRemoteChangesByEntity(String... entityNames) {

            IProjection layerProjection = layer.getProjection();

            String geometryName = store.getDefaultFeatureTypeQuietly().getDefaultGeometryAttributeName();

                    JsonObject feature_online_json = it.next();

                    JsonObject feature_desktop_json = convertOnlineToDesktopFeature(feature_online_json, geometryName, geomManager, layerProjection);

                    if(feature_desktop_json == null){

                        continue;

                    EditableFeature feature = store.createNewFeature(feature_desktop_json);

                    store.insert(feature);

//                    

//                    EditableFeature feature = null;

//                    Geometry geom = null;

//                    JsonObject properties = feature_json.getJsonObject("properties");

//                    JsonObject geom_json = feature_json.getJsonObject("geometry");

//                    if( geom_json!=null ) {

//                        geom = geomManager.createFrom(geom_json);

//                        if( geom.getProjection()==null ) {

//                            geom.setProjection(layer.getProjection());

//                        }

//                    }

//                    if( properties==null ) {

//                        if( geom == null ) {

//                            continue;

//                        }

//                        feature = store.createNewFeature();                        

//                    } else {

//                        feature = store.createNewFeature(properties);

//                    }

//                    feature.setDefaultGeometry(geom);

//                    store.insert(feature); // Insert or replace

    private JsonObject convertOnlineToDesktopFeature(JsonObject online_json, String geometryName, GeometryManager geomManager, IProjection proj) {

        Geometry geom = null;

        JsonObject properties = online_json.getJsonObject("properties");

        JsonObject geom_json = online_json.getJsonObject("geometry");

        if (geom_json != null) {

            try {

                geom = geomManager.createFrom(geom_json);

            } catch (Exception ex) {

            }

            if (geom != null && geom.getProjection() == null) {

                geom.setProjection(proj);

            }

        }

        if (properties == null) {

            if (geom == null) {

                return null;

            }

            JsonObjectBuilder builder = Json.createObjectBuilder();

            builder.add(geometryName, geom.convertToHexWKBQuietly());

            return builder.build();

        }

        JsonObjectBuilder builder = Json.createObjectBuilder();

        if (geom == null) {

            builder.addNull(geometryName);

        } else {

            builder.add(geometryName, geom.convertToHexWKBQuietly());

        }

        builder.addAll(properties);

        return builder.build();

    }

    public int removeRemoteChanges(String entityCode) {

        return removeRemoteChanges(entityCode, null);

    public int removeRemoteChanges(String entityCode, SimpleTaskStatus status) {

        FeatureStore remoteChangesStore = null;

        FeatureStore localChangesStore = null;

        FeatureStore entitiesStore = null;

            remoteChangesStore = openFeatureStore(RemoteChangesTable.TABLE_NAME, false);

            localChangesStore = openFeatureStore(WorkspaceChangesTable.TABLE_NAME, false);

            entitiesStore = openFeatureStore(EntitiesTable.TABLE_NAME, false);

            removeRemoteChanges(remoteChangesStore, localChangesStore, entitiesStore, (EntityRow)entity);

            DisposeUtils.dispose(remoteChangesStore);

            DisposeUtils.dispose(localChangesStore);

            DisposeUtils.dispose(entitiesStore);

    private void removeRemoteChanges(FeatureStore remoteChangesStore, FeatureStore localChangesStore, FeatureStore entitiesStore, EntityRow entity) throws DataException {

        RemoteChangesTable remoteChangesTable = new RemoteChangesTable();

        remoteChangesTable.delete(remoteChangesStore, entity.getEntityCode());

        WorkspaceChangesTable localChangesTable = new WorkspaceChangesTable();

        localChangesTable.changeState(localChangesStore, entity.getEntityCode(), STATE_CONFLICT, STATE_LOCAL_UNMODIFIED);

        if(entity.getState() == STATE_CONFLICT){

            entity.setState(STATE_LOCAL_MODIFIED);

            boolean needFinish = false;

            if(entitiesStore.getMode() == FeatureStore.MODE_QUERY){

                entitiesStore.edit(MODE_PASS_THROUGH);

                needFinish = true;

            }

            entity.update(entitiesStore);

            if(needFinish){

                entitiesStore.finishEditing();

            }

        }

    }

                        Feature f = userStore.findFirst("\"" + lentity.getFeatureIdFieldName() + "\" = " + remoteChangeRow.getRelatedFeatureCode());

                                    userStore.delete("\"" + dataCodeFieldName + "\"=" + remoteChangeRow.getRelatedFeatureCode());

                                    String localEntityName = lentity.getEntityName();

                                    long newRelatedFeatureCode = this.createUniqueCodeLong(localEntityName);

                                    ef.setLong(lentity.getFeatureIdFieldName(), newRelatedFeatureCode);

                                    workspaceChangesStore.delete("\"" + WorkspaceChangesTable.FEATUREID + "\"=" + remoteChangeRow.getRelatedFeatureCode());

                                    LOGGER.debug("===: UPDATE: add insert operation to RelatedFeatureCode " + newRelatedFeatureCode);

    public int synchronize(OnlineEntity entity, Envelope workingArea, SimpleTaskStatus status) {

        Iterator<Geometry> geoms2 = null;

        DisposableIterator<Feature> remoteIt = null;

        DisposableIterator<Feature> localIt = null;

        FeatureStore localChangesStore = null;

        FeatureStore remoteChangesStore = null;

        FeatureStore entitiesStore = null;

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

            OnlineWorkspaceImpl wc = this;

                    Feature f = it.next();

                    WorkspaceChangeRow row = new WorkspaceChangeRow(wc, f);

                    if (row.getOperation() == OP_DELETE) {

                        return null;

                    }

                    return row.getRelatedFeature().getDefaultGeometry();

            DisposableFeatureSetIterable it2 = wct.getSelectedsByEntityCodeAsIterator(this, entity.getEntityCode());

            geoms2 = new Iterator<Geometry>() {

                @Override

                public boolean hasNext() {

                    return it2.hasNext();

                }

                @Override

                public Geometry next() {

                    try {

                        Feature f = it2.next();

                        WorkspaceChangeRow row = new WorkspaceChangeRow(wc, f);

                        JsonObject dataAsJson = row.getDataAsJson();

                        if(dataAsJson == null){

                            return null;

                        }

                        String geom_wkb = dataAsJson.getString(entity.getGeometryFieldName());

                        if(geom_wkb == null) {

                            return null;

                        }

                        return geomManager.createFrom(geom_wkb);

                    } catch (GeometryException ex) {

                        LOGGER.warn("Can't get geometry of workspace change", ex);

                        return null;

                    }

                }

            };

            List<Envelope> envs = tilesCalculator.calculateEnvelopes(

                entity.getTileSize(), 

                new ChainedIterator<>(