Dados da primavera desbloqueados: queries avançadas com MongoDB

1
{
2
   "id": "672182814338f60133ee26e1",
3
   "transactionType": "Debit",
4
   "amount": 888.0,
5
   "currency": "USD",
6
   "status": "In Progress",
7
   "description": "Transfer to Ricardo",
8
   "createdAt": "2024-10-09T14:00:00",
9
   "accountDetails": {
10
       "originator": {
11
           "accountNumber": "2376543213",
12
           "name": "Maria",
13
           "bank": "Bank G"
14
       },
15
       "beneficiary": {
16
           "accountNumber": "2234987651",
17
           "name": "Ricardo Mello",
18
           "bank": "Bank V"
19
       }
20
   }
21
}

1
List<Transaction> findByTransactionType(String type);

1
logging.level.org.springframework.data.mongodb=DEBUG

1
2024-10-15T18:30:33.855-03:00 DEBUG 28992
2
[SpringShop] [nio-8080-exec-6] o.s.data.mongodb.core.MongoTemplate:
3
find using query: { "transactionType" : "Transfer"} fields: Document{{}} sort: { "transactionType" : "Transfer"} for class: class com.mongodb.Transaction in collection: transactions

1
List<Transaction> findByAmountGreaterThan(double amount);

1
void deleteByTransactionType(String type);

1
package com.mongodb;
2
import org.springframework.data.mongodb.repository.MongoRepository;
3
import org.springframework.stereotype.Repository;
4
import java.util.List;
5
6
@Repository
7
public interface TransactionRepository extends MongoRepository<Transaction, String>{
8
    List<Transaction> findByTransactionType(String type);
9
    List<Transaction> findByAmountGreaterThan(double amount);
10
    void deleteByTransactionType(String type);
11
}

1
@Query(
2
       value= "{ 'status' : ?0 }",
3
       fields="{ 'createdAt':  1, 'accountDetails' : 1, 'amount' : 1}",
4
       sort = "{ createdAt:  -1}"
5
)
6
List<Transaction> findByStatus(String status);

1
@Query("{ '_id' : ?0 }")
2
@Update("{ '$set' : { 'status' : ?1 } }")
3
void updateStatus(String id, String status);

1
@Aggregation(pipeline = {
2
       "{ '$match': { 'transactionType': ?0 } }",
3
       "{ '$group': { '_id': '$transactionType', 'amount': { '$sum': '$amount' } } }",
4
       "{ '$project': { 'amount': 1 } }"
5
})
6
List<Transaction> getTotalAmountByTransactionType(String transactionType);

1
@Aggregation(pipeline = {
2
       "{ '$match': { 'status': 'error' } }",
3
       "{ '$project': { '_id': 1, 'amount': 1, 'status': 1, 'description': 1, 'createdAt': 1} }",
4
       "{ '$out': 'error_transactions' }"
5
})
6
void exportErrorTransactions();

1
{
2
  "name": "Ricardo Mello",
3
  "email": "ricardo.mello@mongodb.com",
4
  "accountNumber": "2234987651",
5
  "phone": "5517992384610",
6
  "address": {
7
      "street": "Street 001",
8
      "city": "New York"
9
  }
10
}

1
@Aggregation(pipeline = {
2
       "{ '$lookup': { " +
3
               "'from': 'customer', " +
4
               "'localField': 'accountDetails.originator.accountNumber', " +
5
               "'foreignField': 'accountNumber', " +
6
               "'as': 'originatorCustomerDetails' } }",
7
       "{ '$project': { " +
8
               "'amount': 1, " +
9
               "'status': 1, " +
10
               "'accountDetails': 1, " +
11
               "'originatorCustomerDetails': 1 } }"
12
})
13
List<CustomerOriginatorDetail> findTransactionsWithCustomerDetails();

1
public record CustomerOriginatorDetail(
2
       double amount,
3
       String status,
4
       Transaction.AccountDetails accountDetails,
5
       List<OriginatorCustomerDetails> originatorCustomerDetails
6
) {
7
   private record OriginatorCustomerDetails(
8
           String name,
9
           String accountNumber,
10
           String phone,
11
           Address address) {
12
13
       private record Address(String city, String street) {}
14
   }
15
}

