Start docker compoose.

wise-api/src/main/java/com/wisemapping/dao/LabelManager.java

@@ -0,0 +1,26 @@
+package com.wisemapping.dao;
+
+import com.wisemapping.model.Label;
+import com.wisemapping.model.User;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+public interface LabelManager {
+
+    void addLabel(@NotNull final Label label);
+
+    void saveLabel(@NotNull final Label label);
+
+    @NotNull
+    List<Label> getAllLabels(@NotNull final User user);
+
+    @Nullable
+    Label getLabelById(int id, @NotNull final User user);
+
+    @Nullable
+    Label getLabelByTitle(@NotNull final String title, @NotNull final User user);
+
+    void removeLabel(@NotNull final Label label);
+}

wise-api/src/main/java/com/wisemapping/dao/LabelManagerImpl.java

@@ -0,0 +1,89 @@
+/*
+ *    Copyright [2022] [wisemapping]
+ *
+ *   Licensed under WiseMapping Public License, Version 1.0 (the "License").
+ *   It is basically the Apache License, Version 2.0 (the "License") plus the
+ *   "powered by wisemapping" text requirement on every single page;
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the license at
+ *
+ *       http://www.wisemapping.org/license
+ *
+ *   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.
+ */
+package com.wisemapping.dao;
+
+import com.wisemapping.model.Label;
+import com.wisemapping.model.User;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.TypedQuery;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository("labelManager")
+public class LabelManagerImpl
+        implements LabelManager {
+    @Autowired
+    private EntityManager entityManager;
+
+    @Override
+    public void addLabel(@NotNull final Label label) {
+        saveLabel(label);
+    }
+
+    @Override
+    public void saveLabel(@NotNull final Label label) {
+        entityManager.persist(label);
+    }
+
+    @NotNull
+    @Override
+    public List<Label> getAllLabels(@NotNull final User user) {
+        final TypedQuery<Label> query = entityManager.createQuery("from com.wisemapping.model.Label wisemapping where creator=:creatorId", Label.class);
+        query.setParameter("creatorId", user);
+        return query.getResultList();
+    }
+
+    @Nullable
+    @Override
+    public Label getLabelById(int id, @NotNull final User user) {
+        final TypedQuery<Label> query = entityManager.createQuery("from com.wisemapping.model.Label wisemapping where id=:id and creator=:creator", Label.class);
+        query.setParameter("id", id);
+        query.setParameter("creator", user);
+
+        final List<Label> resultList = query.getResultList();
+        return getFirst(resultList);
+    }
+
+    @Nullable
+    @Override
+    public Label getLabelByTitle(@NotNull String title, @NotNull final User user) {
+        final TypedQuery<Label> query = entityManager.createQuery("from com.wisemapping.model.Label wisemapping where title=:title and creator=:creator", Label.class);
+        query.setParameter("title", title);
+        query.setParameter("creator", user);
+        return query.getResultList().stream().findFirst().orElse(null);
+    }
+
+    @Override
+    public void removeLabel(@NotNull Label label) {
+        entityManager.remove(label);
+    }
+
+    @Nullable
+    private Label getFirst(final List<Label> labels) {
+        Label result = null;
+        if (labels != null && !labels.isEmpty()) {
+            result = labels.get(0);
+        }
+        return result;
+    }
+
+}

wise-api/src/main/java/com/wisemapping/dao/MindmapManager.java

@@ -0,0 +1,59 @@
+/*
+*    Copyright [2022] [wisemapping]
+*
+*   Licensed under WiseMapping Public License, Version 1.0 (the "License").
+*   It is basically the Apache License, Version 2.0 (the "License") plus the
+*   "powered by wisemapping" text requirement on every single page;
+*   you may not use this file except in compliance with the License.
+*   You may obtain a copy of the license at
+*
+*       http://www.wisemapping.org/license
+*
+*   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.
+*/
+
+package com.wisemapping.dao;
+
+import com.wisemapping.model.*;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+public interface MindmapManager {
+
+    Collaborator findCollaborator(@NotNull String email);
+
+    List<Collaboration> findCollaboration(final int collaboratorId);
+
+    @Nullable
+    Mindmap getMindmapById(int mindmapId);
+
+    Mindmap getMindmapByTitle(final String name, final User user);
+
+    void addCollaborator(Collaborator collaborator);
+
+    void addMindmap(User user, Mindmap mindmap);
+
+    void saveMindmap(Mindmap mindmap);
+
+    void updateMindmap(@NotNull Mindmap mindmap, boolean saveHistory);
+
+    void removeCollaborator(@NotNull Collaborator collaborator);
+
+    void removeMindmap(Mindmap mindmap);
+
+    void removeCollaboration(Collaboration collaboration);
+
+    List<MindMapHistory> getHistoryFrom(int mindmapId);
+
+    MindMapHistory getHistory(int historyId);
+
+    void updateCollaboration(@NotNull Collaboration collaboration);
+
+    List<Mindmap> findMindmapByUser(User user);
+}

