Merge tag 'transactionModelJhipster' into ver3

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

@@ -38,7 +38,7 @@ public class Charge implements Serializable {
     private BigDecimal amount;
 
     @ManyToOne(fetch = FetchType.LAZY)
-    @JsonIgnoreProperties(value = { "registrations" }, allowSetters = true)
+    @JsonIgnoreProperties(value = { "registrations", "transactions" }, allowSetters = true)
     private Event event;
 
     @ManyToOne(fetch = FetchType.LAZY)

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

@@ -47,6 +47,10 @@ public class Event implements Serializable {
     @JsonIgnoreProperties(value = { "event" }, allowSetters = true)
     private Set<Registration> registrations = new HashSet<>();
 
+    @OneToMany(fetch = FetchType.LAZY, mappedBy = "event")
+    @JsonIgnoreProperties(value = { "event", "transactionItem" }, allowSetters = true)
+    private Set<Transaction> transactions = new HashSet<>();
+
     // jhipster-needle-entity-add-field - JHipster will add fields here
 
     public Long getId() {
@@ -158,6 +162,37 @@ public class Event implements Serializable {
         return this;
     }
 
+    public Set<Transaction> getTransactions() {
+        return this.transactions;
+    }
+
+    public void setTransactions(Set<Transaction> transactions) {
+        if (this.transactions != null) {
+            this.transactions.forEach(i -> i.setEvent(null));
+        }
+        if (transactions != null) {
+            transactions.forEach(i -> i.setEvent(this));
+        }
+        this.transactions = transactions;
+    }
+
+    public Event transactions(Set<Transaction> transactions) {
+        this.setTransactions(transactions);
+        return this;
+    }
+
+    public Event addTransaction(Transaction transaction) {
+        this.transactions.add(transaction);
+        transaction.setEvent(this);
+        return this;
+    }
+
+    public Event removeTransaction(Transaction transaction) {
+        this.transactions.remove(transaction);
+        transaction.setEvent(null);
+        return this;
+    }
+
     // jhipster-needle-entity-add-getters-setters - JHipster will add getters and setters here
 
     @Override

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

@@ -41,7 +41,7 @@ public class Registration implements Serializable {
     private User user;
 
     @ManyToOne(fetch = FetchType.LAZY)
-    @JsonIgnoreProperties(value = { "registrations" }, allowSetters = true)
+    @JsonIgnoreProperties(value = { "registrations", "transactions" }, allowSetters = true)
     private Event event;
 
     // jhipster-needle-entity-add-field - JHipster will add fields here

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

@@ -0,0 +1,152 @@
+package com.sasiedzi.event.domain;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.sasiedzi.event.domain.enumeration.TransactionType;
+import jakarta.persistence.*;
+import java.io.Serializable;
+import java.time.LocalDate;
+
+/**
+ * A Transaction.
+ */
+@Entity
+@Table(name = "transaction")
+@SuppressWarnings("common-java:DuplicatedBlocks")
+public class Transaction implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "sequenceGenerator")
+    @SequenceGenerator(name = "sequenceGenerator")
+    @Column(name = "id")
+    private Long id;
+
+    @Enumerated(EnumType.STRING)
+    @Column(name = "type")
+    private TransactionType type;
+
+    @Column(name = "date")
+    private LocalDate date;
+
+    @Column(name = "comment")
+    private String comment;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JsonIgnoreProperties(value = { "registrations", "transactions" }, allowSetters = true)
+    private Event event;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JsonIgnoreProperties(value = { "userAccounts", "transactions" }, allowSetters = true)
+    private TransactionItem transactionItem;
+
+    // jhipster-needle-entity-add-field - JHipster will add fields here
+
+    public Long getId() {
+        return this.id;
+    }
+
+    public Transaction id(Long id) {
+        this.setId(id);
+        return this;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public TransactionType getType() {
+        return this.type;
+    }
+
+    public Transaction type(TransactionType type) {
+        this.setType(type);
+        return this;
+    }
+
+    public void setType(TransactionType type) {
+        this.type = type;
+    }
+
+    public LocalDate getDate() {
+        return this.date;
+    }
+
+    public Transaction date(LocalDate date) {
+        this.setDate(date);
+        return this;
+    }
+
+    public void setDate(LocalDate date) {
+        this.date = date;
+    }
+
+    public String getComment() {
+        return this.comment;
+    }
+
+    public Transaction comment(String comment) {
+        this.setComment(comment);
+        return this;
+    }
+
+    public void setComment(String comment) {
+        this.comment = comment;
+    }
+
+    public Event getEvent() {
+        return this.event;
+    }
+
+    public void setEvent(Event event) {
+        this.event = event;
+    }
+
+    public Transaction event(Event event) {
+        this.setEvent(event);
+        return this;
+    }
+
+    public TransactionItem getTransactionItem() {
+        return this.transactionItem;
+    }
+
+    public void setTransactionItem(TransactionItem transactionItem) {
+        this.transactionItem = transactionItem;
+    }
+
+    public Transaction transactionItem(TransactionItem transactionItem) {
+        this.setTransactionItem(transactionItem);
+        return this;
+    }
+
+    // jhipster-needle-entity-add-getters-setters - JHipster will add getters and setters here
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof Transaction)) {
+            return false;
+        }
+        return getId() != null && getId().equals(((Transaction) o).getId());
+    }
+
+    @Override
+    public int hashCode() {
+        // see https://vladmihalcea.com/how-to-implement-equals-and-hashcode-using-the-jpa-entity-identifier/
+        return getClass().hashCode();
+    }
+
+    // prettier-ignore
+    @Override
+    public String toString() {
+        return "Transaction{" +
+            "id=" + getId() +
+            ", type='" + getType() + "'" +
+            ", date='" + getDate() + "'" +
+            ", comment='" + getComment() + "'" +
+            "}";
+    }
+}

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

@@ -0,0 +1,186 @@
+package com.sasiedzi.event.domain;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import jakarta.persistence.*;
+import java.io.Serializable;
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * A TransactionItem.
+ */
+@Entity
+@Table(name = "transaction_item")
+@SuppressWarnings("common-java:DuplicatedBlocks")
+public class TransactionItem implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "sequenceGenerator")
+    @SequenceGenerator(name = "sequenceGenerator")
+    @Column(name = "id")
+    private Long id;
+
+    @Column(name = "amount", precision = 21, scale = 2)
+    private BigDecimal amount;
+
+    @Column(name = "date")
+    private LocalDate date;
+
+    @Column(name = "comment")
+    private String comment;
+
+    @ManyToMany(fetch = FetchType.LAZY)
+    @JoinTable(
+        name = "rel_transaction_item__user_account",
+        joinColumns = @JoinColumn(name = "transaction_item_id"),
+        inverseJoinColumns = @JoinColumn(name = "user_account_id")
+    )
+    @JsonIgnoreProperties(value = { "users", "transactionItems" }, allowSetters = true)
+    private Set<UserAccount> userAccounts = new HashSet<>();
+
+    @OneToMany(fetch = FetchType.LAZY, mappedBy = "transactionItem")
+    @JsonIgnoreProperties(value = { "event", "transactionItem" }, allowSetters = true)
+    private Set<Transaction> transactions = new HashSet<>();
+
+    // jhipster-needle-entity-add-field - JHipster will add fields here
+
+    public Long getId() {
+        return this.id;
+    }
+
+    public TransactionItem id(Long id) {
+        this.setId(id);
+        return this;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public BigDecimal getAmount() {
+        return this.amount;
+    }
+
+    public TransactionItem amount(BigDecimal amount) {
+        this.setAmount(amount);
+        return this;
+    }
+
+    public void setAmount(BigDecimal amount) {
+        this.amount = amount;
+    }
+
+    public LocalDate getDate() {
+        return this.date;
+    }
+
+    public TransactionItem date(LocalDate date) {
+        this.setDate(date);
+        return this;
+    }
+
+    public void setDate(LocalDate date) {
+        this.date = date;
+    }
+
+    public String getComment() {
+        return this.comment;
+    }
+
+    public TransactionItem comment(String comment) {
+        this.setComment(comment);
+        return this;
+    }
+
+    public void setComment(String comment) {
+        this.comment = comment;
+    }
+
+    public Set<UserAccount> getUserAccounts() {
+        return this.userAccounts;
+    }
+
+    public void setUserAccounts(Set<UserAccount> userAccounts) {
+        this.userAccounts = userAccounts;
+    }
+
+    public TransactionItem userAccounts(Set<UserAccount> userAccounts) {
+        this.setUserAccounts(userAccounts);
+        return this;
+    }
+
+    public TransactionItem addUserAccount(UserAccount userAccount) {
+        this.userAccounts.add(userAccount);
+        return this;
+    }
+
+    public TransactionItem removeUserAccount(UserAccount userAccount) {
+        this.userAccounts.remove(userAccount);
+        return this;
+    }
+
+    public Set<Transaction> getTransactions() {
+        return this.transactions;
+    }
+
+    public void setTransactions(Set<Transaction> transactions) {
+        if (this.transactions != null) {
+            this.transactions.forEach(i -> i.setTransactionItem(null));
+        }
+        if (transactions != null) {
+            transactions.forEach(i -> i.setTransactionItem(this));
+        }
+        this.transactions = transactions;
+    }
+
+    public TransactionItem transactions(Set<Transaction> transactions) {
+        this.setTransactions(transactions);
+        return this;
+    }
+
+    public TransactionItem addTransaction(Transaction transaction) {
+        this.transactions.add(transaction);
+        transaction.setTransactionItem(this);
+        return this;
+    }
+
+    public TransactionItem removeTransaction(Transaction transaction) {
+        this.transactions.remove(transaction);
+        transaction.setTransactionItem(null);
+        return this;
+    }
+
+    // jhipster-needle-entity-add-getters-setters - JHipster will add getters and setters here
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof TransactionItem)) {
+            return false;
+        }
+        return getId() != null && getId().equals(((TransactionItem) o).getId());
+    }
+
+    @Override
+    public int hashCode() {
+        // see https://vladmihalcea.com/how-to-implement-equals-and-hashcode-using-the-jpa-entity-identifier/
+        return getClass().hashCode();
+    }
+
+    // prettier-ignore
+    @Override
+    public String toString() {
+        return "TransactionItem{" +
+            "id=" + getId() +
+            ", amount=" + getAmount() +
+            ", date='" + getDate() + "'" +
+            ", comment='" + getComment() + "'" +
+            "}";
+    }
+}

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

@@ -0,0 +1,149 @@
+package com.sasiedzi.event.domain;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import jakarta.persistence.*;
+import java.io.Serializable;
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * A UserAccount.
+ */
+@Entity
+@Table(name = "user_account")
+@SuppressWarnings("common-java:DuplicatedBlocks")
+public class UserAccount implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "sequenceGenerator")
+    @SequenceGenerator(name = "sequenceGenerator")
+    @Column(name = "id")
+    private Long id;
+
+    @Column(name = "name")
+    private String name;
+
+    @ManyToMany(fetch = FetchType.LAZY)
+    @JoinTable(
+        name = "rel_user_account__user",
+        joinColumns = @JoinColumn(name = "user_account_id"),
+        inverseJoinColumns = @JoinColumn(name = "user_id")
+    )
+    private Set<User> users = new HashSet<>();
+
+    @ManyToMany(fetch = FetchType.LAZY, mappedBy = "userAccounts")
+    @JsonIgnoreProperties(value = { "userAccounts", "transactions" }, allowSetters = true)
+    private Set<TransactionItem> transactionItems = new HashSet<>();
+
+    // jhipster-needle-entity-add-field - JHipster will add fields here
+
+    public Long getId() {
+        return this.id;
+    }
+
+    public UserAccount id(Long id) {
+        this.setId(id);
+        return this;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return this.name;
+    }
+
+    public UserAccount name(String name) {
+        this.setName(name);
+        return this;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public Set<User> getUsers() {
+        return this.users;
+    }
+
+    public void setUsers(Set<User> users) {
+        this.users = users;
+    }
+
+    public UserAccount users(Set<User> users) {
+        this.setUsers(users);
+        return this;
+    }
+
+    public UserAccount addUser(User user) {
+        this.users.add(user);
+        return this;
+    }
+
+    public UserAccount removeUser(User user) {
+        this.users.remove(user);
+        return this;
+    }
+
+    public Set<TransactionItem> getTransactionItems() {
+        return this.transactionItems;
+    }
+
+    public void setTransactionItems(Set<TransactionItem> transactionItems) {
+        if (this.transactionItems != null) {
+            this.transactionItems.forEach(i -> i.removeUserAccount(this));
+        }
+        if (transactionItems != null) {
+            transactionItems.forEach(i -> i.addUserAccount(this));
+        }
+        this.transactionItems = transactionItems;
+    }
+
+    public UserAccount transactionItems(Set<TransactionItem> transactionItems) {
+        this.setTransactionItems(transactionItems);
+        return this;
+    }
+
+    public UserAccount addTransactionItem(TransactionItem transactionItem) {
+        this.transactionItems.add(transactionItem);
+        transactionItem.getUserAccounts().add(this);
+        return this;
+    }
+
+    public UserAccount removeTransactionItem(TransactionItem transactionItem) {
+        this.transactionItems.remove(transactionItem);
+        transactionItem.getUserAccounts().remove(this);
+        return this;
+    }
+
+    // jhipster-needle-entity-add-getters-setters - JHipster will add getters and setters here
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof UserAccount)) {
+            return false;
+        }
+        return getId() != null && getId().equals(((UserAccount) o).getId());
+    }
+
+    @Override
+    public int hashCode() {
+        // see https://vladmihalcea.com/how-to-implement-equals-and-hashcode-using-the-jpa-entity-identifier/
+        return getClass().hashCode();
+    }
+
+    // prettier-ignore
+    @Override
+    public String toString() {
+        return "UserAccount{" +
+            "id=" + getId() +
+            ", name='" + getName() + "'" +
+            "}";
+    }
+}

src/main/java/com/sasiedzi/event/domain/enumeration/TransactionType.java

@@ -0,0 +1,11 @@
+package com.sasiedzi.event.domain.enumeration;
+
+/**
+ * The TransactionType enumeration.
+ */
+public enum TransactionType {
+    PURCHASE,
+    MATCH,
+    FIELDPAYMENT,
+    INTERNALTRANSFER,
+}

src/main/java/com/sasiedzi/event/repository/TransactionItemRepository.java

@@ -0,0 +1,30 @@
+package com.sasiedzi.event.repository;
+
+import com.sasiedzi.event.domain.TransactionItem;
+import java.util.List;
+import java.util.Optional;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.*;
+import org.springframework.stereotype.Repository;
+
+/**
+ * Spring Data JPA repository for the TransactionItem entity.
+ *
+ * When extending this class, extend TransactionItemRepositoryWithBagRelationships too.
+ * For more information refer to https://github.com/jhipster/generator-jhipster/issues/17990.
+ */
+@Repository
+public interface TransactionItemRepository extends TransactionItemRepositoryWithBagRelationships, JpaRepository<TransactionItem, Long> {
+    default Optional<TransactionItem> findOneWithEagerRelationships(Long id) {
+        return this.fetchBagRelationships(this.findById(id));
+    }
+
+    default List<TransactionItem> findAllWithEagerRelationships() {
+        return this.fetchBagRelationships(this.findAll());
+    }
+
+    default Page<TransactionItem> findAllWithEagerRelationships(Pageable pageable) {
+        return this.fetchBagRelationships(this.findAll(pageable));
+    }
+}

src/main/java/com/sasiedzi/event/repository/TransactionItemRepositoryWithBagRelationships.java

@@ -0,0 +1,14 @@
+package com.sasiedzi.event.repository;
+
+import com.sasiedzi.event.domain.TransactionItem;
+import java.util.List;
+import java.util.Optional;
+import org.springframework.data.domain.Page;
+
+public interface TransactionItemRepositoryWithBagRelationships {
+    Optional<TransactionItem> fetchBagRelationships(Optional<TransactionItem> transactionItem);
+
+    List<TransactionItem> fetchBagRelationships(List<TransactionItem> transactionItems);
+
+    Page<TransactionItem> fetchBagRelationships(Page<TransactionItem> transactionItems);
+}

src/main/java/com/sasiedzi/event/repository/TransactionItemRepositoryWithBagRelationshipsImpl.java

