Project structure

Author: aek

pom.xml

@@ -31,6 +31,11 @@
             <artifactId>spring-boot-starter-test</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <optional>true</optional>
+        </dependency>
     </dependencies>
 
     <build>

src/main/java/com/tutorial/springdatamongodbdynamicqueries/controller/EmployeeController.java

@@ -0,0 +1,57 @@
+package com.tutorial.springdatamongodbdynamicqueries.controller;
+
+import com.tutorial.springdatamongodbdynamicqueries.domain.Employee;
+import com.tutorial.springdatamongodbdynamicqueries.service.EmployeeService;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.Optional;
+
+@RestController
+@RequestMapping("/employee")
+public class EmployeeController {
+
+    private final EmployeeService employeeService;
+
+    public EmployeeController(EmployeeService employeeService) {
+        this.employeeService = employeeService;
+    }
+
+
+    @GetMapping()
+    public List<Employee> get() {
+        return employeeService.getAll();
+
+    }
+
+    @PostMapping()
+    public Employee save(@RequestBody Employee employee) {
+        return employeeService.save(employee);
+    }
+
+    @PutMapping(value = "/{id}")
+    public Employee update(@PathVariable("id") String id, @RequestBody Employee employee) {
+
+        Optional<Employee> emp = employeeService.getById(id);
+        if (emp.isPresent()) {
+            emp.get().setFirstName(employee.getFirstName());
+            emp.get().setLastName(employee.getLastName());
+            emp.get().setEmail(employee.getEmail());
+
+            return employeeService.save(emp.get());
+        }
+        throw new RuntimeException("not found");
+
+    }
+
+    @GetMapping("/{id}")
+    public Employee getEmployeeById(@PathVariable(value = "id") String id) {
+        return employeeService.getById(id).orElseThrow(() -> new RuntimeException("not found"));
+    }
+    @DeleteMapping("/{id}")
+    public void deleteEmployee(@PathVariable(value = "id") String id) {
+        employeeService.deleteById(id);
+    }
+
+
+}

src/main/java/com/tutorial/springdatamongodbdynamicqueries/controller/dto/FilterCondition.java

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2019. @aek - (anicetkeric@gmail.com)
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  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.tutorial.springdatamongodbdynamicqueries.controller.dto;
+
+import com.tutorial.springdatamongodbdynamicqueries.enums.FilterOperationEnum;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import lombok.Setter;
+
+/**
+ * <h2>FilterCondition</h2>
+ *
+ * @author aek
+ * <p>
+ * Description: Filter Condition Class
+ */
+@Setter
+@Getter
+@AllArgsConstructor
+@RequiredArgsConstructor
+public class FilterCondition {
+
+    private String field;
+    private FilterOperationEnum operator;
+    private Object value;
+
+}

src/main/java/com/tutorial/springdatamongodbdynamicqueries/domain/Department.java

@@ -0,0 +1,17 @@
+package com.tutorial.springdatamongodbdynamicqueries.domain;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.NonNull;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class Department {
+
+    @NonNull
+    private String code;
+
+    private String name;
+}

src/main/java/com/tutorial/springdatamongodbdynamicqueries/domain/Employee.java

@@ -0,0 +1,27 @@
+package com.tutorial.springdatamongodbdynamicqueries.domain;
+
+import lombok.*;
+import lombok.experimental.Accessors;
+import org.springframework.data.annotation.Id;
+import org.springframework.data.mongodb.core.mapping.Document;
+
+@Builder
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@Accessors(chain = true)
+@Document(collection = "employee")
+public class Employee {
+
+    @Id
+    private String id;
+
+    private String firstName;
+
+    private String lastName;
+
+    private String email;
+
+    @NonNull
+    private Department department;
+}

src/main/java/com/tutorial/springdatamongodbdynamicqueries/enums/FilterOperationEnum.java