wise-api/src/main/java/com/wisemapping/dao/MindmapManagerImpl.java

@@ -0,0 +1,189 @@
+/*
+ *    Copyright [2022] [wisemapping]
+ *
+ *   Licensed under WiseMapping Public License, Version 1.0 (the "License").
+ *   It is basically the Apache License, Version 2.0 (the "License") plus the
+ *   "powered by wisemapping" text requirement on every single page;
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the license at
+ *
+ *       http://www.wisemapping.org/license
+ *
+ *   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.
+ */
+
+package com.wisemapping.dao;
+
+import com.wisemapping.model.*;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.TypedQuery;
+import jakarta.persistence.criteria.CriteriaBuilder;
+import jakarta.persistence.criteria.CriteriaDelete;
+import jakarta.persistence.criteria.CriteriaQuery;
+import jakarta.persistence.criteria.Root;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Repository;
+
+import java.util.Calendar;
+import java.util.List;
+
+@Repository("mindmapManager")
+public class MindmapManagerImpl
+        implements MindmapManager {
+
+    @Autowired
+    private EntityManager entityManager;
+
+    @Override
+    public Collaborator findCollaborator(@NotNull final String email) {
+        final Collaborator collaborator;
+        final TypedQuery<Collaborator> query = entityManager.createQuery("from com.wisemapping.model.Collaborator collaborator where email=:email", Collaborator.class);
+        query.setParameter("email", email);
+
+        final List<Collaborator> collaborators = query.getResultList();
+        if (collaborators != null && !collaborators.isEmpty()) {
+            assert collaborators.size() == 1 : "More than one user with the same email!";
+            collaborator = collaborators.get(0);
+        } else {
+            collaborator = null;
+        }
+        return collaborator;
+    }
+
+    @Override
+    public List<MindMapHistory> getHistoryFrom(int mindmapId) {
+        final CriteriaBuilder cb = entityManager.getCriteriaBuilder();
+
+        final CriteriaQuery<MindMapHistory> cr = cb.createQuery(MindMapHistory.class);
+        final Root<MindMapHistory> root = cr.from(MindMapHistory.class);
+
+        final CriteriaQuery<MindMapHistory> select = cr.select(root)
+                .where(cb.equal(root.get("mindmapId"), mindmapId))
+                .orderBy(cb.desc(root.get("creationTime")));
+
+        return entityManager.
+                createQuery(select)
+                .setMaxResults(30)
+                .getResultList();
+    }
+
+    @Override
+    public MindMapHistory getHistory(int historyId) {
+        return entityManager.find(MindMapHistory.class, historyId);
+    }
+
+    @Override
+    public void updateCollaboration(@NotNull Collaboration collaboration) {
+        entityManager.persist(collaboration);
+    }
+
+    @Override
+    public List<Mindmap> findMindmapByUser(@NotNull User user) {
+
+        final TypedQuery<Mindmap> query = entityManager
+                .createQuery("from com.wisemapping.model.Mindmap m where m.id in (select c.mindMap.id from com.wisemapping.model.Collaboration as c where c.collaborator.id=:collabId )", Mindmap.class);
+        query.setParameter("collabId", user.getId());
+
+        return query.getResultList();
+    }
+
+    @Override
+    public List<Collaboration> findCollaboration(final int collaboratorId) {
+        final TypedQuery<Collaboration> query = entityManager.createQuery("from com.wisemapping.model.Collaboration c where c.collaborator.id=:collaboratorId", Collaboration.class);
+        query.setParameter("collaboratorId", collaboratorId);
+        return query.getResultList();
+    }
+
+    @Override
+    public void addCollaborator(@NotNull Collaborator collaborator) {
+        assert collaborator != null : "ADD MINDMAP COLLABORATOR: Collaborator is required!";
+        entityManager.persist(collaborator);
+    }
+
+    @Override
+    public void removeCollaboration(Collaboration collaboration) {
+        entityManager.remove(collaboration);
+    }
+
+    @Override
+    public void removeCollaborator(@NotNull Collaborator collaborator) {
+        entityManager.remove(collaborator);
+    }
+
+    @Override
+    @Nullable
+    public Mindmap getMindmapById(int id) {
+        return entityManager.find(Mindmap.class, id);
+    }
+
+    @Override
+    public Mindmap getMindmapByTitle(final String title, final User user) {
+        final Mindmap result;
+        final TypedQuery<Mindmap> query = entityManager.createQuery("from com.wisemapping.model.Mindmap wisemapping where title=:title and creator=:creator", Mindmap.class);
+        query.setParameter("title", title);
+        query.setParameter("creator", user);
+
+        List<Mindmap> mindMaps = query.getResultList();
+
+        if (mindMaps != null && !mindMaps.isEmpty()) {
+            result = mindMaps.get(0);
+        } else {
+            result = null;
+        }
+        return result;
+    }
+
+    @Override
+    public void addMindmap(User user, Mindmap mindMap) {
+        saveMindmap(mindMap);
+    }
+
+    @Override
+    public void saveMindmap(Mindmap mindMap) {
+        assert mindMap != null : "Save Mindmap: Mindmap is required!";
+        entityManager.persist(mindMap);
+    }
+
+    @Override
+    public void updateMindmap(@NotNull Mindmap mindMap, boolean saveHistory) {
+        assert mindMap != null : "Save Mindmap: Mindmap is required!";
+        entityManager.merge(mindMap);
+        if (saveHistory) {
+            saveHistory(mindMap);
+        }
+    }
+
+    @Override
+    public void removeMindmap(@NotNull final Mindmap mindmap) {
+        // Delete history first ...
+        final CriteriaBuilder cb = entityManager.getCriteriaBuilder();
+
+        final CriteriaDelete<MindMapHistory> cr = cb.createCriteriaDelete(MindMapHistory.class);
+        final Root<MindMapHistory> root = cr.from(MindMapHistory.class);
+
+        final CriteriaDelete<MindMapHistory> deleteStatement = cr.where(cb.equal(root.get("mindmapId"), mindmap.getId()));
+        entityManager.createQuery(deleteStatement).executeUpdate();
+
+        // Remove collaborations ...
+        mindmap.removedCollaboration(mindmap.getCollaborations());
+
+        // Delete mindmap ....
+        entityManager.remove(mindmap);
+    }
+
+    private void saveHistory(@NotNull final Mindmap mindMap) {
+        final MindMapHistory history = new MindMapHistory();
+
+        history.setZippedXml(mindMap.getZippedXml());
+        history.setCreationTime(Calendar.getInstance());
+        history.setEditor(mindMap.getLastEditor());
+        history.setMindmapId(mindMap.getId());
+        entityManager.merge(history);
+    }
+}