1
import org.springframework.data.mongodb.repository.Aggregation;
2
3
import java.lang.annotation.ElementType;
4
import java.lang.annotation.Retention;
5
import java.lang.annotation.RetentionPolicy;
6
import java.lang.annotation.Target;
7
8
@Retention(RetentionPolicy.RUNTIME)
9
@Target({ ElementType.METHOD })
10
@Aggregation(pipeline = {
11
       "{ '$search': { 'text': { 'query': ?0, 'path': ?1 } } }"
12
})
13
@interface SearchAggregate {
14
}

1
@SearchAggregate
2
List<Transaction> search(String query, String path);

1
public Page<Transaction> findPageableTransactions(
2
       Pageable pageable
3
) {
4
   return transactionRepository.findAll(pageable);
5
}

1
@GetMapping("/pageable")
2
public PagedModel<Transaction> findAll(@RequestParam(defaultValue = "0") int page,
3
                                      @RequestParam(defaultValue = "100") int sizePerPage,
4
                                      @RequestParam(defaultValue = "ID") String sortField,
5
                                      @RequestParam(defaultValue = "DESC") Sort.Direction sortDirection) {
6
   Pageable pageable = PageRequest.of(page, sizePerPage, Sort.by(sortDirection, sortField));
7
   return new PagedModel<>(transactionService.findPageableTransactions(pageable));
8
}

1
curl --location 'http://localhost:8080/transactions?page=0&sizePerPage=10&sortField=description&sortDirection=ASC'

1
package com.mongodb;
2
3
import com.mongodb.client.MongoClient;
4
import com.mongodb.client.MongoClients;
5
import org.springframework.context.annotation.Bean;
6
import org.springframework.context.annotation.Configuration;
7
import org.springframework.data.mongodb.core.MongoOperations;
8
import org.springframework.data.mongodb.core.MongoTemplate;
9
10
@Configuration
11
public class MongoConfig  {
12
13
   @Bean
14
   public MongoClient mongoClient() {
15
       MongoClientSettings settings = MongoClientSettings.builder()
16
               .applyConnectionString(new ConnectionString("<your connection string>"))
17
               .build();
18
       return MongoClients.create(settings);
19
   }
20
21
   @Bean
22
   MongoOperations mongoTemplate(MongoClient mongoClient) {
23
       return new MongoTemplate(mongoClient, "springshop");
24
   }
25
}

1
package com.mongodb;
2
3
public record Customer(
4
       String name,
5
       String email,
6
       String accountNumber,
7
       String phone,
8
       Address address
9
) {
10
   public record Address(
11
           String street,
12
           String city
13
   ) {}
14
}

1
import org.springframework.data.mongodb.core.MongoOperations;
2
import org.springframework.stereotype.Service;
3
4
@Service
5
public class CustomerService {
6
7
   private final MongoOperations mongoOperations;
8
9
   CustomerService(MongoOperations mongoOperations) {
10
       this.mongoOperations = mongoOperations;
11
   }
12
13
   public Customer newCustomer() {
14
       var customer = new Customer(
15
               "Ricardo",
16
               "ricardohsmello@gmail.com",
17
               "123",
18
               "1234",
19
               new Customer.Address("a", "Sp")
20
       );
21
22
       return mongoOperations.insert(customer);
23
   }
24
25
}

1
public int bulkCustomerSample(List<Customer> customerList) {
2
    BulkWriteResult result mongoOperations.bulkOps(BulkOperations.BulkMode.ORDERED, Customer.class)
3
            .insert(customerList)
4
            .execute();
5
6
    return result.getInsertedCount();
7
}

1
public Customer findCustomerByEmail(String email) {
2
   return mongoOperations.query(Customer.class)
3
           .matching(query(where("email").is(email)))
4
           .one()
5
           .orElseThrow(() -> new RuntimeException("Customer not found with email: " + email));
6
}

1
public record CustomersByCity(
2
       String id,
3
       int total
4
){}

1
public List<CustomersByCity> totalCustomerByCity() {
2
3
   TypedAggregation<Customer> aggregation = newAggregation(Customer.class,
4
           group("address.city")
5
                   .count().as("total"),
6
           Aggregation.sort(Sort.Direction.ASC, "_id"),
7
           project(Fields.fields("total", "_id")));
8
9
   AggregationResults<CustomersByCity> result = mongoOperations.aggregate(aggregation, CustomersByCity.class);
10
   return result.getMappedResults();
11
}