@@ -0,0 +1,67 @@
+package com.sasiedzi.event.repository;
+
+import com.sasiedzi.event.domain.TransactionItem;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.PersistenceContext;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.IntStream;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+
+/**
+ * Utility repository to load bag relationships based on https://vladmihalcea.com/hibernate-multiplebagfetchexception/
+ */
+public class TransactionItemRepositoryWithBagRelationshipsImpl implements TransactionItemRepositoryWithBagRelationships {
+
+    private static final String ID_PARAMETER = "id";
+    private static final String TRANSACTIONITEMS_PARAMETER = "transactionItems";
+
+    @PersistenceContext
+    private EntityManager entityManager;
+
+    @Override
+    public Optional<TransactionItem> fetchBagRelationships(Optional<TransactionItem> transactionItem) {
+        return transactionItem.map(this::fetchUserAccounts);
+    }
+
+    @Override
+    public Page<TransactionItem> fetchBagRelationships(Page<TransactionItem> transactionItems) {
+        return new PageImpl<>(
+            fetchBagRelationships(transactionItems.getContent()),
+            transactionItems.getPageable(),
+            transactionItems.getTotalElements()
+        );
+    }
+
+    @Override
+    public List<TransactionItem> fetchBagRelationships(List<TransactionItem> transactionItems) {
+        return Optional.of(transactionItems).map(this::fetchUserAccounts).orElse(Collections.emptyList());
+    }
+
+    TransactionItem fetchUserAccounts(TransactionItem result) {
+        return entityManager
+            .createQuery(
+                "select transactionItem from TransactionItem transactionItem left join fetch transactionItem.userAccounts where transactionItem.id = :id",
+                TransactionItem.class
+            )
+            .setParameter(ID_PARAMETER, result.getId())
+            .getSingleResult();
+    }
+
+    List<TransactionItem> fetchUserAccounts(List<TransactionItem> transactionItems) {
+        HashMap<Object, Integer> order = new HashMap<>();
+        IntStream.range(0, transactionItems.size()).forEach(index -> order.put(transactionItems.get(index).getId(), index));
+        List<TransactionItem> result = entityManager
+            .createQuery(
+                "select transactionItem from TransactionItem transactionItem left join fetch transactionItem.userAccounts where transactionItem in :transactionItems",
+                TransactionItem.class
+            )
+            .setParameter(TRANSACTIONITEMS_PARAMETER, transactionItems)
+            .getResultList();
+        Collections.sort(result, (o1, o2) -> Integer.compare(order.get(o1.getId()), order.get(o2.getId())));
+        return result;
+    }
+}

src/main/java/com/sasiedzi/event/repository/TransactionRepository.java

@@ -0,0 +1,40 @@
+package com.sasiedzi.event.repository;
+
+import com.sasiedzi.event.domain.Transaction;
+import java.util.List;
+import java.util.Optional;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.*;
+import org.springframework.data.repository.query.Param;
+import org.springframework.stereotype.Repository;
+
+/**
+ * Spring Data JPA repository for the Transaction entity.
+ */
+@Repository
+public interface TransactionRepository extends JpaRepository<Transaction, Long> {
+    default Optional<Transaction> findOneWithEagerRelationships(Long id) {
+        return this.findOneWithToOneRelationships(id);
+    }
+
+    default List<Transaction> findAllWithEagerRelationships() {
+        return this.findAllWithToOneRelationships();
+    }
+
+    default Page<Transaction> findAllWithEagerRelationships(Pageable pageable) {
+        return this.findAllWithToOneRelationships(pageable);
+    }
+
+    @Query(
+        value = "select transaction from Transaction transaction left join fetch transaction.event",
+        countQuery = "select count(transaction) from Transaction transaction"
+    )
+    Page<Transaction> findAllWithToOneRelationships(Pageable pageable);
+
+    @Query("select transaction from Transaction transaction left join fetch transaction.event")
+    List<Transaction> findAllWithToOneRelationships();
+
+    @Query("select transaction from Transaction transaction left join fetch transaction.event where transaction.id =:id")
+    Optional<Transaction> findOneWithToOneRelationships(@Param("id") Long id);
+}

src/main/java/com/sasiedzi/event/repository/UserAccountRepository.java

@@ -0,0 +1,30 @@
+package com.sasiedzi.event.repository;
+
+import com.sasiedzi.event.domain.UserAccount;
+import java.util.List;
+import java.util.Optional;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.*;
+import org.springframework.stereotype.Repository;
+
+/**
+ * Spring Data JPA repository for the UserAccount entity.
+ *
+ * When extending this class, extend UserAccountRepositoryWithBagRelationships too.
+ * For more information refer to https://github.com/jhipster/generator-jhipster/issues/17990.
+ */
+@Repository
+public interface UserAccountRepository extends UserAccountRepositoryWithBagRelationships, JpaRepository<UserAccount, Long> {
+    default Optional<UserAccount> findOneWithEagerRelationships(Long id) {
+        return this.fetchBagRelationships(this.findById(id));
+    }
+
+    default List<UserAccount> findAllWithEagerRelationships() {
+        return this.fetchBagRelationships(this.findAll());
+    }
+
+    default Page<UserAccount> findAllWithEagerRelationships(Pageable pageable) {
+        return this.fetchBagRelationships(this.findAll(pageable));
+    }
+}

src/main/java/com/sasiedzi/event/repository/UserAccountRepositoryWithBagRelationships.java

@@ -0,0 +1,14 @@
+package com.sasiedzi.event.repository;
+
+import com.sasiedzi.event.domain.UserAccount;
+import java.util.List;
+import java.util.Optional;
+import org.springframework.data.domain.Page;
+
+public interface UserAccountRepositoryWithBagRelationships {
+    Optional<UserAccount> fetchBagRelationships(Optional<UserAccount> userAccount);
+
+    List<UserAccount> fetchBagRelationships(List<UserAccount> userAccounts);
+
+    Page<UserAccount> fetchBagRelationships(Page<UserAccount> userAccounts);
+}

src/main/java/com/sasiedzi/event/repository/UserAccountRepositoryWithBagRelationshipsImpl.java

@@ -0,0 +1,67 @@
+package com.sasiedzi.event.repository;
+
+import com.sasiedzi.event.domain.UserAccount;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.PersistenceContext;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.IntStream;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+
+/**
+ * Utility repository to load bag relationships based on https://vladmihalcea.com/hibernate-multiplebagfetchexception/
+ */
+public class UserAccountRepositoryWithBagRelationshipsImpl implements UserAccountRepositoryWithBagRelationships {
+
+    private static final String ID_PARAMETER = "id";
+    private static final String USERACCOUNTS_PARAMETER = "userAccounts";
+
+    @PersistenceContext
+    private EntityManager entityManager;
+
+    @Override
+    public Optional<UserAccount> fetchBagRelationships(Optional<UserAccount> userAccount) {
+        return userAccount.map(this::fetchUsers);
+    }
+
+    @Override
+    public Page<UserAccount> fetchBagRelationships(Page<UserAccount> userAccounts) {
+        return new PageImpl<>(
+            fetchBagRelationships(userAccounts.getContent()),
+            userAccounts.getPageable(),
+            userAccounts.getTotalElements()
+        );
+    }
+
+    @Override
+    public List<UserAccount> fetchBagRelationships(List<UserAccount> userAccounts) {
+        return Optional.of(userAccounts).map(this::fetchUsers).orElse(Collections.emptyList());
+    }
+
+    UserAccount fetchUsers(UserAccount result) {
+        return entityManager
+            .createQuery(
+                "select userAccount from UserAccount userAccount left join fetch userAccount.users where userAccount.id = :id",
+                UserAccount.class
+            )
+            .setParameter(ID_PARAMETER, result.getId())
+            .getSingleResult();
+    }
+
+    List<UserAccount> fetchUsers(List<UserAccount> userAccounts) {
+        HashMap<Object, Integer> order = new HashMap<>();
+        IntStream.range(0, userAccounts.size()).forEach(index -> order.put(userAccounts.get(index).getId(), index));
+        List<UserAccount> result = entityManager
+            .createQuery(
+                "select userAccount from UserAccount userAccount left join fetch userAccount.users where userAccount in :userAccounts",
+                UserAccount.class
+            )
+            .setParameter(USERACCOUNTS_PARAMETER, userAccounts)
+            .getResultList();
+        Collections.sort(result, (o1, o2) -> Integer.compare(order.get(o1.getId()), order.get(o2.getId())));
+        return result;
+    }
+}

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

@@ -0,0 +1,189 @@
+package com.sasiedzi.event.web.rest;
+
+import com.sasiedzi.event.domain.TransactionItem;
+import com.sasiedzi.event.repository.TransactionItemRepository;
+import com.sasiedzi.event.web.rest.errors.BadRequestAlertException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.ResponseEntity;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.bind.annotation.*;
+import tech.jhipster.web.util.HeaderUtil;
+import tech.jhipster.web.util.ResponseUtil;
+
+/**
+ * REST controller for managing {@link com.sasiedzi.event.domain.TransactionItem}.
+ */
+@RestController
+@RequestMapping("/api/transaction-items")
+@Transactional
+public class TransactionItemResource {
+
+    private static final Logger LOG = LoggerFactory.getLogger(TransactionItemResource.class);
+
+    private static final String ENTITY_NAME = "transactionItem";
+
+    @Value("${jhipster.clientApp.name}")
+    private String applicationName;
+
+    private final TransactionItemRepository transactionItemRepository;
+
+    public TransactionItemResource(TransactionItemRepository transactionItemRepository) {
+        this.transactionItemRepository = transactionItemRepository;
+    }
+
+    /**
+     * {@code POST  /transaction-items} : Create a new transactionItem.
+     *
+     * @param transactionItem the transactionItem to create.
+     * @return the {@link ResponseEntity} with status {@code 201 (Created)} and with body the new transactionItem, or with status {@code 400 (Bad Request)} if the transactionItem has already an ID.
+     * @throws URISyntaxException if the Location URI syntax is incorrect.
+     */
+    @PostMapping("")
+    public ResponseEntity<TransactionItem> createTransactionItem(@RequestBody TransactionItem transactionItem) throws URISyntaxException {
+        LOG.debug("REST request to save TransactionItem : {}", transactionItem);
+        if (transactionItem.getId() != null) {
+            throw new BadRequestAlertException("A new transactionItem cannot already have an ID", ENTITY_NAME, "idexists");
+        }
+        transactionItem = transactionItemRepository.save(transactionItem);
+        return ResponseEntity.created(new URI("/api/transaction-items/" + transactionItem.getId()))
+            .headers(HeaderUtil.createEntityCreationAlert(applicationName, false, ENTITY_NAME, transactionItem.getId().toString()))
+            .body(transactionItem);
+    }
+
+    /**
+     * {@code PUT  /transaction-items/:id} : Updates an existing transactionItem.
+     *
+     * @param id the id of the transactionItem to save.
+     * @param transactionItem the transactionItem to update.
+     * @return the {@link ResponseEntity} with status {@code 200 (OK)} and with body the updated transactionItem,
+     * or with status {@code 400 (Bad Request)} if the transactionItem is not valid,
+     * or with status {@code 500 (Internal Server Error)} if the transactionItem couldn't be updated.
+     * @throws URISyntaxException if the Location URI syntax is incorrect.
+     */
+    @PutMapping("/{id}")
+    public ResponseEntity<TransactionItem> updateTransactionItem(
+        @PathVariable(value = "id", required = false) final Long id,
+        @RequestBody TransactionItem transactionItem
+    ) throws URISyntaxException {
+        LOG.debug("REST request to update TransactionItem : {}, {}", id, transactionItem);
+        if (transactionItem.getId() == null) {
+            throw new BadRequestAlertException("Invalid id", ENTITY_NAME, "idnull");
+        }
+        if (!Objects.equals(id, transactionItem.getId())) {
+            throw new BadRequestAlertException("Invalid ID", ENTITY_NAME, "idinvalid");
+        }
+
+        if (!transactionItemRepository.existsById(id)) {
+            throw new BadRequestAlertException("Entity not found", ENTITY_NAME, "idnotfound");
+        }
+
+        transactionItem = transactionItemRepository.save(transactionItem);
+        return ResponseEntity.ok()
+            .headers(HeaderUtil.createEntityUpdateAlert(applicationName, false, ENTITY_NAME, transactionItem.getId().toString()))
+            .body(transactionItem);
+    }
+
+    /**
+     * {@code PATCH  /transaction-items/:id} : Partial updates given fields of an existing transactionItem, field will ignore if it is null
+     *
+     * @param id the id of the transactionItem to save.
+     * @param transactionItem the transactionItem to update.
+     * @return the {@link ResponseEntity} with status {@code 200 (OK)} and with body the updated transactionItem,
+     * or with status {@code 400 (Bad Request)} if the transactionItem is not valid,
+     * or with status {@code 404 (Not Found)} if the transactionItem is not found,
+     * or with status {@code 500 (Internal Server Error)} if the transactionItem couldn't be updated.
+     * @throws URISyntaxException if the Location URI syntax is incorrect.
+     */
+    @PatchMapping(value = "/{id}", consumes = { "application/json", "application/merge-patch+json" })
+    public ResponseEntity<TransactionItem> partialUpdateTransactionItem(
+        @PathVariable(value = "id", required = false) final Long id,
+        @RequestBody TransactionItem transactionItem
+    ) throws URISyntaxException {
+        LOG.debug("REST request to partial update TransactionItem partially : {}, {}", id, transactionItem);
+        if (transactionItem.getId() == null) {
+            throw new BadRequestAlertException("Invalid id", ENTITY_NAME, "idnull");
+        }
+        if (!Objects.equals(id, transactionItem.getId())) {
+            throw new BadRequestAlertException("Invalid ID", ENTITY_NAME, "idinvalid");
+        }
+
+        if (!transactionItemRepository.existsById(id)) {
+            throw new BadRequestAlertException("Entity not found", ENTITY_NAME, "idnotfound");
+        }
+
+        Optional<TransactionItem> result = transactionItemRepository
+            .findById(transactionItem.getId())
+            .map(existingTransactionItem -> {
+                if (transactionItem.getAmount() != null) {
+                    existingTransactionItem.setAmount(transactionItem.getAmount());
+                }
+                if (transactionItem.getDate() != null) {
+                    existingTransactionItem.setDate(transactionItem.getDate());
+                }
+                if (transactionItem.getComment() != null) {
+                    existingTransactionItem.setComment(transactionItem.getComment());
+                }
+
+                return existingTransactionItem;
+            })
+            .map(transactionItemRepository::save);
+
+        return ResponseUtil.wrapOrNotFound(
+            result,
+            HeaderUtil.createEntityUpdateAlert(applicationName, false, ENTITY_NAME, transactionItem.getId().toString())
+        );
+    }
+
+    /**
+     * {@code GET  /transaction-items} : get all the transactionItems.
+     *
+     * @param eagerload flag to eager load entities from relationships (This is applicable for many-to-many).
+     * @return the {@link ResponseEntity} with status {@code 200 (OK)} and the list of transactionItems in body.
+     */
+    @GetMapping("")
+    public List<TransactionItem> getAllTransactionItems(
+        @RequestParam(name = "eagerload", required = false, defaultValue = "true") boolean eagerload
+    ) {
+        LOG.debug("REST request to get all TransactionItems");
+        if (eagerload) {
+            return transactionItemRepository.findAllWithEagerRelationships();
+        } else {
+            return transactionItemRepository.findAll();
+        }
+    }
+
+    /**
+     * {@code GET  /transaction-items/:id} : get the "id" transactionItem.
+     *
+     * @param id the id of the transactionItem to retrieve.
+     * @return the {@link ResponseEntity} with status {@code 200 (OK)} and with body the transactionItem, or with status {@code 404 (Not Found)}.
+     */
+    @GetMapping("/{id}")
+    public ResponseEntity<TransactionItem> getTransactionItem(@PathVariable("id") Long id) {
+        LOG.debug("REST request to get TransactionItem : {}", id);
+        Optional<TransactionItem> transactionItem = transactionItemRepository.findOneWithEagerRelationships(id);
+        return ResponseUtil.wrapOrNotFound(transactionItem);
+    }
+
+    /**
+     * {@code DELETE  /transaction-items/:id} : delete the "id" transactionItem.
+     *
+     * @param id the id of the transactionItem to delete.
+     * @return the {@link ResponseEntity} with status {@code 204 (NO_CONTENT)}.
+     */
+    @DeleteMapping("/{id}")
+    public ResponseEntity<Void> deleteTransactionItem(@PathVariable("id") Long id) {
+        LOG.debug("REST request to delete TransactionItem : {}", id);
+        transactionItemRepository.deleteById(id);
+        return ResponseEntity.noContent()
+            .headers(HeaderUtil.createEntityDeletionAlert(applicationName, false, ENTITY_NAME, id.toString()))
+            .build();
+    }
+}

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

