account order

src/main/java/com/sasiedzi/event/domain/Transaction.java

@@ -7,8 +7,8 @@ import jakarta.persistence.*;
 import java.io.Serializable;
 import java.time.LocalDate;
 import java.time.temporal.ChronoUnit;
-import java.util.HashSet;
+import java.util.*;
-import java.util.Set;
+import org.hibernate.annotations.SortComparator;
 
 /**
  * A Transaction.
@@ -42,7 +42,8 @@ public class Transaction implements Serializable {
 
     @OneToMany(fetch = FetchType.LAZY, mappedBy = "transaction", cascade = CascadeType.ALL, orphanRemoval = true)
     @JsonIgnoreProperties(value = { "transaction", "event", "registration" }, allowSetters = true)
-    private Set<TransactionItem> transactionItems = new HashSet<>();
+    @SortComparator(TransactionItemComparator.class)
+    private List<TransactionItem> transactionItems = Transaction.getEmptyTransactionItemSet();
 
     @Transient
     private UserAccount beneficiary;
@@ -151,11 +152,11 @@ public class Transaction implements Serializable {
         return this;
     }
 
-    public Set<TransactionItem> getTransactionItems() {
+    public List<TransactionItem> getTransactionItems() {
         return this.transactionItems;
     }
 
-    public void setTransactionItems(Set<TransactionItem> transactionItems) {
+    public void setTransactionItems(List<TransactionItem> transactionItems) {
         if (this.transactionItems != null) {
             this.transactionItems.forEach(i -> i.setTransaction(null));
         }
@@ -165,7 +166,7 @@ public class Transaction implements Serializable {
         this.transactionItems = transactionItems;
     }
 
-    public Transaction transactionItems(Set<TransactionItem> transactionItems) {
+    public Transaction transactionItems(List<TransactionItem> transactionItems) {
         this.setTransactionItems(transactionItems);
         return this;
     }
@@ -211,4 +212,8 @@ public class Transaction implements Serializable {
             ", comment='" + getComment() + "'" +
             "}";
     }
+
+    public static List<TransactionItem> getEmptyTransactionItemSet() {
+        return new ArrayList();
+    }
 }

src/main/java/com/sasiedzi/event/domain/TransactionItemComparator.java

@@ -0,0 +1,24 @@
+package com.sasiedzi.event.domain;
+
+import java.util.Comparator;
+
+public class TransactionItemComparator implements Comparator<TransactionItem> {
+
+    private UserAccountComparator userAccountComparator = new UserAccountComparator();
+
+    @Override
+    public int compare(TransactionItem item1, TransactionItem item2) {
+        // Sprawdzamy, czy którykolwiek z obiektów jest null
+        if (item1 == null && item2 == null) return 0;
+        if (item1 == null) return -1;
+        if (item2 == null) return 1;
+
+        // Teraz porównujemy pola userAccount
+        return compareUserAccounts(item1.getUserAccount(), item2.getUserAccount());
+    }
+
+    private int compareUserAccounts(UserAccount ua1, UserAccount ua2) {
+        // Używamy naszego komparatora UserAccount
+        return userAccountComparator.compare(ua1, ua2);
+    }
+}

src/main/java/com/sasiedzi/event/domain/UserAccountComparator.java

@@ -0,0 +1,58 @@
+package com.sasiedzi.event.domain;
+
+import com.sasiedzi.event.service.Account;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class UserAccountComparator implements Comparator<UserAccount> {
+
+    String[] specialAccounts;
+
+    public UserAccountComparator() {
+        ArrayList<String> specialAccountList = new ArrayList<String>();
+        specialAccountList.addAll(Arrays.stream(Account.values()).map(Enum::toString).toList());
+        specialAccountList.add("Tomasz Taraszewski");
+        this.specialAccounts = specialAccountList.toArray(new String[0]);
+    }
+
+    @Override
+    public int compare(UserAccount ua1, UserAccount ua2) {
+        // Sprawdzamy, czy obiekty nie są null
+        if (ua1 == null && ua2 == null) return 0;
+        if (ua1 == null) return -1;
+        if (ua2 == null) return 1;
+
+        String name1 = ua1.getName();
+        String name2 = ua2.getName();
+
+        // Sprawdzamy, czy oba są null
+        if (name1 == null && name2 == null) return 0;
+        if (name1 == null) return -1;
+        if (name2 == null) return 1;
+
+        // Najpierw sprawdzamy, czy nazwy znajdują się w liście specjalnych nazw
+        int index1 = findSpecialNameIndex(name1);
+        int index2 = findSpecialNameIndex(name2);
+
+        // Jeśli obie nazwy są specjalne, porównujemy ich indeksy
+        if (index1 != -1 && index2 != -1) {
+            return Integer.compare(index1, index2);
+        }
+        // Jeśli tylko jedna nazwa jest specjalna, ona jest "mniejsza"
+        if (index1 != -1) return -1;
+        if (index2 != -1) return 1;
+
+        // Jeśli żadna z nazw nie jest specjalna, porównujemy alfabetycznie
+        return name1.compareTo(name2);
+    }
+
+    private int findSpecialNameIndex(String name) {
+        for (int i = 0; i < specialAccounts.length; i++) {
+            if (specialAccounts[i].equalsIgnoreCase(name)) {
+                return i; // Zwracamy indeks specjalnej nazwy
+            }
+        }
+        return -1; // Nazwa nie jest specjalna
+    }
+}

src/main/java/com/sasiedzi/event/service/EventService.java

@@ -176,7 +176,7 @@ public class EventService {
             transaction.setEvent(event);
             transaction.setType(TransactionType.MATCH);
             transaction.setDate(LocalDate.now());
-            transaction.setTransactionItems(new HashSet<>());
+            transaction.setTransactionItems(Transaction.getEmptyTransactionItemSet());
             transactionRepository.save(transaction);
         } else {
             transaction = allTransactions.get(0);

src/main/java/com/sasiedzi/event/service/TransactionService.java

@@ -1,9 +1,6 @@
 package com.sasiedzi.event.service;
 
-import com.sasiedzi.event.domain.Event;
+import com.sasiedzi.event.domain.*;
-import com.sasiedzi.event.domain.Transaction;
-import com.sasiedzi.event.domain.TransactionItem;
-import com.sasiedzi.event.domain.UserAccount;
 import com.sasiedzi.event.domain.enumeration.TransactionType;
 import com.sasiedzi.event.repository.TransactionItemRepository;
 import com.sasiedzi.event.repository.TransactionRepository;
@@ -12,9 +9,11 @@ import java.math.BigDecimal;
 import java.time.LocalDate;
 import java.util.*;
 import java.util.stream.Collectors;
+import org.apache.commons.lang3.tuple.Pair;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.bind.annotation.RequestParam;
 
 @Service
 @Transactional
@@ -33,7 +32,7 @@ public class TransactionService {
     private EventService eventService;
 
     public Transaction save(Transaction transaction) {
-        Set<TransactionItem> items = transaction.getTransactionItems();
+        List<TransactionItem> items = transaction.getTransactionItems();
         String beneficiaryAccountName = transaction.getBeneficiary() == null
             ? Account.Skarbiec.toString()
             : transaction.getBeneficiary().getName();
@@ -196,4 +195,61 @@ public class TransactionService {
     public UserAccount getAccount(Account account) {
         return userAccountRepository.findByName(account.toString()).stream().min(Comparator.comparing(UserAccount::getId)).orElse(null);
     }
+
+    public List<TransactionDTO> getAllTransactions() {
+        //        LOG.debug("REST request to get all Transactions");
+        //        if (eagerload) {
+        //            return transactionRepository.findAllWithEagerRelationships();
+        //        } else {
+        //            return transactionRepository.findAll();
+        //        }
+        List<Transaction> all = transactionRepository.findAll();
+        Map<UserAccount, TransactionItem> accounts = new HashMap<>();
+        Map<Pair<UserAccount, Transaction>, BigDecimal> items = new LinkedHashMap<>();
+        all.forEach(transaction -> {
+            transaction
+                .getTransactionItems()
+                .forEach(transactionItem -> {
+                    accounts.put(transactionItem.getUserAccount(), transactionItem);
+                });
+        });
+        all.forEach(transaction -> {
+            transaction
+                .getTransactionItems()
+                .forEach(transactionItem -> {
+                    items.put(
+                        Pair.of(transactionItem.getUserAccount(), transaction),
+                        add(items.get(Pair.of(transactionItem.getUserAccount(), transaction)), transactionItem.getAmount())
+                    );
+                });
+        });
+        List<UserAccount> accountsSorted = accounts.keySet().stream().sorted(new UserAccountComparator()).toList();
+
+        List<TransactionDTO> out = new ArrayList<>();
+        for (Transaction transaction : all.stream().sorted(Comparator.comparing(Transaction::getDate)).toList()) {
+            TransactionDTO transactionDTO = new TransactionDTO(
+                transaction.getId(),
+                transaction.getType(),
+                transaction.getDate(),
+                transaction.getComment(),
+                transaction.getEvent()
+            );
+            for (UserAccount userAccount : accountsSorted) {
+                BigDecimal amount = items.get(Pair.of(userAccount, transaction));
+
+                TransactionItem item = new TransactionItem();
+                item.setUserAccount(userAccount);
+                transactionDTO.getItems().add(item);
+                item.setAmount(amount);
+            }
+            out.add(transactionDTO);
+        }
+
+        return out;
+    }
+
+    BigDecimal add(BigDecimal val, BigDecimal val2) {
+        if (val == null) return val2;
+        return val.add(val2);
+    }
 }

src/main/java/com/sasiedzi/event/web/rest/TransactionResource.java

@@ -170,64 +170,7 @@ public class TransactionResource {
     public List<TransactionDTO> getAllTransactions(
         @RequestParam(name = "eagerload", required = false, defaultValue = "true") boolean eagerload
     ) {
-        //        LOG.debug("REST request to get all Transactions");
+        return transactionService.getAllTransactions();
-        //        if (eagerload) {
-        //            return transactionRepository.findAllWithEagerRelationships();
-        //        } else {
-        //            return transactionRepository.findAll();
-        //        }
-        List<Transaction> all = transactionRepository.findAll();
-        Map<UserAccount, TransactionItem> accounts = new HashMap<>();
-        Map<Pair<UserAccount, Transaction>, BigDecimal> items = new HashMap<>();
-        all.forEach(transaction -> {
-            transaction
-                .getTransactionItems()
-                .forEach(transactionItem -> {
-                    accounts.put(transactionItem.getUserAccount(), transactionItem);
-                });
-        });
-        all.forEach(transaction -> {
-            transaction
-                .getTransactionItems()
-                .forEach(transactionItem -> {
-                    items.put(
-                        Pair.of(transactionItem.getUserAccount(), transaction),
-                        add(items.get(Pair.of(transactionItem.getUserAccount(), transaction)), transactionItem.getAmount())
-                    );
-                });
-        });
-        List<UserAccount> accountsSorted = accounts
-            .keySet()
-            .stream()
-            .sorted(Comparator.comparing(UserAccount::getName).thenComparing(Comparator.comparing(UserAccount::getName)))
-            .toList();
-
-        List<TransactionDTO> out = new ArrayList<>();
-        for (Transaction transaction : all.stream().sorted(Comparator.comparing(Transaction::getDate)).toList()) {
-            TransactionDTO transactionDTO = new TransactionDTO(
-                transaction.getId(),
-                transaction.getType(),
-                transaction.getDate(),
-                transaction.getComment(),
-                transaction.getEvent()
-            );
-            for (UserAccount userAccount : accountsSorted) {
-                BigDecimal amount = items.get(Pair.of(userAccount, transaction));
-
-                TransactionItem item = new TransactionItem();
-                item.setUserAccount(userAccount);
-                transactionDTO.getItems().add(item);
-                item.setAmount(amount);
-            }
-            out.add(transactionDTO);
-        }
-
-        return out;
-    }
-
-    BigDecimal add(BigDecimal val, BigDecimal val2) {
-        if (val == null) return val2;
-        return val.add(val2);
     }
 
     //    private  Comparator<UserAccount> getMyAccountFirstComparator (final String myAccountName) {

src/test/java/com/sasiedzi/event/domain/TransactionTest.java

@@ -51,11 +51,11 @@ class TransactionTest {
         assertThat(transaction.getTransactionItems()).doesNotContain(transactionItemBack);
         assertThat(transactionItemBack.getTransaction()).isNull();
 
-        transaction.transactionItems(new HashSet<>(Set.of(transactionItemBack)));
+        transaction.transactionItems(Transaction.getEmptyTransactionItemSet());
         assertThat(transaction.getTransactionItems()).containsOnly(transactionItemBack);
         assertThat(transactionItemBack.getTransaction()).isEqualTo(transaction);
 
-        transaction.setTransactionItems(new HashSet<>());
+        transaction.setTransactionItems(Transaction.getEmptyTransactionItemSet());
         assertThat(transaction.getTransactionItems()).doesNotContain(transactionItemBack);
         assertThat(transactionItemBack.getTransaction()).isNull();
     }