@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2019. @aek - (anicetkeric@gmail.com)
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  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.tutorial.springdatamongodbdynamicqueries.enums;
+
+import com.fasterxml.jackson.annotation.JsonValue;
+
+/**
+ * <h2>FilterOperation</h2>
+ *
+ * @author aek
+ * <p>
+ * Description:
+ */
+public enum FilterOperationEnum {
+
+    EQUAL("eq"),
+    NOT_EQUAL("neq"),
+    GREATER_THAN("gt"),
+    GREATER_THAN_OR_EQUAL_TO("gte"),
+    LESS_THAN("lt"),
+    LESSTHAN_OR_EQUAL_TO("lte"),
+    IN("in"),
+    NOT_IN("nin"),
+    BETWEEN("btn"),
+    CONTAINS("like"),
+    NOT_CONTAINS("notLike"),
+    IS_NULL("isnull"),
+    IS_NOT_NULL("isnotnull"),
+    START_WITH("startwith"),
+    END_WITH("endwith"),
+    IS_EMPTY("isempty"),
+    IS_NOT_EMPTY("isnotempty"),
+    JOIN("jn"),
+    IS("is");
+
+
+    private final String value;
+
+    FilterOperationEnum(String value) {
+        this.value = value;
+    }
+
+    @Override
+    @JsonValue
+    public String toString() {
+        return String.valueOf(value);
+    }
+
+    public static FilterOperationEnum fromValue(String value) {
+        for (FilterOperationEnum op : FilterOperationEnum.values()) {
+
+            //Case insensitive operation name
+            if (String.valueOf(op.value).equalsIgnoreCase(value)) {
+                return op;
+            }
+        }
+        return null;
+    }
+
+}

src/main/java/com/tutorial/springdatamongodbdynamicqueries/repository/EmployeeRepository.java

@@ -0,0 +1,8 @@
+package com.tutorial.springdatamongodbdynamicqueries.repository;
+
+import com.tutorial.springdatamongodbdynamicqueries.domain.Employee;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface EmployeeRepository extends ResourceRepository<Employee, String> {
+}

src/main/java/com/tutorial/springdatamongodbdynamicqueries/repository/ResourceRepository.java

@@ -0,0 +1,15 @@
+package com.tutorial.springdatamongodbdynamicqueries.repository;
+
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.data.mongodb.repository.MongoRepository;
+import org.springframework.data.repository.NoRepositoryBean;
+
+import java.io.Serializable;
+
+@NoRepositoryBean
+public interface ResourceRepository<T, I extends Serializable> extends MongoRepository<T, I> {
+
+    Page<T> findAll(Query query, Pageable pageable);
+}

src/main/java/com/tutorial/springdatamongodbdynamicqueries/repository/support/GenericFilterCriteriaBuilder.java