@@ -0,0 +1,189 @@
+package com.sasiedzi.event.web.rest;
+
+import com.sasiedzi.event.domain.Transaction;
+import com.sasiedzi.event.repository.TransactionRepository;
+import com.sasiedzi.event.web.rest.errors.BadRequestAlertException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.ResponseEntity;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.bind.annotation.*;
+import tech.jhipster.web.util.HeaderUtil;
+import tech.jhipster.web.util.ResponseUtil;
+
+/**
+ * REST controller for managing {@link com.sasiedzi.event.domain.Transaction}.
+ */
+@RestController
+@RequestMapping("/api/transactions")
+@Transactional
+public class TransactionResource {
+
+    private static final Logger LOG = LoggerFactory.getLogger(TransactionResource.class);
+
+    private static final String ENTITY_NAME = "transaction";
+
+    @Value("${jhipster.clientApp.name}")
+    private String applicationName;
+
+    private final TransactionRepository transactionRepository;
+
+    public TransactionResource(TransactionRepository transactionRepository) {
+        this.transactionRepository = transactionRepository;
+    }
+
+    /**
+     * {@code POST  /transactions} : Create a new transaction.
+     *
+     * @param transaction the transaction to create.
+     * @return the {@link ResponseEntity} with status {@code 201 (Created)} and with body the new transaction, or with status {@code 400 (Bad Request)} if the transaction has already an ID.
+     * @throws URISyntaxException if the Location URI syntax is incorrect.
+     */
+    @PostMapping("")
+    public ResponseEntity<Transaction> createTransaction(@RequestBody Transaction transaction) throws URISyntaxException {
+        LOG.debug("REST request to save Transaction : {}", transaction);
+        if (transaction.getId() != null) {
+            throw new BadRequestAlertException("A new transaction cannot already have an ID", ENTITY_NAME, "idexists");
+        }
+        transaction = transactionRepository.save(transaction);
+        return ResponseEntity.created(new URI("/api/transactions/" + transaction.getId()))
+            .headers(HeaderUtil.createEntityCreationAlert(applicationName, false, ENTITY_NAME, transaction.getId().toString()))
+            .body(transaction);
+    }
+
+    /**
+     * {@code PUT  /transactions/:id} : Updates an existing transaction.
+     *
+     * @param id the id of the transaction to save.
+     * @param transaction the transaction to update.
+     * @return the {@link ResponseEntity} with status {@code 200 (OK)} and with body the updated transaction,
+     * or with status {@code 400 (Bad Request)} if the transaction is not valid,
+     * or with status {@code 500 (Internal Server Error)} if the transaction couldn't be updated.
+     * @throws URISyntaxException if the Location URI syntax is incorrect.
+     */
+    @PutMapping("/{id}")
+    public ResponseEntity<Transaction> updateTransaction(
+        @PathVariable(value = "id", required = false) final Long id,
+        @RequestBody Transaction transaction
+    ) throws URISyntaxException {
+        LOG.debug("REST request to update Transaction : {}, {}", id, transaction);
+        if (transaction.getId() == null) {
+            throw new BadRequestAlertException("Invalid id", ENTITY_NAME, "idnull");
+        }
+        if (!Objects.equals(id, transaction.getId())) {
+            throw new BadRequestAlertException("Invalid ID", ENTITY_NAME, "idinvalid");
+        }
+
+        if (!transactionRepository.existsById(id)) {
+            throw new BadRequestAlertException("Entity not found", ENTITY_NAME, "idnotfound");
+        }
+
+        transaction = transactionRepository.save(transaction);
+        return ResponseEntity.ok()
+            .headers(HeaderUtil.createEntityUpdateAlert(applicationName, false, ENTITY_NAME, transaction.getId().toString()))
+            .body(transaction);
+    }
+
+    /**
+     * {@code PATCH  /transactions/:id} : Partial updates given fields of an existing transaction, field will ignore if it is null
+     *
+     * @param id the id of the transaction to save.
+     * @param transaction the transaction to update.
+     * @return the {@link ResponseEntity} with status {@code 200 (OK)} and with body the updated transaction,
+     * or with status {@code 400 (Bad Request)} if the transaction is not valid,
+     * or with status {@code 404 (Not Found)} if the transaction is not found,
+     * or with status {@code 500 (Internal Server Error)} if the transaction couldn't be updated.
+     * @throws URISyntaxException if the Location URI syntax is incorrect.
+     */
+    @PatchMapping(value = "/{id}", consumes = { "application/json", "application/merge-patch+json" })
+    public ResponseEntity<Transaction> partialUpdateTransaction(
+        @PathVariable(value = "id", required = false) final Long id,
+        @RequestBody Transaction transaction
+    ) throws URISyntaxException {
+        LOG.debug("REST request to partial update Transaction partially : {}, {}", id, transaction);
+        if (transaction.getId() == null) {
+            throw new BadRequestAlertException("Invalid id", ENTITY_NAME, "idnull");
+        }
+        if (!Objects.equals(id, transaction.getId())) {
+            throw new BadRequestAlertException("Invalid ID", ENTITY_NAME, "idinvalid");
+        }
+
+        if (!transactionRepository.existsById(id)) {
+            throw new BadRequestAlertException("Entity not found", ENTITY_NAME, "idnotfound");
+        }
+
+        Optional<Transaction> result = transactionRepository
+            .findById(transaction.getId())
+            .map(existingTransaction -> {
+                if (transaction.getType() != null) {
+                    existingTransaction.setType(transaction.getType());
+                }
+                if (transaction.getDate() != null) {
+                    existingTransaction.setDate(transaction.getDate());
+                }
+                if (transaction.getComment() != null) {
+                    existingTransaction.setComment(transaction.getComment());
+                }
+
+                return existingTransaction;
+            })
+            .map(transactionRepository::save);
+
+        return ResponseUtil.wrapOrNotFound(
+            result,
+            HeaderUtil.createEntityUpdateAlert(applicationName, false, ENTITY_NAME, transaction.getId().toString())
+        );
+    }
+
+    /**
+     * {@code GET  /transactions} : get all the transactions.
+     *
+     * @param eagerload flag to eager load entities from relationships (This is applicable for many-to-many).
+     * @return the {@link ResponseEntity} with status {@code 200 (OK)} and the list of transactions in body.
+     */
+    @GetMapping("")
+    public List<Transaction> getAllTransactions(
+        @RequestParam(name = "eagerload", required = false, defaultValue = "true") boolean eagerload
+    ) {
+        LOG.debug("REST request to get all Transactions");
+        if (eagerload) {
+            return transactionRepository.findAllWithEagerRelationships();
+        } else {
+            return transactionRepository.findAll();
+        }
+    }
+
+    /**
+     * {@code GET  /transactions/:id} : get the "id" transaction.
+     *
+     * @param id the id of the transaction to retrieve.
+     * @return the {@link ResponseEntity} with status {@code 200 (OK)} and with body the transaction, or with status {@code 404 (Not Found)}.
+     */
+    @GetMapping("/{id}")
+    public ResponseEntity<Transaction> getTransaction(@PathVariable("id") Long id) {
+        LOG.debug("REST request to get Transaction : {}", id);
+        Optional<Transaction> transaction = transactionRepository.findOneWithEagerRelationships(id);
+        return ResponseUtil.wrapOrNotFound(transaction);
+    }
+
+    /**
+     * {@code DELETE  /transactions/:id} : delete the "id" transaction.
+     *
+     * @param id the id of the transaction to delete.
+     * @return the {@link ResponseEntity} with status {@code 204 (NO_CONTENT)}.
+     */
+    @DeleteMapping("/{id}")
+    public ResponseEntity<Void> deleteTransaction(@PathVariable("id") Long id) {
+        LOG.debug("REST request to delete Transaction : {}", id);
+        transactionRepository.deleteById(id);
+        return ResponseEntity.noContent()
+            .headers(HeaderUtil.createEntityDeletionAlert(applicationName, false, ENTITY_NAME, id.toString()))
+            .build();
+    }
+}

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

@@ -0,0 +1,183 @@
+package com.sasiedzi.event.web.rest;
+
+import com.sasiedzi.event.domain.UserAccount;
+import com.sasiedzi.event.repository.UserAccountRepository;
+import com.sasiedzi.event.web.rest.errors.BadRequestAlertException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.ResponseEntity;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.bind.annotation.*;
+import tech.jhipster.web.util.HeaderUtil;
+import tech.jhipster.web.util.ResponseUtil;
+
+/**
+ * REST controller for managing {@link com.sasiedzi.event.domain.UserAccount}.
+ */
+@RestController
+@RequestMapping("/api/user-accounts")
+@Transactional
+public class UserAccountResource {
+
+    private static final Logger LOG = LoggerFactory.getLogger(UserAccountResource.class);
+
+    private static final String ENTITY_NAME = "userAccount";
+
+    @Value("${jhipster.clientApp.name}")
+    private String applicationName;
+
+    private final UserAccountRepository userAccountRepository;
+
+    public UserAccountResource(UserAccountRepository userAccountRepository) {
+        this.userAccountRepository = userAccountRepository;
+    }
+
+    /**
+     * {@code POST  /user-accounts} : Create a new userAccount.
+     *
+     * @param userAccount the userAccount to create.
+     * @return the {@link ResponseEntity} with status {@code 201 (Created)} and with body the new userAccount, or with status {@code 400 (Bad Request)} if the userAccount has already an ID.
+     * @throws URISyntaxException if the Location URI syntax is incorrect.
+     */
+    @PostMapping("")
+    public ResponseEntity<UserAccount> createUserAccount(@RequestBody UserAccount userAccount) throws URISyntaxException {
+        LOG.debug("REST request to save UserAccount : {}", userAccount);
+        if (userAccount.getId() != null) {
+            throw new BadRequestAlertException("A new userAccount cannot already have an ID", ENTITY_NAME, "idexists");
+        }
+        userAccount = userAccountRepository.save(userAccount);
+        return ResponseEntity.created(new URI("/api/user-accounts/" + userAccount.getId()))
+            .headers(HeaderUtil.createEntityCreationAlert(applicationName, false, ENTITY_NAME, userAccount.getId().toString()))
+            .body(userAccount);
+    }
+
+    /**
+     * {@code PUT  /user-accounts/:id} : Updates an existing userAccount.
+     *
+     * @param id the id of the userAccount to save.
+     * @param userAccount the userAccount to update.
+     * @return the {@link ResponseEntity} with status {@code 200 (OK)} and with body the updated userAccount,
+     * or with status {@code 400 (Bad Request)} if the userAccount is not valid,
+     * or with status {@code 500 (Internal Server Error)} if the userAccount couldn't be updated.
+     * @throws URISyntaxException if the Location URI syntax is incorrect.
+     */
+    @PutMapping("/{id}")
+    public ResponseEntity<UserAccount> updateUserAccount(
+        @PathVariable(value = "id", required = false) final Long id,
+        @RequestBody UserAccount userAccount
+    ) throws URISyntaxException {
+        LOG.debug("REST request to update UserAccount : {}, {}", id, userAccount);
+        if (userAccount.getId() == null) {
+            throw new BadRequestAlertException("Invalid id", ENTITY_NAME, "idnull");
+        }
+        if (!Objects.equals(id, userAccount.getId())) {
+            throw new BadRequestAlertException("Invalid ID", ENTITY_NAME, "idinvalid");
+        }
+
+        if (!userAccountRepository.existsById(id)) {
+            throw new BadRequestAlertException("Entity not found", ENTITY_NAME, "idnotfound");
+        }
+
+        userAccount = userAccountRepository.save(userAccount);
+        return ResponseEntity.ok()
+            .headers(HeaderUtil.createEntityUpdateAlert(applicationName, false, ENTITY_NAME, userAccount.getId().toString()))
+            .body(userAccount);
+    }
+
+    /**
+     * {@code PATCH  /user-accounts/:id} : Partial updates given fields of an existing userAccount, field will ignore if it is null
+     *
+     * @param id the id of the userAccount to save.
+     * @param userAccount the userAccount to update.
+     * @return the {@link ResponseEntity} with status {@code 200 (OK)} and with body the updated userAccount,
+     * or with status {@code 400 (Bad Request)} if the userAccount is not valid,
+     * or with status {@code 404 (Not Found)} if the userAccount is not found,
+     * or with status {@code 500 (Internal Server Error)} if the userAccount couldn't be updated.
+     * @throws URISyntaxException if the Location URI syntax is incorrect.
+     */
+    @PatchMapping(value = "/{id}", consumes = { "application/json", "application/merge-patch+json" })
+    public ResponseEntity<UserAccount> partialUpdateUserAccount(
+        @PathVariable(value = "id", required = false) final Long id,
+        @RequestBody UserAccount userAccount
+    ) throws URISyntaxException {
+        LOG.debug("REST request to partial update UserAccount partially : {}, {}", id, userAccount);
+        if (userAccount.getId() == null) {
+            throw new BadRequestAlertException("Invalid id", ENTITY_NAME, "idnull");
+        }
+        if (!Objects.equals(id, userAccount.getId())) {
+            throw new BadRequestAlertException("Invalid ID", ENTITY_NAME, "idinvalid");
+        }
+
+        if (!userAccountRepository.existsById(id)) {
+            throw new BadRequestAlertException("Entity not found", ENTITY_NAME, "idnotfound");
+        }
+
+        Optional<UserAccount> result = userAccountRepository
+            .findById(userAccount.getId())
+            .map(existingUserAccount -> {
+                if (userAccount.getName() != null) {
+                    existingUserAccount.setName(userAccount.getName());
+                }
+
+                return existingUserAccount;
+            })
+            .map(userAccountRepository::save);
+
+        return ResponseUtil.wrapOrNotFound(
+            result,
+            HeaderUtil.createEntityUpdateAlert(applicationName, false, ENTITY_NAME, userAccount.getId().toString())
+        );
+    }
+
+    /**
+     * {@code GET  /user-accounts} : get all the userAccounts.
+     *
+     * @param eagerload flag to eager load entities from relationships (This is applicable for many-to-many).
+     * @return the {@link ResponseEntity} with status {@code 200 (OK)} and the list of userAccounts in body.
+     */
+    @GetMapping("")
+    public List<UserAccount> getAllUserAccounts(
+        @RequestParam(name = "eagerload", required = false, defaultValue = "true") boolean eagerload
+    ) {
+        LOG.debug("REST request to get all UserAccounts");
+        if (eagerload) {
+            return userAccountRepository.findAllWithEagerRelationships();
+        } else {
+            return userAccountRepository.findAll();
+        }
+    }
+
+    /**
+     * {@code GET  /user-accounts/:id} : get the "id" userAccount.
+     *
+     * @param id the id of the userAccount to retrieve.
+     * @return the {@link ResponseEntity} with status {@code 200 (OK)} and with body the userAccount, or with status {@code 404 (Not Found)}.
+     */
+    @GetMapping("/{id}")
+    public ResponseEntity<UserAccount> getUserAccount(@PathVariable("id") Long id) {
+        LOG.debug("REST request to get UserAccount : {}", id);
+        Optional<UserAccount> userAccount = userAccountRepository.findOneWithEagerRelationships(id);
+        return ResponseUtil.wrapOrNotFound(userAccount);
+    }
+
+    /**
+     * {@code DELETE  /user-accounts/:id} : delete the "id" userAccount.
+     *
+     * @param id the id of the userAccount to delete.
+     * @return the {@link ResponseEntity} with status {@code 204 (NO_CONTENT)}.
+     */
+    @DeleteMapping("/{id}")
+    public ResponseEntity<Void> deleteUserAccount(@PathVariable("id") Long id) {
+        LOG.debug("REST request to delete UserAccount : {}", id);
+        userAccountRepository.deleteById(id);
+        return ResponseEntity.noContent()
+            .headers(HeaderUtil.createEntityDeletionAlert(applicationName, false, ENTITY_NAME, id.toString()))
+            .build();
+    }
+}

src/main/resources/config/liquibase/changelog/20241113134007_added_entity_Transaction.xml

@@ -0,0 +1,59 @@
+<?xml version="1.0" encoding="utf-8"?>
+<databaseChangeLog
+    xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+    xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-latest.xsd
+                        http://www.liquibase.org/xml/ns/dbchangelog-ext http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-ext.xsd">
+
+    <!--
+        Added the entity Transaction.
+    -->
+    <changeSet id="20241113134007-1" author="jhipster">
+        <createTable tableName="transaction">
+            <column name="id" type="bigint">
+                <constraints primaryKey="true" nullable="false"/>
+            </column>
+            <column name="type" type="varchar(255)">
+                <constraints nullable="true" />
+            </column>
+            <column name="date" type="date">
+                <constraints nullable="true" />
+            </column>
+            <column name="comment" type="varchar(255)">
+                <constraints nullable="true" />
+            </column>
+            <column name="event_id" type="bigint">
+                <constraints nullable="true" />
+            </column>
+            <column name="transaction_item_id" type="bigint">
+                <constraints nullable="true" />
+            </column>
+            <!-- jhipster-needle-liquibase-add-column - JHipster will add columns here -->
+        </createTable>
+    </changeSet>
+
+    <!-- jhipster-needle-liquibase-add-changeset - JHipster will add changesets here -->
+
+    <!--
+        Load sample data generated with Faker.js
+        - This data can be easily edited using a CSV editor (or even MS Excel) and
+          is located in the 'src/main/resources/config/liquibase/fake-data' directory
+        - By default this data is applied when running with the JHipster 'dev' profile.
+          This can be customized by adding or removing 'faker' in the 'spring.liquibase.contexts'
+          Spring Boot configuration key.
+    -->
+    <changeSet id="20241113134007-1-data" author="jhipster" context="faker">
+        <loadData
+                  file="config/liquibase/fake-data/transaction.csv"
+                  separator=";"
+                  tableName="transaction"
+                  usePreparedStatements="true">
+            <column name="id" type="numeric"/>
+            <column name="type" type="string"/>
+            <column name="date" type="date"/>
+            <column name="comment" type="string"/>
+            <!-- jhipster-needle-liquibase-add-loadcolumn - JHipster (and/or extensions) can add load columns here -->
+        </loadData>
+    </changeSet>
+</databaseChangeLog>