wise-api/src/main/java/com/wisemapping/dao/UserManager.java

@@ -0,0 +1,50 @@
+/*
+*    Copyright [2022] [wisemapping]
+*
+*   Licensed under WiseMapping Public License, Version 1.0 (the "License").
+*   It is basically the Apache License, Version 2.0 (the "License") plus the
+*   "powered by wisemapping" text requirement on every single page;
+*   you may not use this file except in compliance with the License.
+*   You may obtain a copy of the license at
+*
+*       http://www.wisemapping.org/license
+*
+*   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.
+*/
+
+package com.wisemapping.dao;
+
+import com.wisemapping.model.AccessAuditory;
+import com.wisemapping.model.Collaborator;
+import com.wisemapping.model.User;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+public interface UserManager {
+
+    List<User> getAllUsers();
+
+    User getUserBy(String email);
+
+    User getUserBy(int id);
+
+    void createUser(User user);
+
+    void auditLogin(@NotNull AccessAuditory accessAuditory);
+
+    void updateUser(User user);
+
+    User getUserByActivationCode(long code);
+
+    Collaborator getCollaboratorBy(String email);
+
+    User createUser(User user, Collaborator col);
+
+    void removeUser(@NotNull User user);
+
+}

wise-api/src/main/java/com/wisemapping/dao/UserManagerImpl.java

