feat: create ref from commit id

core/src/main/java/org/openmbee/mms/core/services/BranchService.java

@@ -10,6 +10,7 @@ public interface BranchService {
     RefsResponse getBranch(String projectId, String id);
 
     RefJson createBranch(String projectId, RefJson branch);
+    RefJson createBranchfromCommit(String projectId, RefJson branch, NodeService nodeService);
 
     RefsResponse deleteBranch(String projectId, String id);
 }

crud/src/main/java/org/openmbee/mms/crud/controllers/branches/BranchesController.java

@@ -96,9 +96,7 @@ public RefsResponse createRefs(
                 if (branch.getParentCommitId() == null || branch.getParentCommitId().isEmpty()) {
                     res = branchService.createBranch(projectId, branch);
                 } else {
-                    //TODO implement branching from historical commit
-                    response.addRejection(new Rejection(branch, 400, "Branching from historical commits is not implemented."));
-                    continue;
+                    res = branchService.createBranchfromCommit(projectId, branch, getNodeService(projectId));
                 }
 
                 permissionService.initBranchPerms(projectId, branch.getId(), true, auth.getName());

crud/src/main/java/org/openmbee/mms/crud/services/DefaultBranchService.java

@@ -5,11 +5,7 @@
 import org.openmbee.mms.core.config.Constants;
 import org.openmbee.mms.core.config.ContextHolder;
 import org.openmbee.mms.core.config.Formats;
-import org.openmbee.mms.core.dao.BranchDAO;
-import org.openmbee.mms.core.dao.BranchIndexDAO;
-import org.openmbee.mms.core.dao.CommitDAO;
-import org.openmbee.mms.core.dao.NodeDAO;
-import org.openmbee.mms.core.dao.NodeIndexDAO;
+import org.openmbee.mms.core.dao.*;
 import org.openmbee.mms.core.exceptions.BadRequestException;
 import org.openmbee.mms.core.exceptions.DeletedException;
 import org.openmbee.mms.core.exceptions.InternalErrorException;
@@ -18,9 +14,11 @@
 import org.openmbee.mms.core.objects.RefsResponse;
 import org.openmbee.mms.core.services.BranchService;
 import org.openmbee.mms.core.services.EventService;
+import org.openmbee.mms.core.services.NodeService;
 import org.openmbee.mms.data.domains.scoped.Branch;
 import org.openmbee.mms.data.domains.scoped.Commit;
 import org.openmbee.mms.data.domains.scoped.Node;
+import org.openmbee.mms.json.ElementJson;
 import org.openmbee.mms.json.RefJson;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -45,6 +43,15 @@
     private NodeIndexDAO nodeIndex;
 
     protected Collection<EventService> eventPublisher;
+    protected NodeGetHelper nodeGetHelper;
+
+
+
+    @Autowired
+    public void setNodeGetHelper(NodeGetHelper nodeGetHelper) {
+        this.nodeGetHelper = nodeGetHelper;
+    }
+
 
     @Autowired
     public void setBranchRepository(BranchDAO branchRepository) {
@@ -145,18 +152,26 @@
             b.setParentRefId(Constants.MASTER_BRANCH);
         }
 
-        //This service cannot create branches from historic versions
-        if (branch.getParentCommitId() != null) {
-            throw new BadRequestException("Internal Error: Invalid branch creation logic.");
-        }
-
         Optional<Branch> refOption = branchRepository.findByBranchId(b.getParentRefId());
         if (refOption.isPresent()) {
-            Optional<Commit> parentCommit = commitRepository.findLatestByRef(refOption.get());
-            parentCommit.ifPresent(parent -> {
-                b.setParentCommit(parent.getId());
-                branch.setParentCommitId(parent.getCommitId()); //commit id is same as its docId
-            });
+            if(branch.getParentCommitId() != null){
+                Optional<Commit> commitRequestId = commitRepository.findByCommitId(branch.getParentCommitId());
+                commitRequestId.ifPresentOrElse(commit -> {
+                    Optional<Commit> parentCommit = commitRepository.findByRefAndTimestamp(refOption.get(), commit.getTimestamp());
+                    parentCommit.ifPresent(parent -> {
+                        b.setParentCommit(parent.getId());
+                        branch.setParentCommitId(parent.getCommitId());
+                    });
+                },
+                    () -> { throw new BadRequestException(new RefsResponse().addMessage("parentCommitId not found " + now.toString()));
+                });
+            } else {
+                Optional<Commit> parentCommit = commitRepository.findLatestByRef(refOption.get());
+                parentCommit.ifPresent(parent -> {
+                    b.setParentCommit(parent.getId());
+                    branch.setParentCommitId(parent.getCommitId()); //commit id is same as its docId
+                });
+            }
         }
 
         if (b.getParentCommit() == null) {
@@ -181,6 +196,55 @@
             throw new InternalErrorException(e);
         }
     }