@@ -0,0 +1,98 @@
+package com.tutorial.springdatamongodbdynamicqueries.repository.support;
+
+import com.tutorial.springdatamongodbdynamicqueries.controller.dto.FilterCondition;
+import org.bson.types.ObjectId;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+/**
+ * This class is used to build all the queries passed as parameters.
+ * filterAndConditions (filter list for the AND operator)
+ * filterOrConditions (filter list for the OR operator)
+ */
+public class GenericFilterCriteriaBuilder {
+
+    private final List<FilterCondition> filterAndConditions;
+    private final List<FilterCondition> filterOrConditions;
+
+    private static final Map<String, Function<FilterCondition, Criteria>>
+            FILTER_CRITERIA = new HashMap<>();
+
+    public GenericFilterCriteriaBuilder() {
+        filterOrConditions = new ArrayList<>();
+        filterAndConditions = new ArrayList<>();
+    }
+
+    public Query addCondition(List<FilterCondition> andConditions, List<FilterCondition> orConditions) {
+
+        if (andConditions != null && !andConditions.isEmpty()) {
+            filterAndConditions.addAll(andConditions);
+        }
+        if (orConditions != null && !orConditions.isEmpty()) {
+            filterOrConditions.addAll(orConditions);
+        }
+
+        List<Criteria> criteriaAndClause = new ArrayList<>();
+        List<Criteria> criteriaOrClause = new ArrayList<>();
+        Criteria criteria = new Criteria();
+
+        // build criteria
+        filterAndConditions.stream().map(condition -> criteriaAndClause.add(buildCriteria(condition))).collect(Collectors.toList());
+        filterOrConditions.stream().map(condition -> criteriaOrClause.add(buildCriteria(condition))).collect(Collectors.toList());
+
+
+        if (!criteriaAndClause.isEmpty() && !criteriaOrClause.isEmpty()) {
+
+            return new Query(criteria.andOperator(criteriaAndClause.toArray(new Criteria[0])).orOperator(criteriaOrClause.toArray(new Criteria[0])));
+
+        } else if (!criteriaAndClause.isEmpty()) {
+            return new Query(criteria.andOperator(criteriaAndClause.toArray(new Criteria[0])));
+        } else if (!criteriaOrClause.isEmpty()) {
+
+            return new Query(criteria.orOperator(criteriaOrClause.toArray(new Criteria[0])));
+
+        } else {
+            return new Query();
+        }
+
+    }
+
+
+    // create map of filter
+    static {
+        FILTER_CRITERIA.put("EQUAL", condition -> Criteria.where(condition.getField()).is(condition.getValue()));
+        FILTER_CRITERIA.put("NOT_EQUAL", condition -> Criteria.where(condition.getField()).ne(condition.getValue()));
+        FILTER_CRITERIA.put("GREATER_THAN", condition -> Criteria.where(condition.getField()).gt(condition.getValue()));
+        FILTER_CRITERIA.put("GREATER_THAN_OR_EQUAL_TO", condition -> Criteria.where(condition.getField()).gte(condition.getValue()));
+        FILTER_CRITERIA.put("LESS_THAN", condition -> Criteria.where(condition.getField()).lt(condition.getValue()));
+        FILTER_CRITERIA.put("LESSTHAN_OR_EQUAL_TO", condition -> Criteria.where(condition.getField()).lte(condition.getValue()));
+        FILTER_CRITERIA.put("CONTAINS", condition -> Criteria.where(condition.getField()).regex((String) condition.getValue()));
+        FILTER_CRITERIA.put("JOIN", condition -> Criteria.where(condition.getField()).is(new ObjectId((String) condition.getValue())));
+    }
+
+
+    /**
+     * Build the predicate according to the request
+     *
+     * @param condition The condition of the filter requested by the query
+     * @return {{@link Criteria}}
+     */
+    private Criteria buildCriteria(FilterCondition condition) {
+        Function<FilterCondition, Criteria>
+                function = FILTER_CRITERIA.get(condition.getOperator().name());
+
+        if (function == null) {
+            throw new IllegalArgumentException("Invalid function param type: ");
+        }
+
+        return function.apply(condition);
+    }
+
+}

src/main/java/com/tutorial/springdatamongodbdynamicqueries/repository/support/ResourceRepositoryImpl.java

@@ -0,0 +1,37 @@
+package com.tutorial.springdatamongodbdynamicqueries.repository.support;
+
+import com.tutorial.springdatamongodbdynamicqueries.repository.ResourceRepository;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.mongodb.core.MongoOperations;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.data.mongodb.repository.query.MongoEntityInformation;
+import org.springframework.data.mongodb.repository.support.SimpleMongoRepository;
+import org.springframework.util.Assert;
+
+import java.io.Serializable;
+import java.util.List;
+
+public class ResourceRepositoryImpl<T, I extends Serializable> extends SimpleMongoRepository<T, I> implements ResourceRepository<T, I> {
+
+    private MongoOperations mongoOperations;
+    private MongoEntityInformation entityInformation;
+
+    public ResourceRepositoryImpl(final MongoEntityInformation entityInformation, final MongoOperations mongoOperations) {
+        super(entityInformation, mongoOperations);
+
+        this.entityInformation = entityInformation;
+        this.mongoOperations = mongoOperations;
+    }
+
+    @Override
+    public Page<T> findAll(final Query query, final Pageable pageable) {
+        Assert.notNull(query, "Query must not be null!");
+
+        long total = mongoOperations.count(query, entityInformation.getJavaType(), entityInformation.getCollectionName());
+        List<T> content = mongoOperations.find(query.with(pageable), entityInformation.getJavaType(), entityInformation.getCollectionName());
+
+        return new PageImpl<T>(content,pageable,total);
+    }
+}