@@ -0,0 +1,169 @@
+/*
+ *    Copyright [2022] [wisemapping]
+ *
+ *   Licensed under WiseMapping Public License, Version 1.0 (the "License").
+ *   It is basically the Apache License, Version 2.0 (the "License") plus the
+ *   "powered by wisemapping" text requirement on every single page;
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the license at
+ *
+ *       http://www.wisemapping.org/license
+ *
+ *   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.
+ */
+
+package com.wisemapping.dao;
+
+import com.wisemapping.model.*;
+import com.wisemapping.security.DefaultPasswordEncoderFactories;
+import com.wisemapping.security.LegacyPasswordEncoder;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.TypedQuery;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.CopyOnWriteArraySet;
+
+@Repository
+public class UserManagerImpl
+        implements UserManager {
+    @Autowired
+    private EntityManager entityManager;
+    @Autowired
+    private PasswordEncoder passwordEncoder;
+
+    public UserManagerImpl() {
+    }
+
+    public void setEncoder(PasswordEncoder passwordEncoder) {
+        this.passwordEncoder = passwordEncoder;
+    }
+
+    public List<User> getAllUsers() {
+        return entityManager.createQuery("from com.wisemapping.model.User user", User.class).getResultList();
+    }
+
+    @Override
+    @Nullable
+    public User getUserBy(@NotNull final String email) {
+        User user = null;
+
+        TypedQuery<User> query = entityManager.createQuery("from com.wisemapping.model.User colaborator where email=:email", User.class);
+        query.setParameter("email", email);
+
+        final List<User> users = query.getResultList();
+        if (users != null && !users.isEmpty()) {
+            assert users.size() == 1 : "More than one user with the same email!";
+            user = users.get(0);
+        }
+        return user;
+
+    }
+
+    @Override
+    public Collaborator getCollaboratorBy(final String email) {
+        final Collaborator result;
+
+        final TypedQuery<Collaborator> query = entityManager.createQuery("from com.wisemapping.model.Collaborator colaborator where " +
+                "email=:email", Collaborator.class);
+        query.setParameter("email", email);
+
+        final List<Collaborator> cols = query.getResultList();
+        if (cols != null && !cols.isEmpty()) {
+            assert cols.size() == 1 : "More than one colaborator with the same email!";
+            result = cols.get(0);
+        } else {
+            result = null;
+        }
+        return result;
+    }
+
+    @Nullable
+    @Override
+    public User getUserBy(int id) {
+        return entityManager.find(User.class, id);
+    }
+
+    @Override
+    public void createUser(User user) {
+        assert user != null : "Trying to store a null user";
+        if (!AuthenticationType.GOOGLE_OAUTH2.equals(user.getAuthenticationType())) {
+            user.setPassword(passwordEncoder.encode(user.getPassword()));
+        } else {
+            user.setPassword("");
+        }
+        entityManager.persist(user);
+    }
+
+    @Override
+    public User createUser(@NotNull User user, @NotNull Collaborator collaborator) {
+        assert user != null : "Trying to store a null user";
+
+        // Migrate from previous temporal collab to new user ...
+        collaborator.setEmail(collaborator.getEmail() + "_toRemove");
+        entityManager.merge(collaborator);
+        entityManager.flush();
+
+        // Save all new...
+        this.createUser(user);
+
+        // Update mindmap ...
+        final Set<Collaboration> collaborations = new CopyOnWriteArraySet<>(collaborator.getCollaborations());
+        for (Collaboration collabs : collaborations) {
+            collabs.setCollaborator(user);
+        }
+
+        // Delete old user ...
+        entityManager.remove(collaborator);
+        return user;
+    }
+
+    @Override
+    public void removeUser(@NotNull final User user) {
+        entityManager.remove(user);
+    }
+
+    public void auditLogin(@NotNull AccessAuditory accessAuditory) {
+        assert accessAuditory != null : "accessAuditory is null";
+        entityManager.persist(accessAuditory);
+    }
+
+    public void updateUser(@NotNull User user) {
+        assert user != null : "user is null";
+
+        // Does the password need to be encrypted ?
+        final String password = user.getPassword();
+        if (password != null && (!password.startsWith(LegacyPasswordEncoder.ENC_PREFIX) && !password.startsWith("{" + DefaultPasswordEncoderFactories.ENCODING_ID))) {
+            user.setPassword(passwordEncoder.encode(user.getPassword()));
+        }
+
+        entityManager.merge(user);
+    }
+
+    public User getUserByActivationCode(long code) {
+        final User user;
+
+        final TypedQuery<User> query = entityManager.createQuery("from com.wisemapping.model.User user where " +
+                "activationCode=:activationCode", User.class);
+        query.setParameter("activationCode", code);
+
+        final List<User> users = query.getResultList();
+        if (users != null && !users.isEmpty()) {
+
+            assert users.size() == 1 : "More than one user with the same username!";
+            user = users.get(0);
+        } else {
+            user = null;
+        }
+        return user;
+    }
+}