src/main/resources/config/liquibase/changelog/20241113134007_added_entity_constraints_Transaction.xml

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<databaseChangeLog
+    xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+    xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-latest.xsd
+                        http://www.liquibase.org/xml/ns/dbchangelog-ext http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-ext.xsd">
+    <!--
+        Added the constraints for entity Transaction.
+    -->
+    <changeSet id="20241113134007-2" author="jhipster">
+
+        <addForeignKeyConstraint baseColumnNames="event_id"
+                                 baseTableName="transaction"
+                                 constraintName="fk_transaction__event_id"
+                                 referencedColumnNames="id"
+                                 referencedTableName="event"
+                                 />
+
+        <addForeignKeyConstraint baseColumnNames="transaction_item_id"
+                                 baseTableName="transaction"
+                                 constraintName="fk_transaction__transaction_item_id"
+                                 referencedColumnNames="id"
+                                 referencedTableName="transaction_item"
+                                 />
+    </changeSet>
+</databaseChangeLog>

src/main/resources/config/liquibase/changelog/20241113135042_added_entity_UserAccount.xml

@@ -0,0 +1,59 @@
+<?xml version="1.0" encoding="utf-8"?>
+<databaseChangeLog
+    xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+    xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-latest.xsd
+                        http://www.liquibase.org/xml/ns/dbchangelog-ext http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-ext.xsd">
+
+    <!--
+        Added the entity UserAccount.
+    -->
+    <changeSet id="20241113135042-1" author="jhipster">
+        <createTable tableName="user_account">
+            <column name="id" type="bigint">
+                <constraints primaryKey="true" nullable="false"/>
+            </column>
+            <column name="name" type="varchar(255)">
+                <constraints nullable="true" />
+            </column>
+            <!-- jhipster-needle-liquibase-add-column - JHipster will add columns here -->
+        </createTable>
+    </changeSet>
+
+    <changeSet id="20241113135042-1-relations" author="jhipster">
+
+        <createTable tableName="rel_user_account__user">
+            <column name="user_id" type="varchar(100)">
+                <constraints nullable="false"/>
+            </column>
+            <column name="user_account_id" type="bigint">
+                <constraints nullable="false"/>
+            </column>
+        </createTable>
+
+        <addPrimaryKey columnNames="user_account_id, user_id" tableName="rel_user_account__user"/>
+    </changeSet>
+
+    <!-- jhipster-needle-liquibase-add-changeset - JHipster will add changesets here -->
+
+    <!--
+        Load sample data generated with Faker.js
+        - This data can be easily edited using a CSV editor (or even MS Excel) and
+          is located in the 'src/main/resources/config/liquibase/fake-data' directory
+        - By default this data is applied when running with the JHipster 'dev' profile.
+          This can be customized by adding or removing 'faker' in the 'spring.liquibase.contexts'
+          Spring Boot configuration key.
+    -->
+    <changeSet id="20241113135042-1-data" author="jhipster" context="faker">
+        <loadData
+                  file="config/liquibase/fake-data/user_account.csv"
+                  separator=";"
+                  tableName="user_account"
+                  usePreparedStatements="true">
+            <column name="id" type="numeric"/>
+            <column name="name" type="string"/>
+            <!-- jhipster-needle-liquibase-add-loadcolumn - JHipster (and/or extensions) can add load columns here -->
+        </loadData>
+    </changeSet>
+</databaseChangeLog>

src/main/resources/config/liquibase/changelog/20241113135042_added_entity_constraints_UserAccount.xml

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<databaseChangeLog
+    xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+    xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-latest.xsd
+                        http://www.liquibase.org/xml/ns/dbchangelog-ext http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-ext.xsd">
+    <!--
+        Added the constraints for entity UserAccount.
+    -->
+    <changeSet id="20241113135042-2" author="jhipster">
+
+        <addForeignKeyConstraint baseColumnNames="user_account_id"
+                                 baseTableName="rel_user_account__user"
+                                 constraintName="fk_rel_user_account__user__user_account_id"
+                                 referencedColumnNames="id"
+                                 referencedTableName="user_account"
+                                 />
+
+        <addForeignKeyConstraint baseColumnNames="user_id"
+                                 baseTableName="rel_user_account__user"
+                                 constraintName="fk_rel_user_account__user__user_id"
+                                 referencedColumnNames="id"
+                                 referencedTableName="jhi_user"
+                                 />
+    </changeSet>
+</databaseChangeLog>

src/main/resources/config/liquibase/changelog/20241113135446_added_entity_TransactionItem.xml

@@ -0,0 +1,67 @@
+<?xml version="1.0" encoding="utf-8"?>
+<databaseChangeLog
+    xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+    xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-latest.xsd
+                        http://www.liquibase.org/xml/ns/dbchangelog-ext http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-ext.xsd">
+
+    <!--
+        Added the entity TransactionItem.
+    -->
+    <changeSet id="20241113135446-1" author="jhipster">
+        <createTable tableName="transaction_item">
+            <column name="id" type="bigint">
+                <constraints primaryKey="true" nullable="false"/>
+            </column>
+            <column name="amount" type="decimal(21,2)">
+                <constraints nullable="true" />
+            </column>
+            <column name="date" type="date">
+                <constraints nullable="true" />
+            </column>
+            <column name="comment" type="varchar(255)">
+                <constraints nullable="true" />
+            </column>
+            <!-- jhipster-needle-liquibase-add-column - JHipster will add columns here -->
+        </createTable>
+    </changeSet>
+
+    <changeSet id="20241113135446-1-relations" author="jhipster">
+
+        <createTable tableName="rel_transaction_item__user_account">
+            <column name="user_account_id" type="bigint">
+                <constraints nullable="false"/>
+            </column>
+            <column name="transaction_item_id" type="bigint">
+                <constraints nullable="false"/>
+            </column>
+        </createTable>
+
+        <addPrimaryKey columnNames="transaction_item_id, user_account_id" tableName="rel_transaction_item__user_account"/>
+    </changeSet>
+
+    <!-- jhipster-needle-liquibase-add-changeset - JHipster will add changesets here -->
+
+    <!--
+        Load sample data generated with Faker.js
+        - This data can be easily edited using a CSV editor (or even MS Excel) and
+          is located in the 'src/main/resources/config/liquibase/fake-data' directory
+        - By default this data is applied when running with the JHipster 'dev' profile.
+          This can be customized by adding or removing 'faker' in the 'spring.liquibase.contexts'
+          Spring Boot configuration key.
+    -->
+    <changeSet id="20241113135446-1-data" author="jhipster" context="faker">
+        <loadData
+                  file="config/liquibase/fake-data/transaction_item.csv"
+                  separator=";"
+                  tableName="transaction_item"
+                  usePreparedStatements="true">
+            <column name="id" type="numeric"/>
+            <column name="amount" type="numeric"/>
+            <column name="date" type="date"/>
+            <column name="comment" type="string"/>
+            <!-- jhipster-needle-liquibase-add-loadcolumn - JHipster (and/or extensions) can add load columns here -->
+        </loadData>
+    </changeSet>
+</databaseChangeLog>

src/main/resources/config/liquibase/changelog/20241113135446_added_entity_constraints_TransactionItem.xml

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<databaseChangeLog
+    xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+    xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-latest.xsd
+                        http://www.liquibase.org/xml/ns/dbchangelog-ext http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-ext.xsd">
+    <!--
+        Added the constraints for entity TransactionItem.
+    -->
+    <changeSet id="20241113135446-2" author="jhipster">
+
+        <addForeignKeyConstraint baseColumnNames="transaction_item_id"
+                                 baseTableName="rel_transaction_item__user_account"
+                                 constraintName="fk_rel_transaction_item__user_account__transaction_item_id"
+                                 referencedColumnNames="id"
+                                 referencedTableName="transaction_item"
+                                 />
+
+        <addForeignKeyConstraint baseColumnNames="user_account_id"
+                                 baseTableName="rel_transaction_item__user_account"
+                                 constraintName="fk_rel_transaction_item__user_account__user_account_id"
+                                 referencedColumnNames="id"
+                                 referencedTableName="user_account"
+                                 />
+    </changeSet>
+</databaseChangeLog>

src/main/resources/config/liquibase/fake-data/transaction.csv

@@ -0,0 +1,11 @@
+id;type;date;comment
+1;MATCH;2024-11-12;hope gad outside
+2;FIELDPAYMENT;2024-11-12;fibre
+3;INTERNALTRANSFER;2024-11-12;finger
+4;MATCH;2024-11-12;fair victorious sniff
+5;MATCH;2024-11-12;yuck
+6;PURCHASE;2024-11-13;correctly
+7;INTERNALTRANSFER;2024-11-12;behind gladly alongside
+8;FIELDPAYMENT;2024-11-13;negative
+9;FIELDPAYMENT;2024-11-13;unlucky
+10;FIELDPAYMENT;2024-11-12;see scorpion

src/main/resources/config/liquibase/fake-data/transaction_item.csv

@@ -0,0 +1,11 @@
+id;amount;date;comment
+1;11521.38;2024-11-13;until knowingly antagonize
+2;25335.92;2024-11-13;paintwork
+3;18782.46;2024-11-13;whoever
+4;31380.57;2024-11-13;saturate snow vestment
+5;16957.5;2024-11-13;desecrate
+6;21000.66;2024-11-13;card
+7;21849.26;2024-11-13;as hourly ha
+8;11729.78;2024-11-13;on fledgling
+9;17672.41;2024-11-13;sarcastic or
+10;22248.04;2024-11-12;where gadzooks out

src/main/resources/config/liquibase/fake-data/user_account.csv

@@ -0,0 +1,11 @@
+id;name
+1;since
+2;pfft what jam-packed
+3;internalise
+4;yum indeed for
+5;minion gee
+6;likewise impressive concerning
+7;notwithstanding
+8;furthermore
+9;diligently kindly
+10;buck

src/main/resources/config/liquibase/master.xml

@@ -14,9 +14,15 @@
     <include file="config/liquibase/changelog/20241105091001_added_entity_Charge.xml" relativeToChangelogFile="false"/>
     <include file="config/liquibase/changelog/20241105091002_added_entity_Event.xml" relativeToChangelogFile="false"/>
     <include file="config/liquibase/changelog/20241105091003_added_entity_Registration.xml" relativeToChangelogFile="false"/>
+    <include file="config/liquibase/changelog/20241113134007_added_entity_Transaction.xml" relativeToChangelogFile="false"/>
+    <include file="config/liquibase/changelog/20241113135042_added_entity_UserAccount.xml" relativeToChangelogFile="false"/>
+    <include file="config/liquibase/changelog/20241113135446_added_entity_TransactionItem.xml" relativeToChangelogFile="false"/>
     <!-- jhipster-needle-liquibase-add-changelog - JHipster will add liquibase changelogs here -->
     <include file="config/liquibase/changelog/20241105091001_added_entity_constraints_Charge.xml" relativeToChangelogFile="false"/>
     <include file="config/liquibase/changelog/20241105091003_added_entity_constraints_Registration.xml" relativeToChangelogFile="false"/>
+    <include file="config/liquibase/changelog/20241113134007_added_entity_constraints_Transaction.xml" relativeToChangelogFile="false"/>
+    <include file="config/liquibase/changelog/20241113135042_added_entity_constraints_UserAccount.xml" relativeToChangelogFile="false"/>
+    <include file="config/liquibase/changelog/20241113135446_added_entity_constraints_TransactionItem.xml" relativeToChangelogFile="false"/>
     <!-- jhipster-needle-liquibase-add-constraints-changelog - JHipster will add liquibase constraints changelogs here -->
     <!-- jhipster-needle-liquibase-add-incremental-changelog - JHipster will add incremental liquibase changelogs here -->
 </databaseChangeLog>

src/main/webapp/app/entities/charge/charge.service.spec.ts