+    public RefJson createBranchfromCommit(String projectId, RefJson parentCommitIdRef, NodeService nodeService) {
+        Instant now = Instant.now();
+
+        if(parentCommitIdRef.getParentCommitId().isEmpty()){
+            throw new BadRequestException(new RefsResponse().addMessage("parentCommitId not provided " + now.toString()));
+        }
+
+        ContextHolder.setContext(projectId);
+        Optional<Commit> parentCommit = commitRepository.findByCommitId(parentCommitIdRef.getParentCommitId());
+
+        // Get Commit object
+        String parentCommitID = parentCommit.map(Commit::getCommitId).orElseThrow(() ->
+            new BadRequestException(new RefsResponse().addMessage("parentCommitId not found " + now.toString())));
+
+        // Get Commit parentRef, the branch will be created from this
+        String parentRef = parentCommit.map(Commit::getBranchId).orElseThrow(() ->
+            new BadRequestException(new RefsResponse().addMessage("Ref from parentCommitId not found"  + now.toString())));
+
+        parentCommitIdRef.setParentRefId(parentRef);
+        ContextHolder.setContext(projectId, parentRef);
+
+        RefJson branchFromCommit = this.createBranch(projectId, parentCommitIdRef);
+
+        ContextHolder.setContext(projectId, branchFromCommit.getRefId());
+
+        // Get current nodes from database
+        List<Node> nodes = nodeRepository.findAll();
+        // Get elements from index
+        Collection<ElementJson> result = nodeGetHelper.processGetJsonFromNodes(nodes, parentCommitID, nodeService)
+            .getActiveElementMap().values();
+
+        Map<String, ElementJson> nodeCommitData = new HashMap<>();
+        for (ElementJson element : result) {
+            nodeCommitData.put(element.getId(), element);
+        }
+
+        // Update database table to match index
+        for (Node node : nodes) {
+            if(nodeCommitData.containsKey(node.getNodeId())){
+                node.setDocId(nodeCommitData.get(node.getNodeId()).getDocId());
+                node.setDeleted(false);
+            } else {
+                node.setDeleted(true);
+            }
+        }
+        nodeRepository.updateAll(nodes);
+
+        return branchFromCommit;
+    }
 
     public RefsResponse deleteBranch(String projectId, String id) {
         ContextHolder.setContext(projectId);

crud/src/main/java/org/openmbee/mms/crud/services/NodeGetHelper.java

@@ -129,6 +129,7 @@ private NodeGetInfo processCommit(NodeGetInfo info, String commitId, NodeService
                     rejectNotFound(info, nodeId); // element not found at commit time
                 }
             } else if (info.getExistingNodeMap().get(nodeId).isDeleted()) { // latest element is before commit, but deleted
+                // TODO check if time of deletion is after the commit time
                 rejectDeleted(info, nodeId, indexElement);
             } else { // latest element version is version at commit, not deleted
                 info.getActiveElementMap().put(nodeId, indexElement);