@@ -100,7 +100,7 @@ describe('Service Tests', () => {
       });
 
       it('should partial update a Charge', async () => {
-        const patchObject = { chargeDate: dayjs(currentDate).format(DATE_FORMAT), type: 'BBBBBB', ...new Charge() };
+        const patchObject = { amount: 1, ...new Charge() };
         const returnedFromService = Object.assign(patchObject, elemDefault);
 
         const expected = { chargeDate: currentDate, ...returnedFromService };

src/main/webapp/app/entities/entities-menu.vue

@@ -12,6 +12,14 @@
       <font-awesome-icon icon="asterisk" />
       <span>Registration</span>
     </b-dropdown-item>
+    <b-dropdown-item to="/transaction">
+      <font-awesome-icon icon="asterisk" />
+      <span>Transaction</span>
+    </b-dropdown-item>
+    <b-dropdown-item to="/user-account">
+      <font-awesome-icon icon="asterisk" />
+      <span>User Account</span>
+    </b-dropdown-item>
     <!-- jhipster-needle-add-entity-to-menu - JHipster will add entities to the menu here -->
   </div>
 </template>

src/main/webapp/app/entities/entities.component.ts

@@ -3,6 +3,8 @@ import { defineComponent, provide } from 'vue';
 import ChargeService from './charge/charge.service';
 import EventService from './event/event.service';
 import RegistrationService from './registration/registration.service';
+import TransactionService from './transaction/transaction.service';
+import UserAccountService from './user-account/user-account.service';
 import UserService from '@/entities/user/user.service';
 // jhipster-needle-add-entity-service-to-entities-component-import - JHipster will import entities services here
 
@@ -14,6 +16,8 @@ export default defineComponent({
     provide('chargeService', () => new ChargeService());
     provide('eventService', () => new EventService());
     provide('registrationService', () => new RegistrationService());
+    provide('transactionService', () => new TransactionService());
+    provide('userAccountService', () => new UserAccountService());
     // jhipster-needle-add-entity-service-to-entities-component - JHipster will import entities services here
   },
 });

src/main/webapp/app/entities/event/event.service.spec.ts

@@ -107,7 +107,7 @@ describe('Service Tests', () => {
       });
 
       it('should partial update a Event', async () => {
-        const patchObject = { name: 'BBBBBB', date: dayjs(currentDate).format(DATE_FORMAT), cost: 1, ...new Event() };
+        const patchObject = { name: 'BBBBBB', playersLimit: 1, cost: 1, ...new Event() };
         const returnedFromService = Object.assign(patchObject, elemDefault);
 
         const expected = { date: currentDate, ...returnedFromService };

src/main/webapp/app/entities/registration/registration.service.spec.ts

@@ -106,7 +106,7 @@ describe('Service Tests', () => {
       });
 
       it('should partial update a Registration', async () => {
-        const patchObject = { comment: 'BBBBBB', ...new Registration() };
+        const patchObject = { playerName: 'BBBBBB', comment: 'BBBBBB', ...new Registration() };
         const returnedFromService = Object.assign(patchObject, elemDefault);
 
         const expected = { dateTime: currentDate, ...returnedFromService };

src/main/webapp/app/entities/transaction/transaction-details.component.spec.ts

@@ -0,0 +1,89 @@
+/* tslint:disable max-line-length */
+import { vitest } from 'vitest';
+import { type MountingOptions, shallowMount } from '@vue/test-utils';
+import sinon, { type SinonStubbedInstance } from 'sinon';
+import { type RouteLocation } from 'vue-router';
+
+import TransactionDetails from './transaction-details.vue';
+import TransactionService from './transaction.service';
+import AlertService from '@/shared/alert/alert.service';
+
+type TransactionDetailsComponentType = InstanceType<typeof TransactionDetails>;
+
+let route: Partial<RouteLocation>;
+const routerGoMock = vitest.fn();
+
+vitest.mock('vue-router', () => ({
+  useRoute: () => route,
+  useRouter: () => ({ go: routerGoMock }),
+}));
+
+const transactionSample = { id: 123 };
+
+describe('Component Tests', () => {
+  let alertService: AlertService;
+
+  afterEach(() => {
+    vitest.resetAllMocks();
+  });
+
+  describe('Transaction Management Detail Component', () => {
+    let transactionServiceStub: SinonStubbedInstance<TransactionService>;
+    let mountOptions: MountingOptions<TransactionDetailsComponentType>['global'];
+
+    beforeEach(() => {
+      route = {};
+      transactionServiceStub = sinon.createStubInstance<TransactionService>(TransactionService);
+
+      alertService = new AlertService({
+        bvToast: {
+          toast: vitest.fn(),
+        } as any,
+      });
+
+      mountOptions = {
+        stubs: {
+          'font-awesome-icon': true,
+          'router-link': true,
+        },
+        provide: {
+          alertService,
+          transactionService: () => transactionServiceStub,
+        },
+      };
+    });
+
+    describe('Navigate to details', () => {
+      it('Should call load all on init', async () => {
+        // GIVEN
+        transactionServiceStub.find.resolves(transactionSample);
+        route = {
+          params: {
+            transactionId: `${123}`,
+          },
+        };
+        const wrapper = shallowMount(TransactionDetails, { global: mountOptions });
+        const comp = wrapper.vm;
+        // WHEN
+        await comp.$nextTick();
+
+        // THEN
+        expect(comp.transaction).toMatchObject(transactionSample);
+      });
+    });
+
+    describe('Previous state', () => {
+      it('Should go previous state', async () => {
+        transactionServiceStub.find.resolves(transactionSample);
+        const wrapper = shallowMount(TransactionDetails, { global: mountOptions });
+        const comp = wrapper.vm;
+        await comp.$nextTick();
+
+        comp.previousState();
+        await comp.$nextTick();
+
+        expect(routerGoMock).toHaveBeenCalledWith(-1);
+      });
+    });
+  });
+});

src/main/webapp/app/entities/transaction/transaction-details.component.ts

@@ -0,0 +1,41 @@
+import { type Ref, defineComponent, inject, ref } from 'vue';
+import { useRoute, useRouter } from 'vue-router';
+
+import TransactionService from './transaction.service';
+import { type ITransaction } from '@/shared/model/transaction.model';
+import { useAlertService } from '@/shared/alert/alert.service';
+
+export default defineComponent({
+  compatConfig: { MODE: 3 },
+  name: 'TransactionDetails',
+  setup() {
+    const transactionService = inject('transactionService', () => new TransactionService());
+    const alertService = inject('alertService', () => useAlertService(), true);
+
+    const route = useRoute();
+    const router = useRouter();
+
+    const previousState = () => router.go(-1);
+    const transaction: Ref<ITransaction> = ref({});
+
+    const retrieveTransaction = async transactionId => {
+      try {
+        const res = await transactionService().find(transactionId);
+        transaction.value = res;
+      } catch (error) {
+        alertService.showHttpError(error.response);
+      }
+    };
+
+    if (route.params?.transactionId) {
+      retrieveTransaction(route.params.transactionId);
+    }
+
+    return {
+      alertService,
+      transaction,
+
+      previousState,
+    };
+  },
+});

src/main/webapp/app/entities/transaction/transaction-details.vue

@@ -0,0 +1,52 @@
+<template>
+  <div class="row justify-content-center">
+    <div class="col-8">
+      <div v-if="transaction">
+        <h2 class="jh-entity-heading" data-cy="transactionDetailsHeading"><span>Transaction</span> {{ transaction.id }}</h2>
+        <dl class="row jh-entity-details">
+          <dt>
+            <span>Type</span>
+          </dt>
+          <dd>
+            <span>{{ transaction.type }}</span>
+          </dd>
+          <dt>
+            <span>Date</span>
+          </dt>
+          <dd>
+            <span>{{ transaction.date }}</span>
+          </dd>
+          <dt>
+            <span>Comment</span>
+          </dt>
+          <dd>
+            <span>{{ transaction.comment }}</span>
+          </dd>
+          <dt>
+            <span>Event</span>
+          </dt>
+          <dd>
+            <div v-if="transaction.event">
+              <router-link :to="{ name: 'EventView', params: { eventId: transaction.event.id } }">{{ transaction.event.name }}</router-link>
+            </div>
+          </dd>
+        </dl>
+        <button type="submit" @click.prevent="previousState()" class="btn btn-info" data-cy="entityDetailsBackButton">
+          <font-awesome-icon icon="arrow-left"></font-awesome-icon>&nbsp;<span>Back</span>
+        </button>
+        <router-link
+          v-if="transaction.id"
+          :to="{ name: 'TransactionEdit', params: { transactionId: transaction.id } }"
+          custom
+          v-slot="{ navigate }"
+        >
+          <button @click="navigate" class="btn btn-primary">
+            <font-awesome-icon icon="pencil-alt"></font-awesome-icon>&nbsp;<span>Edit</span>
+          </button>
+        </router-link>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script lang="ts" src="./transaction-details.component.ts"></script>

src/main/webapp/app/entities/transaction/transaction-update.component.spec.ts

@@ -0,0 +1,137 @@
+/* tslint:disable max-line-length */
+import { vitest } from 'vitest';
+import { type MountingOptions, shallowMount } from '@vue/test-utils';
+import sinon, { type SinonStubbedInstance } from 'sinon';
+import { type RouteLocation } from 'vue-router';
+
+import TransactionUpdate from './transaction-update.vue';
+import TransactionService from './transaction.service';
+import AlertService from '@/shared/alert/alert.service';
+
+import EventService from '@/entities/event/event.service';
+
+type TransactionUpdateComponentType = InstanceType<typeof TransactionUpdate>;
+
+let route: Partial<RouteLocation>;
+const routerGoMock = vitest.fn();
+
+vitest.mock('vue-router', () => ({
+  useRoute: () => route,
+  useRouter: () => ({ go: routerGoMock }),
+}));
+
+const transactionSample = { id: 123 };
+
+describe('Component Tests', () => {
+  let mountOptions: MountingOptions<TransactionUpdateComponentType>['global'];
+  let alertService: AlertService;
+
+  describe('Transaction Management Update Component', () => {
+    let comp: TransactionUpdateComponentType;
+    let transactionServiceStub: SinonStubbedInstance<TransactionService>;
+
+    beforeEach(() => {
+      route = {};
+      transactionServiceStub = sinon.createStubInstance<TransactionService>(TransactionService);
+      transactionServiceStub.retrieve.onFirstCall().resolves(Promise.resolve([]));
+
+      alertService = new AlertService({
+        bvToast: {
+          toast: vitest.fn(),
+        } as any,
+      });
+
+      mountOptions = {
+        stubs: {
+          'font-awesome-icon': true,
+          'b-input-group': true,
+          'b-input-group-prepend': true,
+          'b-form-datepicker': true,
+          'b-form-input': true,
+        },
+        provide: {
+          alertService,
+          transactionService: () => transactionServiceStub,
+          eventService: () =>
+            sinon.createStubInstance<EventService>(EventService, {
+              retrieve: sinon.stub().resolves({}),
+            } as any),
+        },
+      };
+    });
+
+    afterEach(() => {
+      vitest.resetAllMocks();
+    });
+
+    describe('save', () => {
+      it('Should call update service on save for existing entity', async () => {
+        // GIVEN
+        const wrapper = shallowMount(TransactionUpdate, { global: mountOptions });
+        comp = wrapper.vm;
+        comp.transaction = transactionSample;
+        transactionServiceStub.update.resolves(transactionSample);
+
+        // WHEN
+        comp.save();
+        await comp.$nextTick();
+
+        // THEN
+        expect(transactionServiceStub.update.calledWith(transactionSample)).toBeTruthy();
+        expect(comp.isSaving).toEqual(false);
+      });
+
+      it('Should call create service on save for new entity', async () => {
+        // GIVEN
+        const entity = {};
+        transactionServiceStub.create.resolves(entity);
+        const wrapper = shallowMount(TransactionUpdate, { global: mountOptions });
+        comp = wrapper.vm;
+        comp.transaction = entity;
+
+        // WHEN
+        comp.save();
+        await comp.$nextTick();
+
+        // THEN
+        expect(transactionServiceStub.create.calledWith(entity)).toBeTruthy();
+        expect(comp.isSaving).toEqual(false);
+      });
+    });
+
+    describe('Before route enter', () => {
+      it('Should retrieve data', async () => {
+        // GIVEN
+        transactionServiceStub.find.resolves(transactionSample);
+        transactionServiceStub.retrieve.resolves([transactionSample]);
+
+        // WHEN
+        route = {
+          params: {
+            transactionId: `${transactionSample.id}`,
+          },
+        };
+        const wrapper = shallowMount(TransactionUpdate, { global: mountOptions });
+        comp = wrapper.vm;
+        await comp.$nextTick();
+
+        // THEN
+        expect(comp.transaction).toMatchObject(transactionSample);
+      });
+    });
+
+    describe('Previous state', () => {
+      it('Should go previous state', async () => {
+        transactionServiceStub.find.resolves(transactionSample);
+        const wrapper = shallowMount(TransactionUpdate, { global: mountOptions });
+        comp = wrapper.vm;
+        await comp.$nextTick();
+
+        comp.previousState();
+        await comp.$nextTick();
+
+        expect(routerGoMock).toHaveBeenCalledWith(-1);
+      });
+    });
+  });
+});

src/main/webapp/app/entities/transaction/transaction-update.component.ts

@@ -0,0 +1,111 @@
+import { type Ref, computed, defineComponent, inject, ref } from 'vue';
+import { useRoute, useRouter } from 'vue-router';
+import { useVuelidate } from '@vuelidate/core';
+
+import TransactionService from './transaction.service';
+import { useValidation } from '@/shared/composables';
+import { useAlertService } from '@/shared/alert/alert.service';
+
+import EventService from '@/entities/event/event.service';
+import { type IEvent } from '@/shared/model/event.model';
+import { type ITransaction, Transaction } from '@/shared/model/transaction.model';
+import { TransactionType } from '@/shared/model/enumerations/transaction-type.model';
+
+export default defineComponent({
+  compatConfig: { MODE: 3 },
+  name: 'TransactionUpdate',
+  setup() {
+    const transactionService = inject('transactionService', () => new TransactionService());
+    const alertService = inject('alertService', () => useAlertService(), true);
+
+    const transaction: Ref<ITransaction> = ref(new Transaction());
+
+    const eventService = inject('eventService', () => new EventService());
+
+    const events: Ref<IEvent[]> = ref([]);
+    const transactionTypeValues: Ref<string[]> = ref(Object.keys(TransactionType));
+    const isSaving = ref(false);
+    const currentLanguage = inject('currentLanguage', () => computed(() => navigator.language ?? 'en'), true);
+
+    const route = useRoute();
+    const router = useRouter();
+
+    const previousState = () => router.go(-1);
+
+    const retrieveTransaction = async transactionId => {
+      try {
+        const res = await transactionService().find(transactionId);
+        transaction.value = res;
+      } catch (error) {
+        alertService.showHttpError(error.response);
+      }
+    };
+
+    if (route.params?.transactionId) {
+      retrieveTransaction(route.params.transactionId);
+    }
+
+    const initRelationships = () => {
+      eventService()
+        .retrieve()
+        .then(res => {
+          events.value = res.data;
+        });
+    };
+
+    initRelationships();
+
+    const validations = useValidation();
+    const validationRules = {
+      type: {},
+      date: {},
+      comment: {},
+      event: {},
+    };
+    const v$ = useVuelidate(validationRules, transaction as any);
+    v$.value.$validate();
+
+    return {
+      transactionService,
+      alertService,
+      transaction,
+      previousState,
+      transactionTypeValues,
+      isSaving,
+      currentLanguage,
+      events,
+      v$,
+    };
+  },
+  created(): void {},
+  methods: {
+    save(): void {
+      this.isSaving = true;
+      if (this.transaction.id) {
+        this.transactionService()
+          .update(this.transaction)
+          .then(param => {
+            this.isSaving = false;
+            this.previousState();
+            this.alertService.showInfo(`A Transaction is updated with identifier ${param.id}`);
+          })
+          .catch(error => {
+            this.isSaving = false;
+            this.alertService.showHttpError(error.response);
+          });
+      } else {
+        this.transactionService()
+          .create(this.transaction)
+          .then(param => {
+            this.isSaving = false;
+            this.previousState();
+            this.alertService.showSuccess(`A Transaction is created with identifier ${param.id}`);
+          })
+          .catch(error => {
+            this.isSaving = false;
+            this.alertService.showHttpError(error.response);
+          });
+      }
+    },
+  },
+});

src/main/webapp/app/entities/transaction/transaction-update.vue

@@ -0,0 +1,98 @@
+<template>
+  <div class="row justify-content-center">
+    <div class="col-8">
+      <form name="editForm" novalidate @submit.prevent="save()">
+        <h2 id="sasiedziApp.transaction.home.createOrEditLabel" data-cy="TransactionCreateUpdateHeading">Create or edit a Transaction</h2>
+        <div>
+          <div class="form-group" v-if="transaction.id">
+            <label for="id">ID</label>
+            <input type="text" class="form-control" id="id" name="id" v-model="transaction.id" readonly />
+          </div>
+          <div class="form-group">
+            <label class="form-control-label" for="transaction-type">Type</label>
+            <select
+              class="form-control"
+              name="type"
+              :class="{ valid: !v$.type.$invalid, invalid: v$.type.$invalid }"
+              v-model="v$.type.$model"
+              id="transaction-type"
+              data-cy="type"
+            >
+              <option v-for="transactionType in transactionTypeValues" :key="transactionType" :value="transactionType">
+                {{ transactionType }}
+              </option>
+            </select>
+          </div>
+          <div class="form-group">
+            <label class="form-control-label" for="transaction-date">Date</label>
+            <b-input-group class="mb-3">
+              <b-input-group-prepend>
+                <b-form-datepicker
+                  aria-controls="transaction-date"
+                  v-model="v$.date.$model"
+                  name="date"
+                  class="form-control"
+                  :locale="currentLanguage"
+                  button-only
+                  today-button
+                  reset-button
+                  close-button
+                >
+                </b-form-datepicker>
+              </b-input-group-prepend>
+              <b-form-input
+                id="transaction-date"
+                data-cy="date"
+                type="text"
+                class="form-control"
+                name="date"
+                :class="{ valid: !v$.date.$invalid, invalid: v$.date.$invalid }"
+                v-model="v$.date.$model"
+              />
+            </b-input-group>
+          </div>
+          <div class="form-group">
+            <label class="form-control-label" for="transaction-comment">Comment</label>
+            <input
+              type="text"
+              class="form-control"
+              name="comment"
+              id="transaction-comment"
+              data-cy="comment"
+              :class="{ valid: !v$.comment.$invalid, invalid: v$.comment.$invalid }"
+              v-model="v$.comment.$model"
+            />
+          </div>
+          <div class="form-group">
+            <label class="form-control-label" for="transaction-event">Event</label>
+            <select class="form-control" id="transaction-event" data-cy="event" name="event" v-model="transaction.event">
+              <option :value="null"></option>
+              <option
+                :value="transaction.event && eventOption.id === transaction.event.id ? transaction.event : eventOption"
+                v-for="eventOption in events"
+                :key="eventOption.id"
+              >
+                {{ eventOption.name }}
+              </option>
+            </select>
+          </div>
+        </div>
+        <div>
+          <button type="button" id="cancel-save" data-cy="entityCreateCancelButton" class="btn btn-secondary" @click="previousState()">
+            <font-awesome-icon icon="ban"></font-awesome-icon>&nbsp;<span>Cancel</span>
+          </button>
+          <button
+            type="submit"
+            id="save-entity"
+            data-cy="entityCreateSaveButton"
+            :disabled="v$.$invalid || isSaving"
+            class="btn btn-primary"
+          >
+            <font-awesome-icon icon="save"></font-awesome-icon>&nbsp;<span>Save</span>
+          </button>
+        </div>
+      </form>
+    </div>
+  </div>
+</template>
+<script lang="ts" src="./transaction-update.component.ts"></script>

src/main/webapp/app/entities/transaction/transaction.component.spec.ts

@@ -0,0 +1,100 @@
+/* tslint:disable max-line-length */
+import { vitest } from 'vitest';
+import { type MountingOptions, shallowMount } from '@vue/test-utils';
+import sinon, { type SinonStubbedInstance } from 'sinon';
+
+import Transaction from './transaction.vue';
+import TransactionService from './transaction.service';
+import AlertService from '@/shared/alert/alert.service';
+
+type TransactionComponentType = InstanceType<typeof Transaction>;
+
+const bModalStub = {
+  render: () => {},
+  methods: {
+    hide: () => {},
+    show: () => {},
+  },
+};
+
+describe('Component Tests', () => {
+  let alertService: AlertService;
+
+  describe('Transaction Management Component', () => {
+    let transactionServiceStub: SinonStubbedInstance<TransactionService>;
+    let mountOptions: MountingOptions<TransactionComponentType>['global'];
+
+    beforeEach(() => {
+      transactionServiceStub = sinon.createStubInstance<TransactionService>(TransactionService);
+      transactionServiceStub.retrieve.resolves({ headers: {} });
+
+      alertService = new AlertService({
+        bvToast: {
+          toast: vitest.fn(),
+        } as any,
+      });
+
+      mountOptions = {
+        stubs: {
+          bModal: bModalStub as any,
+          'font-awesome-icon': true,
+          'b-badge': true,
+          'b-button': true,
+          'router-link': true,
+        },
+        directives: {
+          'b-modal': {},
+        },
+        provide: {
+          alertService,
+          transactionService: () => transactionServiceStub,
+        },
+      };
+    });
+
+    describe('Mount', () => {
+      it('Should call load all on init', async () => {
+        // GIVEN
+        transactionServiceStub.retrieve.resolves({ headers: {}, data: [{ id: 123 }] });
+
+        // WHEN
+        const wrapper = shallowMount(Transaction, { global: mountOptions });
+        const comp = wrapper.vm;
+        await comp.$nextTick();
+
+        // THEN
+        expect(transactionServiceStub.retrieve.calledOnce).toBeTruthy();
+        expect(comp.transactions[0]).toEqual(expect.objectContaining({ id: 123 }));
+      });
+    });
+    describe('Handles', () => {
+      let comp: TransactionComponentType;
+
+      beforeEach(async () => {
+        const wrapper = shallowMount(Transaction, { global: mountOptions });
+        comp = wrapper.vm;
+        await comp.$nextTick();
+        transactionServiceStub.retrieve.reset();
+        transactionServiceStub.retrieve.resolves({ headers: {}, data: [] });
+      });
+
+      it('Should call delete service on confirmDelete', async () => {
+        // GIVEN
+        transactionServiceStub.delete.resolves({});
+
+        // WHEN
+        comp.prepareRemove({ id: 123 });
+
+        comp.removeTransaction();
+        await comp.$nextTick(); // clear components
+
+        // THEN
+        expect(transactionServiceStub.delete.called).toBeTruthy();
+
+        // THEN
+        await comp.$nextTick(); // handle component clear watch
+        expect(transactionServiceStub.retrieve.callCount).toEqual(1);
+      });
+    });
+  });
+});

src/main/webapp/app/entities/transaction/transaction.component.ts

@@ -0,0 +1,75 @@
+import { type Ref, defineComponent, inject, onMounted, ref } from 'vue';
+
+import TransactionService from './transaction.service';
+import { type ITransaction } from '@/shared/model/transaction.model';
+import { useAlertService } from '@/shared/alert/alert.service';
+
+export default defineComponent({
+  compatConfig: { MODE: 3 },
+  name: 'Transaction',
+  setup() {
+    const transactionService = inject('transactionService', () => new TransactionService());
+    const alertService = inject('alertService', () => useAlertService(), true);
+
+    const transactions: Ref<ITransaction[]> = ref([]);
+
+    const isFetching = ref(false);
+
+    const clear = () => {};
+
+    const retrieveTransactions = async () => {
+      isFetching.value = true;
+      try {
+        const res = await transactionService().retrieve();
+        transactions.value = res.data;
+      } catch (err) {
+        alertService.showHttpError(err.response);
+      } finally {
+        isFetching.value = false;
+      }
+    };
+
+    const handleSyncList = () => {
+      retrieveTransactions();
+    };
+
+    onMounted(async () => {
+      await retrieveTransactions();
+    });
+
+    const removeId: Ref<number> = ref(null);
+    const removeEntity = ref<any>(null);
+    const prepareRemove = (instance: ITransaction) => {
+      removeId.value = instance.id;
+      removeEntity.value.show();
+    };
+    const closeDialog = () => {
+      removeEntity.value.hide();
+    };
+    const removeTransaction = async () => {
+      try {
+        await transactionService().delete(removeId.value);
+        const message = `A Transaction is deleted with identifier ${removeId.value}`;
+        alertService.showInfo(message, { variant: 'danger' });
+        removeId.value = null;
+        retrieveTransactions();
+        closeDialog();
+      } catch (error) {
+        alertService.showHttpError(error.response);
+      }
+    };
+
+    return {
+      transactions,
+      handleSyncList,
+      isFetching,
+      retrieveTransactions,
+      clear,
+      removeId,
+      removeEntity,
+      prepareRemove,
+      closeDialog,
+      removeTransaction,
+    };
+  },
+});

src/main/webapp/app/entities/transaction/transaction.service.spec.ts

@@ -0,0 +1,164 @@
+/* tslint:disable max-line-length */
+import axios from 'axios';
+import sinon from 'sinon';
+import dayjs from 'dayjs';
+
+import TransactionService from './transaction.service';
+import { DATE_FORMAT } from '@/shared/composables/date-format';
+import { Transaction } from '@/shared/model/transaction.model';
+
+const error = {
+  response: {
+    status: null,
+    data: {
+      type: null,
+    },
+  },
+};
+
+const axiosStub = {
+  get: sinon.stub(axios, 'get'),
+  post: sinon.stub(axios, 'post'),
+  put: sinon.stub(axios, 'put'),
+  patch: sinon.stub(axios, 'patch'),
+  delete: sinon.stub(axios, 'delete'),
+};
+
+describe('Service Tests', () => {
+  describe('Transaction Service', () => {
+    let service: TransactionService;
+    let elemDefault;
+    let currentDate: Date;
+
+    beforeEach(() => {
+      service = new TransactionService();
+      currentDate = new Date();
+      elemDefault = new Transaction(123, 'PURCHASE', currentDate, 'AAAAAAA');
+    });
+
+    describe('Service methods', () => {
+      it('should find an element', async () => {
+        const returnedFromService = { date: dayjs(currentDate).format(DATE_FORMAT), ...elemDefault };
+        axiosStub.get.resolves({ data: returnedFromService });
+
+        return service.find(123).then(res => {
+          expect(res).toMatchObject(elemDefault);
+        });
+      });
+
+      it('should not find an element', async () => {
+        axiosStub.get.rejects(error);
+        return service
+          .find(123)
+          .then()
+          .catch(err => {
+            expect(err).toMatchObject(error);
+          });
+      });
+
+      it('should create a Transaction', async () => {
+        const returnedFromService = { id: 123, date: dayjs(currentDate).format(DATE_FORMAT), ...elemDefault };
+        const expected = { date: currentDate, ...returnedFromService };
+
+        axiosStub.post.resolves({ data: returnedFromService });
+        return service.create({}).then(res => {
+          expect(res).toMatchObject(expected);
+        });
+      });
+
+      it('should not create a Transaction', async () => {
+        axiosStub.post.rejects(error);
+
+        return service
+          .create({})
+          .then()
+          .catch(err => {
+            expect(err).toMatchObject(error);
+          });
+      });
+
+      it('should update a Transaction', async () => {
+        const returnedFromService = { type: 'BBBBBB', date: dayjs(currentDate).format(DATE_FORMAT), comment: 'BBBBBB', ...elemDefault };
+
+        const expected = { date: currentDate, ...returnedFromService };
+        axiosStub.put.resolves({ data: returnedFromService });
+
+        return service.update(expected).then(res => {
+          expect(res).toMatchObject(expected);
+        });
+      });
+
+      it('should not update a Transaction', async () => {
+        axiosStub.put.rejects(error);
+
+        return service
+          .update({})
+          .then()
+          .catch(err => {
+            expect(err).toMatchObject(error);
+          });
+      });
+
+      it('should partial update a Transaction', async () => {
+        const patchObject = { ...new Transaction() };
+        const returnedFromService = Object.assign(patchObject, elemDefault);
+
+        const expected = { date: currentDate, ...returnedFromService };
+        axiosStub.patch.resolves({ data: returnedFromService });
+
+        return service.partialUpdate(patchObject).then(res => {
+          expect(res).toMatchObject(expected);
+        });
+      });
+
+      it('should not partial update a Transaction', async () => {
+        axiosStub.patch.rejects(error);
+
+        return service
+          .partialUpdate({})
+          .then()
+          .catch(err => {
+            expect(err).toMatchObject(error);
+          });
+      });
+
+      it('should return a list of Transaction', async () => {
+        const returnedFromService = { type: 'BBBBBB', date: dayjs(currentDate).format(DATE_FORMAT), comment: 'BBBBBB', ...elemDefault };
+        const expected = { date: currentDate, ...returnedFromService };
+        axiosStub.get.resolves([returnedFromService]);
+        return service.retrieve().then(res => {
+          expect(res).toContainEqual(expected);
+        });
+      });
+
+      it('should not return a list of Transaction', async () => {
+        axiosStub.get.rejects(error);
+
+        return service
+          .retrieve()
+          .then()
+          .catch(err => {
+            expect(err).toMatchObject(error);
+          });
+      });
+
+      it('should delete a Transaction', async () => {
+        axiosStub.delete.resolves({ ok: true });
+        return service.delete(123).then(res => {
+          expect(res.ok).toBeTruthy();
+        });
+      });
+
+      it('should not delete a Transaction', async () => {
+        axiosStub.delete.rejects(error);
+
+        return service
+          .delete(123)
+          .then()
+          .catch(err => {
+            expect(err).toMatchObject(error);
+          });
+      });
+    });
+  });
+});

src/main/webapp/app/entities/transaction/transaction.service.ts

@@ -0,0 +1,85 @@
+import axios from 'axios';
+
+import { type ITransaction } from '@/shared/model/transaction.model';
+
+const baseApiUrl = 'api/transactions';
+
+export default class TransactionService {
+  public find(id: number): Promise<ITransaction> {
+    return new Promise<ITransaction>((resolve, reject) => {
+      axios
+        .get(`${baseApiUrl}/${id}`)
+        .then(res => {
+          resolve(res.data);
+        })
+        .catch(err => {
+          reject(err);
+        });
+    });
+  }
+
+  public retrieve(): Promise<any> {
+    return new Promise<any>((resolve, reject) => {
+      axios
+        .get(baseApiUrl)
+        .then(res => {
+          resolve(res);
+        })
+        .catch(err => {
+          reject(err);
+        });
+    });
+  }
+
+  public delete(id: number): Promise<any> {
+    return new Promise<any>((resolve, reject) => {
+      axios
+        .delete(`${baseApiUrl}/${id}`)
+        .then(res => {
+          resolve(res);
+        })
+        .catch(err => {
+          reject(err);
+        });
+    });
+  }
+
+  public create(entity: ITransaction): Promise<ITransaction> {
+    return new Promise<ITransaction>((resolve, reject) => {
+      axios
+        .post(`${baseApiUrl}`, entity)
+        .then(res => {
+          resolve(res.data);
+        })
+        .catch(err => {
+          reject(err);
+        });
+    });
+  }
+
+  public update(entity: ITransaction): Promise<ITransaction> {
+    return new Promise<ITransaction>((resolve, reject) => {
+      axios
+        .put(`${baseApiUrl}/${entity.id}`, entity)
+        .then(res => {
+          resolve(res.data);
+        })
+        .catch(err => {
+          reject(err);
+        });
+    });
+  }
+
+  public partialUpdate(entity: ITransaction): Promise<ITransaction> {
+    return new Promise<ITransaction>((resolve, reject) => {
+      axios
+        .patch(`${baseApiUrl}/${entity.id}`, entity)
+        .then(res => {
+          resolve(res.data);
+        })
+        .catch(err => {
+          reject(err);
+        });
+    });
+  }
+}

src/main/webapp/app/entities/transaction/transaction.vue

@@ -0,0 +1,108 @@
+<template>
+  <div>
+    <h2 id="page-heading" data-cy="TransactionHeading">
+      <span id="transaction-heading">Transactions</span>
+      <div class="d-flex justify-content-end">
+        <button class="btn btn-info mr-2" @click="handleSyncList" :disabled="isFetching">
+          <font-awesome-icon icon="sync" :spin="isFetching"></font-awesome-icon> <span>Refresh list</span>
+        </button>
+        <router-link :to="{ name: 'TransactionCreate' }" custom v-slot="{ navigate }">
+          <button
+            @click="navigate"
+            id="jh-create-entity"
+            data-cy="entityCreateButton"
+            class="btn btn-primary jh-create-entity create-transaction"
+          >
+            <font-awesome-icon icon="plus"></font-awesome-icon>
+            <span>Create a new Transaction</span>
+          </button>
+        </router-link>
+      </div>
+    </h2>
+    <br />
+    <div class="alert alert-warning" v-if="!isFetching && transactions && transactions.length === 0">
+      <span>No Transactions found</span>
+    </div>
+    <div class="table-responsive" v-if="transactions && transactions.length > 0">
+      <table class="table table-striped" aria-describedby="transactions">
+        <thead>
+          <tr>
+            <th scope="row"><span>ID</span></th>
+            <th scope="row"><span>Type</span></th>
+            <th scope="row"><span>Date</span></th>
+            <th scope="row"><span>Comment</span></th>
+            <th scope="row"><span>Event</span></th>
+            <th scope="row"></th>
+          </tr>
+        </thead>
+        <tbody>
+          <tr v-for="transaction in transactions" :key="transaction.id" data-cy="entityTable">
+            <td>
+              <router-link :to="{ name: 'TransactionView', params: { transactionId: transaction.id } }">{{ transaction.id }}</router-link>
+            </td>
+            <td>{{ transaction.type }}</td>
+            <td>{{ transaction.date }}</td>
+            <td>{{ transaction.comment }}</td>
+            <td>
+              <div v-if="transaction.event">
+                <router-link :to="{ name: 'EventView', params: { eventId: transaction.event.id } }">{{
+                  transaction.event.name
+                }}</router-link>
+              </div>
+            </td>
+            <td class="text-right">
+              <div class="btn-group">
+                <router-link :to="{ name: 'TransactionView', params: { transactionId: transaction.id } }" custom v-slot="{ navigate }">
+                  <button @click="navigate" class="btn btn-info btn-sm details" data-cy="entityDetailsButton">
+                    <font-awesome-icon icon="eye"></font-awesome-icon>
+                    <span class="d-none d-md-inline">View</span>
+                  </button>
+                </router-link>
+                <router-link :to="{ name: 'TransactionEdit', params: { transactionId: transaction.id } }" custom v-slot="{ navigate }">
+                  <button @click="navigate" class="btn btn-primary btn-sm edit" data-cy="entityEditButton">
+                    <font-awesome-icon icon="pencil-alt"></font-awesome-icon>
+                    <span class="d-none d-md-inline">Edit</span>
+                  </button>
+                </router-link>
+                <b-button
+                  @click="prepareRemove(transaction)"
+                  variant="danger"
+                  class="btn btn-sm"
+                  data-cy="entityDeleteButton"
+                  v-b-modal.removeEntity
+                >
+                  <font-awesome-icon icon="times"></font-awesome-icon>
+                  <span class="d-none d-md-inline">Delete</span>
+                </b-button>
+              </div>
+            </td>
+          </tr>
+        </tbody>
+      </table>
+    </div>
+    <b-modal ref="removeEntity" id="removeEntity">
+      <template #modal-title>
+        <span id="sasiedziApp.transaction.delete.question" data-cy="transactionDeleteDialogHeading">Confirm delete operation</span>
+      </template>
+      <div class="modal-body">
+        <p id="jhi-delete-transaction-heading">Are you sure you want to delete Transaction {{ removeId }}?</p>
+      </div>
+      <template #modal-footer>
+        <div>
+          <button type="button" class="btn btn-secondary" @click="closeDialog()">Cancel</button>
+          <button
+            type="button"
+            class="btn btn-primary"
+            id="jhi-confirm-delete-transaction"
+            data-cy="entityConfirmDeleteButton"
+            @click="removeTransaction()"
+          >
+            Delete
+          </button>
+        </div>
+      </template>
+    </b-modal>
+  </div>
+</template>
+
+<script lang="ts" src="./transaction.component.ts"></script>

src/main/webapp/app/entities/user-account/user-account-details.component.spec.ts

@@ -0,0 +1,89 @@
+/* tslint:disable max-line-length */
+import { vitest } from 'vitest';
+import { type MountingOptions, shallowMount } from '@vue/test-utils';
+import sinon, { type SinonStubbedInstance } from 'sinon';
+import { type RouteLocation } from 'vue-router';
+
+import UserAccountDetails from './user-account-details.vue';
+import UserAccountService from './user-account.service';
+import AlertService from '@/shared/alert/alert.service';
+
+type UserAccountDetailsComponentType = InstanceType<typeof UserAccountDetails>;
+
+let route: Partial<RouteLocation>;
+const routerGoMock = vitest.fn();
+
+vitest.mock('vue-router', () => ({
+  useRoute: () => route,
+  useRouter: () => ({ go: routerGoMock }),
+}));
+
+const userAccountSample = { id: 123 };
+
+describe('Component Tests', () => {
+  let alertService: AlertService;
+
+  afterEach(() => {
+    vitest.resetAllMocks();
+  });
+
+  describe('UserAccount Management Detail Component', () => {
+    let userAccountServiceStub: SinonStubbedInstance<UserAccountService>;
+    let mountOptions: MountingOptions<UserAccountDetailsComponentType>['global'];
+
+    beforeEach(() => {
+      route = {};
+      userAccountServiceStub = sinon.createStubInstance<UserAccountService>(UserAccountService);
+
+      alertService = new AlertService({
+        bvToast: {
+          toast: vitest.fn(),
+        } as any,
+      });
+
+      mountOptions = {
+        stubs: {
+          'font-awesome-icon': true,
+          'router-link': true,
+        },
+        provide: {
+          alertService,
+          userAccountService: () => userAccountServiceStub,
+        },
+      };
+    });
+
+    describe('Navigate to details', () => {
+      it('Should call load all on init', async () => {
+        // GIVEN
+        userAccountServiceStub.find.resolves(userAccountSample);
+        route = {
+          params: {
+            userAccountId: `${123}`,
+          },
+        };
+        const wrapper = shallowMount(UserAccountDetails, { global: mountOptions });
+        const comp = wrapper.vm;
+        // WHEN
+        await comp.$nextTick();
+
+        // THEN
+        expect(comp.userAccount).toMatchObject(userAccountSample);
+      });
+    });
+
+    describe('Previous state', () => {
+      it('Should go previous state', async () => {
+        userAccountServiceStub.find.resolves(userAccountSample);
+        const wrapper = shallowMount(UserAccountDetails, { global: mountOptions });
+        const comp = wrapper.vm;
+        await comp.$nextTick();
+
+        comp.previousState();
+        await comp.$nextTick();
+
+        expect(routerGoMock).toHaveBeenCalledWith(-1);
+      });
+    });
+  });
+});

src/main/webapp/app/entities/user-account/user-account-details.component.ts

@@ -0,0 +1,41 @@
+import { type Ref, defineComponent, inject, ref } from 'vue';
+import { useRoute, useRouter } from 'vue-router';
+
+import UserAccountService from './user-account.service';
+import { type IUserAccount } from '@/shared/model/user-account.model';
+import { useAlertService } from '@/shared/alert/alert.service';
+
+export default defineComponent({
+  compatConfig: { MODE: 3 },
+  name: 'UserAccountDetails',
+  setup() {
+    const userAccountService = inject('userAccountService', () => new UserAccountService());
+    const alertService = inject('alertService', () => useAlertService(), true);
+
+    const route = useRoute();
+    const router = useRouter();
+
+    const previousState = () => router.go(-1);
+    const userAccount: Ref<IUserAccount> = ref({});
+
+    const retrieveUserAccount = async userAccountId => {
+      try {
+        const res = await userAccountService().find(userAccountId);
+        userAccount.value = res;
+      } catch (error) {
+        alertService.showHttpError(error.response);
+      }
+    };
+
+    if (route.params?.userAccountId) {
+      retrieveUserAccount(route.params.userAccountId);
+    }
+
+    return {
+      alertService,
+      userAccount,
+
+      previousState,
+    };
+  },
+});

src/main/webapp/app/entities/user-account/user-account-details.vue

@@ -0,0 +1,41 @@
+<template>
+  <div class="row justify-content-center">
+    <div class="col-8">
+      <div v-if="userAccount">
+        <h2 class="jh-entity-heading" data-cy="userAccountDetailsHeading"><span>User Account</span> {{ userAccount.id }}</h2>
+        <dl class="row jh-entity-details">
+          <dt>
+            <span>Name</span>
+          </dt>
+          <dd>
+            <span>{{ userAccount.name }}</span>
+          </dd>
+          <dt>
+            <span>User</span>
+          </dt>
+          <dd>
+            <span v-for="(user, i) in userAccount.users" :key="user.id"
+              >{{ i > 0 ? ', ' : '' }}
+              {{ user.login }}
+            </span>
+          </dd>
+        </dl>
+        <button type="submit" @click.prevent="previousState()" class="btn btn-info" data-cy="entityDetailsBackButton">
+          <font-awesome-icon icon="arrow-left"></font-awesome-icon>&nbsp;<span>Back</span>
+        </button>
+        <router-link
+          v-if="userAccount.id"
+          :to="{ name: 'UserAccountEdit', params: { userAccountId: userAccount.id } }"
+          custom
+          v-slot="{ navigate }"
+        >
+          <button @click="navigate" class="btn btn-primary">
+            <font-awesome-icon icon="pencil-alt"></font-awesome-icon>&nbsp;<span>Edit</span>
+          </button>
+        </router-link>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script lang="ts" src="./user-account-details.component.ts"></script>

src/main/webapp/app/entities/user-account/user-account-update.component.spec.ts

@@ -0,0 +1,138 @@
+/* tslint:disable max-line-length */
+import { vitest } from 'vitest';
+import { type MountingOptions, shallowMount } from '@vue/test-utils';
+import sinon, { type SinonStubbedInstance } from 'sinon';
+import { type RouteLocation } from 'vue-router';
+
+import UserAccountUpdate from './user-account-update.vue';
+import UserAccountService from './user-account.service';
+import AlertService from '@/shared/alert/alert.service';
+
+import UserService from '@/entities/user/user.service';
+
+type UserAccountUpdateComponentType = InstanceType<typeof UserAccountUpdate>;
+
+let route: Partial<RouteLocation>;
+const routerGoMock = vitest.fn();
+
+vitest.mock('vue-router', () => ({
+  useRoute: () => route,
+  useRouter: () => ({ go: routerGoMock }),
+}));
+
+const userAccountSample = { id: 123 };
+
+describe('Component Tests', () => {
+  let mountOptions: MountingOptions<UserAccountUpdateComponentType>['global'];
+  let alertService: AlertService;
+
+  describe('UserAccount Management Update Component', () => {
+    let comp: UserAccountUpdateComponentType;
+    let userAccountServiceStub: SinonStubbedInstance<UserAccountService>;
+
+    beforeEach(() => {
+      route = {};
+      userAccountServiceStub = sinon.createStubInstance<UserAccountService>(UserAccountService);
+      userAccountServiceStub.retrieve.onFirstCall().resolves(Promise.resolve([]));
+
+      alertService = new AlertService({
+        bvToast: {
+          toast: vitest.fn(),
+        } as any,
+      });
+
+      mountOptions = {
+        stubs: {
+          'font-awesome-icon': true,
+          'b-input-group': true,
+          'b-input-group-prepend': true,
+          'b-form-datepicker': true,
+          'b-form-input': true,
+        },
+        provide: {
+          alertService,
+          userAccountService: () => userAccountServiceStub,
+
+          userService: () =>
+            sinon.createStubInstance<UserService>(UserService, {
+              retrieve: sinon.stub().resolves({}),
+            } as any),
+        },
+      };
+    });
+
+    afterEach(() => {
+      vitest.resetAllMocks();
+    });
+
+    describe('save', () => {
+      it('Should call update service on save for existing entity', async () => {
+        // GIVEN
+        const wrapper = shallowMount(UserAccountUpdate, { global: mountOptions });
+        comp = wrapper.vm;
+        comp.userAccount = userAccountSample;
+        userAccountServiceStub.update.resolves(userAccountSample);
+
+        // WHEN
+        comp.save();
+        await comp.$nextTick();
+
+        // THEN
+        expect(userAccountServiceStub.update.calledWith(userAccountSample)).toBeTruthy();
+        expect(comp.isSaving).toEqual(false);
+      });
+
+      it('Should call create service on save for new entity', async () => {
+        // GIVEN
+        const entity = {};
+        userAccountServiceStub.create.resolves(entity);
+        const wrapper = shallowMount(UserAccountUpdate, { global: mountOptions });
+        comp = wrapper.vm;
+        comp.userAccount = entity;
+
+        // WHEN
+        comp.save();
+        await comp.$nextTick();
+
+        // THEN
+        expect(userAccountServiceStub.create.calledWith(entity)).toBeTruthy();
+        expect(comp.isSaving).toEqual(false);
+      });
+    });
+
+    describe('Before route enter', () => {
+      it('Should retrieve data', async () => {
+        // GIVEN
+        userAccountServiceStub.find.resolves(userAccountSample);
+        userAccountServiceStub.retrieve.resolves([userAccountSample]);
+
+        // WHEN
+        route = {
+          params: {
+            userAccountId: `${userAccountSample.id}`,
+          },
+        };
+        const wrapper = shallowMount(UserAccountUpdate, { global: mountOptions });
+        comp = wrapper.vm;
+        await comp.$nextTick();
+
+        // THEN
+        expect(comp.userAccount).toMatchObject(userAccountSample);
+      });
+    });
+
+    describe('Previous state', () => {
+      it('Should go previous state', async () => {
+        userAccountServiceStub.find.resolves(userAccountSample);
+        const wrapper = shallowMount(UserAccountUpdate, { global: mountOptions });
+        comp = wrapper.vm;
+        await comp.$nextTick();
+
+        comp.previousState();
+        await comp.$nextTick();
+
+        expect(routerGoMock).toHaveBeenCalledWith(-1);
+      });
+    });
+  });
+});

src/main/webapp/app/entities/user-account/user-account-update.component.ts

@@ -0,0 +1,112 @@
+import { type Ref, computed, defineComponent, inject, ref } from 'vue';
+import { useRoute, useRouter } from 'vue-router';
+import { useVuelidate } from '@vuelidate/core';
+
+import UserAccountService from './user-account.service';
+import { useValidation } from '@/shared/composables';
+import { useAlertService } from '@/shared/alert/alert.service';
+
+import UserService from '@/entities/user/user.service';
+import { type IUserAccount, UserAccount } from '@/shared/model/user-account.model';
+
+export default defineComponent({
+  compatConfig: { MODE: 3 },
+  name: 'UserAccountUpdate',
+  setup() {
+    const userAccountService = inject('userAccountService', () => new UserAccountService());
+    const alertService = inject('alertService', () => useAlertService(), true);
+
+    const userAccount: Ref<IUserAccount> = ref(new UserAccount());
+    const userService = inject('userService', () => new UserService());
+    const users: Ref<Array<any>> = ref([]);
+    const isSaving = ref(false);
+    const currentLanguage = inject('currentLanguage', () => computed(() => navigator.language ?? 'en'), true);
+
+    const route = useRoute();
+    const router = useRouter();
+
+    const previousState = () => router.go(-1);
+
+    const retrieveUserAccount = async userAccountId => {
+      try {
+        const res = await userAccountService().find(userAccountId);
+        userAccount.value = res;
+      } catch (error) {
+        alertService.showHttpError(error.response);
+      }
+    };
+
+    if (route.params?.userAccountId) {
+      retrieveUserAccount(route.params.userAccountId);
+    }
+
+    const initRelationships = () => {
+      userService()
+        .retrieve()
+        .then(res => {
+          users.value = res.data;
+        });
+    };
+
+    initRelationships();
+
+    const validations = useValidation();
+    const validationRules = {
+      name: {},
+      users: {},
+    };
+    const v$ = useVuelidate(validationRules, userAccount as any);
+    v$.value.$validate();
+
+    return {
+      userAccountService,
+      alertService,
+      userAccount,
+      previousState,
+      isSaving,
+      currentLanguage,
+      users,
+      v$,
+    };
+  },
+  created(): void {
+    this.userAccount.users = [];
+  },
+  methods: {
+    save(): void {
+      this.isSaving = true;
+      if (this.userAccount.id) {
+        this.userAccountService()
+          .update(this.userAccount)
+          .then(param => {
+            this.isSaving = false;
+            this.previousState();
+            this.alertService.showInfo(`A UserAccount is updated with identifier ${param.id}`);
+          })
+          .catch(error => {
+            this.isSaving = false;
+            this.alertService.showHttpError(error.response);
+          });
+      } else {
+        this.userAccountService()
+          .create(this.userAccount)
+          .then(param => {
+            this.isSaving = false;
+            this.previousState();
+            this.alertService.showSuccess(`A UserAccount is created with identifier ${param.id}`);
+          })
+          .catch(error => {
+            this.isSaving = false;
+            this.alertService.showHttpError(error.response);
+          });
+      }
+    },
+
+    getSelected(selectedVals, option, pkField = 'id'): any {
+      if (selectedVals) {
+        return selectedVals.find(value => option[pkField] === value[pkField]) ?? option;
+      }
+      return option;
+    },
+  },
+});

src/main/webapp/app/entities/user-account/user-account-update.vue

@@ -0,0 +1,58 @@
+<template>
+  <div class="row justify-content-center">
+    <div class="col-8">
+      <form name="editForm" novalidate @submit.prevent="save()">
+        <h2 id="sasiedziApp.userAccount.home.createOrEditLabel" data-cy="UserAccountCreateUpdateHeading">Create or edit a User Account</h2>
+        <div>
+          <div class="form-group" v-if="userAccount.id">
+            <label for="id">ID</label>
+            <input type="text" class="form-control" id="id" name="id" v-model="userAccount.id" readonly />
+          </div>
+          <div class="form-group">
+            <label class="form-control-label" for="user-account-name">Name</label>
+            <input
+              type="text"
+              class="form-control"
+              name="name"
+              id="user-account-name"
+              data-cy="name"
+              :class="{ valid: !v$.name.$invalid, invalid: v$.name.$invalid }"
+              v-model="v$.name.$model"
+            />
+          </div>
+          <div class="form-group">
+            <label for="user-account-user">User</label>
+            <select
+              class="form-control"
+              id="user-account-users"
+              data-cy="user"
+              multiple
+              name="user"
+              v-if="userAccount.users !== undefined"
+              v-model="userAccount.users"
+            >
+              <option :value="getSelected(userAccount.users, userOption, 'id')" v-for="userOption in users" :key="userOption.id">
+                {{ userOption.login }}
+              </option>
+            </select>
+          </div>
+        </div>
+        <div>
+          <button type="button" id="cancel-save" data-cy="entityCreateCancelButton" class="btn btn-secondary" @click="previousState()">
+            <font-awesome-icon icon="ban"></font-awesome-icon>&nbsp;<span>Cancel</span>
+          </button>
+          <button
+            type="submit"
+            id="save-entity"
+            data-cy="entityCreateSaveButton"
+            :disabled="v$.$invalid || isSaving"
+            class="btn btn-primary"
+          >
+            <font-awesome-icon icon="save"></font-awesome-icon>&nbsp;<span>Save</span>
+          </button>
+        </div>
+      </form>
+    </div>
+  </div>
+</template>
+<script lang="ts" src="./user-account-update.component.ts"></script>

src/main/webapp/app/entities/user-account/user-account.component.spec.ts

@@ -0,0 +1,100 @@
+/* tslint:disable max-line-length */
+import { vitest } from 'vitest';
+import { type MountingOptions, shallowMount } from '@vue/test-utils';
+import sinon, { type SinonStubbedInstance } from 'sinon';
+
+import UserAccount from './user-account.vue';
+import UserAccountService from './user-account.service';
+import AlertService from '@/shared/alert/alert.service';
+
+type UserAccountComponentType = InstanceType<typeof UserAccount>;
+
+const bModalStub = {
+  render: () => {},
+  methods: {
+    hide: () => {},
+    show: () => {},
+  },
+};
+
+describe('Component Tests', () => {
+  let alertService: AlertService;
+
+  describe('UserAccount Management Component', () => {
+    let userAccountServiceStub: SinonStubbedInstance<UserAccountService>;
+    let mountOptions: MountingOptions<UserAccountComponentType>['global'];
+
+    beforeEach(() => {
+      userAccountServiceStub = sinon.createStubInstance<UserAccountService>(UserAccountService);
+      userAccountServiceStub.retrieve.resolves({ headers: {} });
+
+      alertService = new AlertService({
+        bvToast: {
+          toast: vitest.fn(),
+        } as any,
+      });
+
+      mountOptions = {
+        stubs: {
+          bModal: bModalStub as any,
+          'font-awesome-icon': true,
+          'b-badge': true,
+          'b-button': true,
+          'router-link': true,
+        },
+        directives: {
+          'b-modal': {},
+        },
+        provide: {
+          alertService,
+          userAccountService: () => userAccountServiceStub,
+        },
+      };
+    });
+
+    describe('Mount', () => {
+      it('Should call load all on init', async () => {
+        // GIVEN
+        userAccountServiceStub.retrieve.resolves({ headers: {}, data: [{ id: 123 }] });
+
+        // WHEN
+        const wrapper = shallowMount(UserAccount, { global: mountOptions });
+        const comp = wrapper.vm;
+        await comp.$nextTick();
+
+        // THEN
+        expect(userAccountServiceStub.retrieve.calledOnce).toBeTruthy();
+        expect(comp.userAccounts[0]).toEqual(expect.objectContaining({ id: 123 }));
+      });
+    });
+    describe('Handles', () => {
+      let comp: UserAccountComponentType;
+
+      beforeEach(async () => {
+        const wrapper = shallowMount(UserAccount, { global: mountOptions });
+        comp = wrapper.vm;
+        await comp.$nextTick();
+        userAccountServiceStub.retrieve.reset();
+        userAccountServiceStub.retrieve.resolves({ headers: {}, data: [] });
+      });
+
+      it('Should call delete service on confirmDelete', async () => {
+        // GIVEN
+        userAccountServiceStub.delete.resolves({});
+
+        // WHEN
+        comp.prepareRemove({ id: 123 });
+
+        comp.removeUserAccount();
+        await comp.$nextTick(); // clear components
+
+        // THEN
+        expect(userAccountServiceStub.delete.called).toBeTruthy();
+
+        // THEN
+        await comp.$nextTick(); // handle component clear watch
+        expect(userAccountServiceStub.retrieve.callCount).toEqual(1);
+      });
+    });
+  });
+});

src/main/webapp/app/entities/user-account/user-account.component.ts

@@ -0,0 +1,75 @@
+import { type Ref, defineComponent, inject, onMounted, ref } from 'vue';
+
+import UserAccountService from './user-account.service';
+import { type IUserAccount } from '@/shared/model/user-account.model';
+import { useAlertService } from '@/shared/alert/alert.service';
+
+export default defineComponent({
+  compatConfig: { MODE: 3 },
+  name: 'UserAccount',
+  setup() {
+    const userAccountService = inject('userAccountService', () => new UserAccountService());
+    const alertService = inject('alertService', () => useAlertService(), true);
+
+    const userAccounts: Ref<IUserAccount[]> = ref([]);
+
+    const isFetching = ref(false);
+
+    const clear = () => {};
+
+    const retrieveUserAccounts = async () => {
+      isFetching.value = true;
+      try {
+        const res = await userAccountService().retrieve();
+        userAccounts.value = res.data;
+      } catch (err) {
+        alertService.showHttpError(err.response);
+      } finally {
+        isFetching.value = false;
+      }
+    };
+
+    const handleSyncList = () => {
+      retrieveUserAccounts();
+    };
+
+    onMounted(async () => {
+      await retrieveUserAccounts();
+    });
+
+    const removeId: Ref<number> = ref(null);
+    const removeEntity = ref<any>(null);
+    const prepareRemove = (instance: IUserAccount) => {
+      removeId.value = instance.id;
+      removeEntity.value.show();
+    };
+    const closeDialog = () => {
+      removeEntity.value.hide();
+    };
+    const removeUserAccount = async () => {
+      try {
+        await userAccountService().delete(removeId.value);
+        const message = `A UserAccount is deleted with identifier ${removeId.value}`;
+        alertService.showInfo(message, { variant: 'danger' });
+        removeId.value = null;
+        retrieveUserAccounts();
+        closeDialog();
+      } catch (error) {
+        alertService.showHttpError(error.response);
+      }
+    };
+
+    return {
+      userAccounts,
+      handleSyncList,
+      isFetching,
+      retrieveUserAccounts,
+      clear,
+      removeId,
+      removeEntity,
+      prepareRemove,
+      closeDialog,
+      removeUserAccount,
+    };
+  },
+});

src/main/webapp/app/entities/user-account/user-account.service.spec.ts

@@ -0,0 +1,160 @@
+/* tslint:disable max-line-length */
+import axios from 'axios';
+import sinon from 'sinon';
+
+import UserAccountService from './user-account.service';
+import { UserAccount } from '@/shared/model/user-account.model';
+
+const error = {
+  response: {
+    status: null,
+    data: {
+      type: null,
+    },
+  },
+};
+
+const axiosStub = {
+  get: sinon.stub(axios, 'get'),
+  post: sinon.stub(axios, 'post'),
+  put: sinon.stub(axios, 'put'),
+  patch: sinon.stub(axios, 'patch'),
+  delete: sinon.stub(axios, 'delete'),
+};
+
+describe('Service Tests', () => {
+  describe('UserAccount Service', () => {
+    let service: UserAccountService;
+    let elemDefault;
+
+    beforeEach(() => {
+      service = new UserAccountService();
+      elemDefault = new UserAccount(123, 'AAAAAAA');
+    });
+
+    describe('Service methods', () => {
+      it('should find an element', async () => {
+        const returnedFromService = { ...elemDefault };
+        axiosStub.get.resolves({ data: returnedFromService });
+
+        return service.find(123).then(res => {
+          expect(res).toMatchObject(elemDefault);
+        });
+      });
+
+      it('should not find an element', async () => {
+        axiosStub.get.rejects(error);
+        return service
+          .find(123)
+          .then()
+          .catch(err => {
+            expect(err).toMatchObject(error);
+          });
+      });
+
+      it('should create a UserAccount', async () => {
+        const returnedFromService = { id: 123, ...elemDefault };
+        const expected = { ...returnedFromService };
+
+        axiosStub.post.resolves({ data: returnedFromService });
+        return service.create({}).then(res => {
+          expect(res).toMatchObject(expected);
+        });
+      });
+
+      it('should not create a UserAccount', async () => {
+        axiosStub.post.rejects(error);
+
+        return service
+          .create({})
+          .then()
+          .catch(err => {
+            expect(err).toMatchObject(error);
+          });
+      });
+
+      it('should update a UserAccount', async () => {
+        const returnedFromService = { name: 'BBBBBB', ...elemDefault };
+
+        const expected = { ...returnedFromService };
+        axiosStub.put.resolves({ data: returnedFromService });
+
+        return service.update(expected).then(res => {
+          expect(res).toMatchObject(expected);
+        });
+      });
+
+      it('should not update a UserAccount', async () => {
+        axiosStub.put.rejects(error);
+
+        return service
+          .update({})
+          .then()
+          .catch(err => {
+            expect(err).toMatchObject(error);
+          });
+      });
+
+      it('should partial update a UserAccount', async () => {
+        const patchObject = { name: 'BBBBBB', ...new UserAccount() };
+        const returnedFromService = Object.assign(patchObject, elemDefault);
+
+        const expected = { ...returnedFromService };
+        axiosStub.patch.resolves({ data: returnedFromService });
+
+        return service.partialUpdate(patchObject).then(res => {
+          expect(res).toMatchObject(expected);
+        });
+      });
+
+      it('should not partial update a UserAccount', async () => {
+        axiosStub.patch.rejects(error);
+
+        return service
+          .partialUpdate({})
+          .then()
+          .catch(err => {
+            expect(err).toMatchObject(error);
+          });
+      });
+
+      it('should return a list of UserAccount', async () => {
+        const returnedFromService = { name: 'BBBBBB', ...elemDefault };
+        const expected = { ...returnedFromService };
+        axiosStub.get.resolves([returnedFromService]);
+        return service.retrieve().then(res => {
+          expect(res).toContainEqual(expected);
+        });
+      });
+
+      it('should not return a list of UserAccount', async () => {
+        axiosStub.get.rejects(error);
+
+        return service
+          .retrieve()
+          .then()
+          .catch(err => {
+            expect(err).toMatchObject(error);
+          });
+      });
+
+      it('should delete a UserAccount', async () => {
+        axiosStub.delete.resolves({ ok: true });
+        return service.delete(123).then(res => {
+          expect(res.ok).toBeTruthy();
+        });
+      });
+
+      it('should not delete a UserAccount', async () => {
+        axiosStub.delete.rejects(error);
+
+        return service
+          .delete(123)
+          .then()
+          .catch(err => {
+            expect(err).toMatchObject(error);
+          });
+      });
+    });
+  });
+});

src/main/webapp/app/entities/user-account/user-account.service.ts

@@ -0,0 +1,85 @@
+import axios from 'axios';
+
+import { type IUserAccount } from '@/shared/model/user-account.model';
+
+const baseApiUrl = 'api/user-accounts';
+
+export default class UserAccountService {
+  public find(id: number): Promise<IUserAccount> {
+    return new Promise<IUserAccount>((resolve, reject) => {
+      axios
+        .get(`${baseApiUrl}/${id}`)
+        .then(res => {
+          resolve(res.data);
+        })
+        .catch(err => {
+          reject(err);
+        });
+    });
+  }
+
+  public retrieve(): Promise<any> {
+    return new Promise<any>((resolve, reject) => {
+      axios
+        .get(baseApiUrl)
+        .then(res => {
+          resolve(res);
+        })
+        .catch(err => {
+          reject(err);
+        });
+    });
+  }
+
+  public delete(id: number): Promise<any> {
+    return new Promise<any>((resolve, reject) => {
+      axios
+        .delete(`${baseApiUrl}/${id}`)
+        .then(res => {
+          resolve(res);
+        })
+        .catch(err => {
+          reject(err);
+        });
+    });
+  }
+
+  public create(entity: IUserAccount): Promise<IUserAccount> {
+    return new Promise<IUserAccount>((resolve, reject) => {
+      axios
+        .post(`${baseApiUrl}`, entity)
+        .then(res => {
+          resolve(res.data);
+        })
+        .catch(err => {
+          reject(err);
+        });
+    });
+  }
+
+  public update(entity: IUserAccount): Promise<IUserAccount> {
+    return new Promise<IUserAccount>((resolve, reject) => {
+      axios
+        .put(`${baseApiUrl}/${entity.id}`, entity)
+        .then(res => {
+          resolve(res.data);
+        })
+        .catch(err => {
+          reject(err);
+        });
+    });
+  }
+
+  public partialUpdate(entity: IUserAccount): Promise<IUserAccount> {
+    return new Promise<IUserAccount>((resolve, reject) => {
+      axios
+        .patch(`${baseApiUrl}/${entity.id}`, entity)
+        .then(res => {
+          resolve(res.data);
+        })
+        .catch(err => {
+          reject(err);
+        });
+    });
+  }
+}

src/main/webapp/app/entities/user-account/user-account.vue

@@ -0,0 +1,103 @@
+<template>
+  <div>
+    <h2 id="page-heading" data-cy="UserAccountHeading">
+      <span id="user-account-heading">User Accounts</span>
+      <div class="d-flex justify-content-end">
+        <button class="btn btn-info mr-2" @click="handleSyncList" :disabled="isFetching">
+          <font-awesome-icon icon="sync" :spin="isFetching"></font-awesome-icon> <span>Refresh list</span>
+        </button>
+        <router-link :to="{ name: 'UserAccountCreate' }" custom v-slot="{ navigate }">
+          <button
+            @click="navigate"
+            id="jh-create-entity"
+            data-cy="entityCreateButton"
+            class="btn btn-primary jh-create-entity create-user-account"
+          >
+            <font-awesome-icon icon="plus"></font-awesome-icon>
+            <span>Create a new User Account</span>
+          </button>
+        </router-link>
+      </div>
+    </h2>
+    <br />
+    <div class="alert alert-warning" v-if="!isFetching && userAccounts && userAccounts.length === 0">
+      <span>No User Accounts found</span>
+    </div>
+    <div class="table-responsive" v-if="userAccounts && userAccounts.length > 0">
+      <table class="table table-striped" aria-describedby="userAccounts">
+        <thead>
+          <tr>
+            <th scope="row"><span>ID</span></th>
+            <th scope="row"><span>Name</span></th>
+            <th scope="row"><span>User</span></th>
+            <th scope="row"></th>
+          </tr>
+        </thead>
+        <tbody>
+          <tr v-for="userAccount in userAccounts" :key="userAccount.id" data-cy="entityTable">
+            <td>
+              <router-link :to="{ name: 'UserAccountView', params: { userAccountId: userAccount.id } }">{{ userAccount.id }}</router-link>
+            </td>
+            <td>{{ userAccount.name }}</td>
+            <td>
+              <span v-for="(user, i) in userAccount.users" :key="user.id"
+                >{{ i > 0 ? ', ' : '' }}
+                {{ user.login }}
+              </span>
+            </td>
+            <td class="text-right">
+              <div class="btn-group">
+                <router-link :to="{ name: 'UserAccountView', params: { userAccountId: userAccount.id } }" custom v-slot="{ navigate }">
+                  <button @click="navigate" class="btn btn-info btn-sm details" data-cy="entityDetailsButton">
+                    <font-awesome-icon icon="eye"></font-awesome-icon>
+                    <span class="d-none d-md-inline">View</span>
+                  </button>
+                </router-link>
+                <router-link :to="{ name: 'UserAccountEdit', params: { userAccountId: userAccount.id } }" custom v-slot="{ navigate }">
+                  <button @click="navigate" class="btn btn-primary btn-sm edit" data-cy="entityEditButton">
+                    <font-awesome-icon icon="pencil-alt"></font-awesome-icon>
+                    <span class="d-none d-md-inline">Edit</span>
+                  </button>
+                </router-link>
+                <b-button
+                  @click="prepareRemove(userAccount)"
+                  variant="danger"
+                  class="btn btn-sm"
+                  data-cy="entityDeleteButton"
+                  v-b-modal.removeEntity
+                >
+                  <font-awesome-icon icon="times"></font-awesome-icon>
+                  <span class="d-none d-md-inline">Delete</span>
+                </b-button>
+              </div>
+            </td>
+          </tr>
+        </tbody>
+      </table>
+    </div>
+    <b-modal ref="removeEntity" id="removeEntity">
+      <template #modal-title>
+        <span id="sasiedziApp.userAccount.delete.question" data-cy="userAccountDeleteDialogHeading">Confirm delete operation</span>
+      </template>
+      <div class="modal-body">
+        <p id="jhi-delete-userAccount-heading">Are you sure you want to delete User Account {{ removeId }}?</p>
+      </div>
+      <template #modal-footer>
+        <div>
+          <button type="button" class="btn btn-secondary" @click="closeDialog()">Cancel</button>
+          <button
+            type="button"
+            class="btn btn-primary"
+            id="jhi-confirm-delete-userAccount"
+            data-cy="entityConfirmDeleteButton"
+            @click="removeUserAccount()"
+          >
+            Delete
+          </button>
+        </div>
+      </template>
+    </b-modal>
+  </div>
+</template>
+
+<script lang="ts" src="./user-account.component.ts"></script>

src/main/webapp/app/router/entities.ts

@@ -15,6 +15,14 @@ const Registration = () => import('@/entities/registration/registration.vue');
 const RegistrationUpdate = () => import('@/entities/registration/registration-update.vue');
 const RegistrationDetails = () => import('@/entities/registration/registration-details.vue');
 
+const Transaction = () => import('@/entities/transaction/transaction.vue');
+const TransactionUpdate = () => import('@/entities/transaction/transaction-update.vue');
+const TransactionDetails = () => import('@/entities/transaction/transaction-details.vue');
+
+const UserAccount = () => import('@/entities/user-account/user-account.vue');
+const UserAccountUpdate = () => import('@/entities/user-account/user-account-update.vue');
+const UserAccountDetails = () => import('@/entities/user-account/user-account-details.vue');
+
 // jhipster-needle-add-entity-to-router-import - JHipster will import entities to the router here
 
 export default {
@@ -94,6 +102,54 @@ export default {
       component: RegistrationDetails,
       meta: { authorities: [Authority.USER] },
     },
+    {
+      path: 'transaction',
+      name: 'Transaction',
+      component: Transaction,
+      meta: { authorities: [Authority.USER] },
+    },
+    {
+      path: 'transaction/new',
+      name: 'TransactionCreate',
+      component: TransactionUpdate,
+      meta: { authorities: [Authority.USER] },
+    },
+    {
+      path: 'transaction/:transactionId/edit',
+      name: 'TransactionEdit',
+      component: TransactionUpdate,
+      meta: { authorities: [Authority.USER] },
+    },
+    {
+      path: 'transaction/:transactionId/view',
+      name: 'TransactionView',
+      component: TransactionDetails,
+      meta: { authorities: [Authority.USER] },
+    },
+    {
+      path: 'user-account',
+      name: 'UserAccount',
+      component: UserAccount,
+      meta: { authorities: [Authority.USER] },
+    },
+    {
+      path: 'user-account/new',
+      name: 'UserAccountCreate',
+      component: UserAccountUpdate,
+      meta: { authorities: [Authority.USER] },
+    },
+    {
+      path: 'user-account/:userAccountId/edit',
+      name: 'UserAccountEdit',
+      component: UserAccountUpdate,
+      meta: { authorities: [Authority.USER] },
+    },
+    {
+      path: 'user-account/:userAccountId/view',
+      name: 'UserAccountView',
+      component: UserAccountDetails,
+      meta: { authorities: [Authority.USER] },
+    },
     // jhipster-needle-add-entity-to-router - JHipster will add entities to the router here
   ],
 };

src/main/webapp/app/shared/model/enumerations/transaction-type.model.ts

@@ -0,0 +1,9 @@
+export enum TransactionType {
+  PURCHASE = 'PURCHASE',
+
+  MATCH = 'MATCH',
+
+  FIELDPAYMENT = 'FIELDPAYMENT',
+
+  INTERNALTRANSFER = 'INTERNALTRANSFER',
+}

src/main/webapp/app/shared/model/transaction.model.ts

@@ -0,0 +1,20 @@
+import { type IEvent } from '@/shared/model/event.model';
+
+import { type TransactionType } from '@/shared/model/enumerations/transaction-type.model';
+export interface ITransaction {
+  id?: number;
+  type?: keyof typeof TransactionType | null;
+  date?: Date | null;
+  comment?: string | null;
+  event?: IEvent | null;
+}
+
+export class Transaction implements ITransaction {
+  constructor(
+    public id?: number,
+    public type?: keyof typeof TransactionType | null,
+    public date?: Date | null,
+    public comment?: string | null,
+    public event?: IEvent | null,
+  ) {}
+}

src/main/webapp/app/shared/model/user-account.model.ts

@@ -0,0 +1,15 @@
+import { type IUser } from '@/shared/model/user.model';
+
+export interface IUserAccount {
+  id?: number;
+  name?: string | null;
+  users?: IUser[] | null;
+}
+
+export class UserAccount implements IUserAccount {
+  constructor(
+    public id?: number,
+    public name?: string | null,
+    public users?: IUser[] | null,
+  ) {}
+}