TransactionItem - backend only

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

@@ -48,7 +48,7 @@ public class Event implements Serializable {
     private Set<Registration> registrations = new HashSet<>();
 
     @OneToMany(fetch = FetchType.LAZY, mappedBy = "event")
-    @JsonIgnoreProperties(value = { "event" }, allowSetters = true)
+    @JsonIgnoreProperties(value = { "event", "transactionItem" }, allowSetters = true)
     private Set<Transaction> transactions = new HashSet<>();
 
     // jhipster-needle-entity-add-field - JHipster will add fields here

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

@@ -36,6 +36,10 @@ public class Transaction implements Serializable {
     @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() {
@@ -103,6 +107,19 @@ public class Transaction implements Serializable {
         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

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

@@ -1,5 +1,6 @@
 package com.sasiedzi.event.domain;
 
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
 import jakarta.persistence.*;
 import java.io.Serializable;
 import java.util.HashSet;
@@ -32,6 +33,10 @@ public class UserAccount implements Serializable {
     )
     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() {
@@ -83,6 +88,37 @@ public class UserAccount implements Serializable {
         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

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/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/resources/config/liquibase/changelog/20241113134007_added_entity_Transaction.xml

@@ -26,6 +26,9 @@
             <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>

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

@@ -16,5 +16,12 @@
                                  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/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_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/master.xml

@@ -16,11 +16,13 @@
     <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/test/java/com/sasiedzi/event/domain/TransactionAsserts.java

@@ -61,6 +61,7 @@ public class TransactionAsserts {
     public static void assertTransactionUpdatableRelationshipsEquals(Transaction expected, Transaction actual) {
         assertThat(expected)
             .as("Verify Transaction relationships")
-            .satisfies(e -> assertThat(e.getEvent()).as("check event").isEqualTo(actual.getEvent()));
+            .satisfies(e -> assertThat(e.getEvent()).as("check event").isEqualTo(actual.getEvent()))
+            .satisfies(e -> assertThat(e.getTransactionItem()).as("check transactionItem").isEqualTo(actual.getTransactionItem()));
     }
 }

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

@@ -0,0 +1,67 @@
+package com.sasiedzi.event.domain;
+
+import static com.sasiedzi.event.domain.AssertUtils.bigDecimalCompareTo;
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TransactionItemAsserts {
+
+    /**
+     * Asserts that the entity has all properties (fields/relationships) set.
+     *
+     * @param expected the expected entity
+     * @param actual the actual entity
+     */
+    public static void assertTransactionItemAllPropertiesEquals(TransactionItem expected, TransactionItem actual) {
+        assertTransactionItemAutoGeneratedPropertiesEquals(expected, actual);
+        assertTransactionItemAllUpdatablePropertiesEquals(expected, actual);
+    }
+
+    /**
+     * Asserts that the entity has all updatable properties (fields/relationships) set.
+     *
+     * @param expected the expected entity
+     * @param actual the actual entity
+     */
+    public static void assertTransactionItemAllUpdatablePropertiesEquals(TransactionItem expected, TransactionItem actual) {
+        assertTransactionItemUpdatableFieldsEquals(expected, actual);
+        assertTransactionItemUpdatableRelationshipsEquals(expected, actual);
+    }
+
+    /**
+     * Asserts that the entity has all the auto generated properties (fields/relationships) set.
+     *
+     * @param expected the expected entity
+     * @param actual the actual entity
+     */
+    public static void assertTransactionItemAutoGeneratedPropertiesEquals(TransactionItem expected, TransactionItem actual) {
+        assertThat(expected)
+            .as("Verify TransactionItem auto generated properties")
+            .satisfies(e -> assertThat(e.getId()).as("check id").isEqualTo(actual.getId()));
+    }
+
+    /**
+     * Asserts that the entity has all the updatable fields set.
+     *
+     * @param expected the expected entity
+     * @param actual the actual entity
+     */
+    public static void assertTransactionItemUpdatableFieldsEquals(TransactionItem expected, TransactionItem actual) {
+        assertThat(expected)
+            .as("Verify TransactionItem relevant properties")
+            .satisfies(e -> assertThat(e.getAmount()).as("check amount").usingComparator(bigDecimalCompareTo).isEqualTo(actual.getAmount()))
+            .satisfies(e -> assertThat(e.getDate()).as("check date").isEqualTo(actual.getDate()))
+            .satisfies(e -> assertThat(e.getComment()).as("check comment").isEqualTo(actual.getComment()));
+    }
+
+    /**
+     * Asserts that the entity has all the updatable relationships set.
+     *
+     * @param expected the expected entity
+     * @param actual the actual entity
+     */
+    public static void assertTransactionItemUpdatableRelationshipsEquals(TransactionItem expected, TransactionItem actual) {
+        assertThat(expected)
+            .as("Verify TransactionItem relationships")
+            .satisfies(e -> assertThat(e.getUserAccounts()).as("check userAccounts").isEqualTo(actual.getUserAccounts()));
+    }
+}

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

@@ -0,0 +1,68 @@
+package com.sasiedzi.event.domain;
+
+import static com.sasiedzi.event.domain.TransactionItemTestSamples.*;
+import static com.sasiedzi.event.domain.TransactionTestSamples.*;
+import static com.sasiedzi.event.domain.UserAccountTestSamples.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.sasiedzi.event.web.rest.TestUtil;
+import java.util.HashSet;
+import java.util.Set;
+import org.junit.jupiter.api.Test;
+
+class TransactionItemTest {
+
+    @Test
+    void equalsVerifier() throws Exception {
+        TestUtil.equalsVerifier(TransactionItem.class);
+        TransactionItem transactionItem1 = getTransactionItemSample1();
+        TransactionItem transactionItem2 = new TransactionItem();
+        assertThat(transactionItem1).isNotEqualTo(transactionItem2);
+
+        transactionItem2.setId(transactionItem1.getId());
+        assertThat(transactionItem1).isEqualTo(transactionItem2);
+
+        transactionItem2 = getTransactionItemSample2();
+        assertThat(transactionItem1).isNotEqualTo(transactionItem2);
+    }
+
+    @Test
+    void userAccountTest() {
+        TransactionItem transactionItem = getTransactionItemRandomSampleGenerator();
+        UserAccount userAccountBack = getUserAccountRandomSampleGenerator();
+
+        transactionItem.addUserAccount(userAccountBack);
+        assertThat(transactionItem.getUserAccounts()).containsOnly(userAccountBack);
+
+        transactionItem.removeUserAccount(userAccountBack);
+        assertThat(transactionItem.getUserAccounts()).doesNotContain(userAccountBack);
+
+        transactionItem.userAccounts(new HashSet<>(Set.of(userAccountBack)));
+        assertThat(transactionItem.getUserAccounts()).containsOnly(userAccountBack);
+
+        transactionItem.setUserAccounts(new HashSet<>());
+        assertThat(transactionItem.getUserAccounts()).doesNotContain(userAccountBack);
+    }
+
+    @Test
+    void transactionTest() {
+        TransactionItem transactionItem = getTransactionItemRandomSampleGenerator();
+        Transaction transactionBack = getTransactionRandomSampleGenerator();
+
+        transactionItem.addTransaction(transactionBack);
+        assertThat(transactionItem.getTransactions()).containsOnly(transactionBack);
+        assertThat(transactionBack.getTransactionItem()).isEqualTo(transactionItem);
+
+        transactionItem.removeTransaction(transactionBack);
+        assertThat(transactionItem.getTransactions()).doesNotContain(transactionBack);
+        assertThat(transactionBack.getTransactionItem()).isNull();
+
+        transactionItem.transactions(new HashSet<>(Set.of(transactionBack)));
+        assertThat(transactionItem.getTransactions()).containsOnly(transactionBack);
+        assertThat(transactionBack.getTransactionItem()).isEqualTo(transactionItem);
+
+        transactionItem.setTransactions(new HashSet<>());
+        assertThat(transactionItem.getTransactions()).doesNotContain(transactionBack);
+        assertThat(transactionBack.getTransactionItem()).isNull();
+    }
+}

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

@@ -0,0 +1,23 @@
+package com.sasiedzi.event.domain;
+
+import java.util.Random;
+import java.util.UUID;
+import java.util.concurrent.atomic.AtomicLong;
+
+public class TransactionItemTestSamples {
+
+    private static final Random random = new Random();
+    private static final AtomicLong longCount = new AtomicLong(random.nextInt() + (2 * Integer.MAX_VALUE));
+
+    public static TransactionItem getTransactionItemSample1() {
+        return new TransactionItem().id(1L).comment("comment1");
+    }
+
+    public static TransactionItem getTransactionItemSample2() {
+        return new TransactionItem().id(2L).comment("comment2");
+    }
+
+    public static TransactionItem getTransactionItemRandomSampleGenerator() {
+        return new TransactionItem().id(longCount.incrementAndGet()).comment(UUID.randomUUID().toString());
+    }
+}

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

@@ -1,6 +1,7 @@
 package com.sasiedzi.event.domain;
 
 import static com.sasiedzi.event.domain.EventTestSamples.*;
+import static com.sasiedzi.event.domain.TransactionItemTestSamples.*;
 import static com.sasiedzi.event.domain.TransactionTestSamples.*;
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -34,4 +35,16 @@ class TransactionTest {
         transaction.event(null);
         assertThat(transaction.getEvent()).isNull();
     }
+
+    @Test
+    void transactionItemTest() {
+        Transaction transaction = getTransactionRandomSampleGenerator();
+        TransactionItem transactionItemBack = getTransactionItemRandomSampleGenerator();
+
+        transaction.setTransactionItem(transactionItemBack);
+        assertThat(transaction.getTransactionItem()).isEqualTo(transactionItemBack);
+
+        transaction.transactionItem(null);
+        assertThat(transaction.getTransactionItem()).isNull();
+    }
 }

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

@@ -57,6 +57,8 @@ public class UserAccountAsserts {
      * @param actual the actual entity
      */
     public static void assertUserAccountUpdatableRelationshipsEquals(UserAccount expected, UserAccount actual) {
-        // empty method
+        assertThat(expected)
+            .as("Verify UserAccount relationships")
+            .satisfies(e -> assertThat(e.getTransactionItems()).as("check transactionItems").isEqualTo(actual.getTransactionItems()));
     }
 }

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

@@ -1,9 +1,12 @@
 package com.sasiedzi.event.domain;
 
+import static com.sasiedzi.event.domain.TransactionItemTestSamples.*;
 import static com.sasiedzi.event.domain.UserAccountTestSamples.*;
 import static org.assertj.core.api.Assertions.assertThat;
 
 import com.sasiedzi.event.web.rest.TestUtil;
+import java.util.HashSet;
+import java.util.Set;
 import org.junit.jupiter.api.Test;
 
 class UserAccountTest {
@@ -21,4 +24,26 @@ class UserAccountTest {
         userAccount2 = getUserAccountSample2();
         assertThat(userAccount1).isNotEqualTo(userAccount2);
     }
+
+    @Test
+    void transactionItemTest() {
+        UserAccount userAccount = getUserAccountRandomSampleGenerator();
+        TransactionItem transactionItemBack = getTransactionItemRandomSampleGenerator();
+
+        userAccount.addTransactionItem(transactionItemBack);
+        assertThat(userAccount.getTransactionItems()).containsOnly(transactionItemBack);
+        assertThat(transactionItemBack.getUserAccounts()).containsOnly(userAccount);
+
+        userAccount.removeTransactionItem(transactionItemBack);
+        assertThat(userAccount.getTransactionItems()).doesNotContain(transactionItemBack);
+        assertThat(transactionItemBack.getUserAccounts()).doesNotContain(userAccount);
+
+        userAccount.transactionItems(new HashSet<>(Set.of(transactionItemBack)));
+        assertThat(userAccount.getTransactionItems()).containsOnly(transactionItemBack);
+        assertThat(transactionItemBack.getUserAccounts()).containsOnly(userAccount);
+
+        userAccount.setTransactionItems(new HashSet<>());
+        assertThat(userAccount.getTransactionItems()).doesNotContain(transactionItemBack);
+        assertThat(transactionItemBack.getUserAccounts()).doesNotContain(userAccount);
+    }
 }

src/test/java/com/sasiedzi/event/web/rest/EventResourceIT.java

@@ -328,7 +328,7 @@ class EventResourceIT {
         Event partialUpdatedEvent = new Event();
         partialUpdatedEvent.setId(event.getId());
 
-        partialUpdatedEvent.playersLimit(UPDATED_PLAYERS_LIMIT).cost(UPDATED_COST).comment(UPDATED_COMMENT);
+        partialUpdatedEvent.name(UPDATED_NAME).cost(UPDATED_COST).comment(UPDATED_COMMENT);
 
         restEventMockMvc
             .perform(

src/test/java/com/sasiedzi/event/web/rest/RegistrationResourceIT.java

@@ -357,7 +357,7 @@ class RegistrationResourceIT {
         Registration partialUpdatedRegistration = new Registration();
         partialUpdatedRegistration.setId(registration.getId());
 
-        partialUpdatedRegistration.dateTime(UPDATED_DATE_TIME).playerName(UPDATED_PLAYER_NAME);
+        partialUpdatedRegistration.active(UPDATED_ACTIVE);
 
         restRegistrationMockMvc
             .perform(

src/test/java/com/sasiedzi/event/web/rest/TransactionItemResourceIT.java

@@ -0,0 +1,469 @@
+package com.sasiedzi.event.web.rest;
+
+import static com.sasiedzi.event.domain.TransactionItemAsserts.*;
+import static com.sasiedzi.event.web.rest.TestUtil.createUpdateProxyForBean;
+import static com.sasiedzi.event.web.rest.TestUtil.sameNumber;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.hamcrest.Matchers.hasItem;
+import static org.mockito.Mockito.*;
+import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.csrf;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.sasiedzi.event.IntegrationTest;
+import com.sasiedzi.event.domain.TransactionItem;
+import com.sasiedzi.event.repository.TransactionItemRepository;
+import jakarta.persistence.EntityManager;
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.time.ZoneId;
+import java.util.ArrayList;
+import java.util.Random;
+import java.util.concurrent.atomic.AtomicLong;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
+import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.Pageable;
+import org.springframework.http.MediaType;
+import org.springframework.security.test.context.support.WithMockUser;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * Integration tests for the {@link TransactionItemResource} REST controller.
+ */
+@IntegrationTest
+@ExtendWith(MockitoExtension.class)
+@AutoConfigureMockMvc
+@WithMockUser
+class TransactionItemResourceIT {
+
+    private static final BigDecimal DEFAULT_AMOUNT = new BigDecimal(1);
+    private static final BigDecimal UPDATED_AMOUNT = new BigDecimal(2);
+
+    private static final LocalDate DEFAULT_DATE = LocalDate.ofEpochDay(0L);
+    private static final LocalDate UPDATED_DATE = LocalDate.now(ZoneId.systemDefault());
+
+    private static final String DEFAULT_COMMENT = "AAAAAAAAAA";
+    private static final String UPDATED_COMMENT = "BBBBBBBBBB";
+
+    private static final String ENTITY_API_URL = "/api/transaction-items";
+    private static final String ENTITY_API_URL_ID = ENTITY_API_URL + "/{id}";
+
+    private static Random random = new Random();
+    private static AtomicLong longCount = new AtomicLong(random.nextInt() + (2 * Integer.MAX_VALUE));
+
+    @Autowired
+    private ObjectMapper om;
+
+    @Autowired
+    private TransactionItemRepository transactionItemRepository;
+
+    @Mock
+    private TransactionItemRepository transactionItemRepositoryMock;
+
+    @Autowired
+    private EntityManager em;
+
+    @Autowired
+    private MockMvc restTransactionItemMockMvc;
+
+    private TransactionItem transactionItem;
+
+    private TransactionItem insertedTransactionItem;
+
+    /**
+     * Create an entity for this test.
+     *
+     * This is a static method, as tests for other entities might also need it,
+     * if they test an entity which requires the current entity.
+     */
+    public static TransactionItem createEntity() {
+        return new TransactionItem().amount(DEFAULT_AMOUNT).date(DEFAULT_DATE).comment(DEFAULT_COMMENT);
+    }
+
+    /**
+     * Create an updated entity for this test.
+     *
+     * This is a static method, as tests for other entities might also need it,
+     * if they test an entity which requires the current entity.
+     */
+    public static TransactionItem createUpdatedEntity() {
+        return new TransactionItem().amount(UPDATED_AMOUNT).date(UPDATED_DATE).comment(UPDATED_COMMENT);
+    }
+
+    @BeforeEach
+    public void initTest() {
+        transactionItem = createEntity();
+    }
+
+    @AfterEach
+    public void cleanup() {
+        if (insertedTransactionItem != null) {
+            transactionItemRepository.delete(insertedTransactionItem);
+            insertedTransactionItem = null;
+        }
+    }
+
+    @Test
+    @Transactional
+    void createTransactionItem() throws Exception {
+        long databaseSizeBeforeCreate = getRepositoryCount();
+        // Create the TransactionItem
+        var returnedTransactionItem = om.readValue(
+            restTransactionItemMockMvc
+                .perform(
+                    post(ENTITY_API_URL).with(csrf()).contentType(MediaType.APPLICATION_JSON).content(om.writeValueAsBytes(transactionItem))
+                )
+                .andExpect(status().isCreated())
+                .andReturn()
+                .getResponse()
+                .getContentAsString(),
+            TransactionItem.class
+        );
+
+        // Validate the TransactionItem in the database
+        assertIncrementedRepositoryCount(databaseSizeBeforeCreate);
+        assertTransactionItemUpdatableFieldsEquals(returnedTransactionItem, getPersistedTransactionItem(returnedTransactionItem));
+
+        insertedTransactionItem = returnedTransactionItem;
+    }
+
+    @Test
+    @Transactional
+    void createTransactionItemWithExistingId() throws Exception {
+        // Create the TransactionItem with an existing ID
+        transactionItem.setId(1L);
+
+        long databaseSizeBeforeCreate = getRepositoryCount();
+
+        // An entity with an existing ID cannot be created, so this API call must fail
+        restTransactionItemMockMvc
+            .perform(
+                post(ENTITY_API_URL).with(csrf()).contentType(MediaType.APPLICATION_JSON).content(om.writeValueAsBytes(transactionItem))
+            )
+            .andExpect(status().isBadRequest());
+
+        // Validate the TransactionItem in the database
+        assertSameRepositoryCount(databaseSizeBeforeCreate);
+    }
+
+    @Test
+    @Transactional
+    void getAllTransactionItems() throws Exception {
+        // Initialize the database
+        insertedTransactionItem = transactionItemRepository.saveAndFlush(transactionItem);
+
+        // Get all the transactionItemList
+        restTransactionItemMockMvc
+            .perform(get(ENTITY_API_URL + "?sort=id,desc"))
+            .andExpect(status().isOk())
+            .andExpect(content().contentType(MediaType.APPLICATION_JSON_VALUE))
+            .andExpect(jsonPath("$.[*].id").value(hasItem(transactionItem.getId().intValue())))
+            .andExpect(jsonPath("$.[*].amount").value(hasItem(sameNumber(DEFAULT_AMOUNT))))
+            .andExpect(jsonPath("$.[*].date").value(hasItem(DEFAULT_DATE.toString())))
+            .andExpect(jsonPath("$.[*].comment").value(hasItem(DEFAULT_COMMENT)));
+    }
+
+    @SuppressWarnings({ "unchecked" })
+    void getAllTransactionItemsWithEagerRelationshipsIsEnabled() throws Exception {
+        when(transactionItemRepositoryMock.findAllWithEagerRelationships(any())).thenReturn(new PageImpl(new ArrayList<>()));
+
+        restTransactionItemMockMvc.perform(get(ENTITY_API_URL + "?eagerload=true")).andExpect(status().isOk());
+
+        verify(transactionItemRepositoryMock, times(1)).findAllWithEagerRelationships(any());
+    }
+
+    @SuppressWarnings({ "unchecked" })
+    void getAllTransactionItemsWithEagerRelationshipsIsNotEnabled() throws Exception {
+        when(transactionItemRepositoryMock.findAllWithEagerRelationships(any())).thenReturn(new PageImpl(new ArrayList<>()));
+
+        restTransactionItemMockMvc.perform(get(ENTITY_API_URL + "?eagerload=false")).andExpect(status().isOk());
+        verify(transactionItemRepositoryMock, times(1)).findAll(any(Pageable.class));
+    }
+
+    @Test
+    @Transactional
+    void getTransactionItem() throws Exception {
+        // Initialize the database
+        insertedTransactionItem = transactionItemRepository.saveAndFlush(transactionItem);
+
+        // Get the transactionItem
+        restTransactionItemMockMvc
+            .perform(get(ENTITY_API_URL_ID, transactionItem.getId()))
+            .andExpect(status().isOk())
+            .andExpect(content().contentType(MediaType.APPLICATION_JSON_VALUE))
+            .andExpect(jsonPath("$.id").value(transactionItem.getId().intValue()))
+            .andExpect(jsonPath("$.amount").value(sameNumber(DEFAULT_AMOUNT)))
+            .andExpect(jsonPath("$.date").value(DEFAULT_DATE.toString()))
+            .andExpect(jsonPath("$.comment").value(DEFAULT_COMMENT));
+    }
+
+    @Test
+    @Transactional
+    void getNonExistingTransactionItem() throws Exception {
+        // Get the transactionItem
+        restTransactionItemMockMvc.perform(get(ENTITY_API_URL_ID, Long.MAX_VALUE)).andExpect(status().isNotFound());
+    }
+
+    @Test
+    @Transactional
+    void putExistingTransactionItem() throws Exception {
+        // Initialize the database
+        insertedTransactionItem = transactionItemRepository.saveAndFlush(transactionItem);
+
+        long databaseSizeBeforeUpdate = getRepositoryCount();
+
+        // Update the transactionItem
+        TransactionItem updatedTransactionItem = transactionItemRepository.findById(transactionItem.getId()).orElseThrow();
+        // Disconnect from session so that the updates on updatedTransactionItem are not directly saved in db
+        em.detach(updatedTransactionItem);
+        updatedTransactionItem.amount(UPDATED_AMOUNT).date(UPDATED_DATE).comment(UPDATED_COMMENT);
+
+        restTransactionItemMockMvc
+            .perform(
+                put(ENTITY_API_URL_ID, updatedTransactionItem.getId())
+                    .with(csrf())
+                    .contentType(MediaType.APPLICATION_JSON)
+                    .content(om.writeValueAsBytes(updatedTransactionItem))
+            )
+            .andExpect(status().isOk());
+
+        // Validate the TransactionItem in the database
+        assertSameRepositoryCount(databaseSizeBeforeUpdate);
+        assertPersistedTransactionItemToMatchAllProperties(updatedTransactionItem);
+    }
+
+    @Test
+    @Transactional
+    void putNonExistingTransactionItem() throws Exception {
+        long databaseSizeBeforeUpdate = getRepositoryCount();
+        transactionItem.setId(longCount.incrementAndGet());
+
+        // If the entity doesn't have an ID, it will throw BadRequestAlertException
+        restTransactionItemMockMvc
+            .perform(
+                put(ENTITY_API_URL_ID, transactionItem.getId())
+                    .with(csrf())
+                    .contentType(MediaType.APPLICATION_JSON)
+                    .content(om.writeValueAsBytes(transactionItem))
+            )
+            .andExpect(status().isBadRequest());
+
+        // Validate the TransactionItem in the database
+        assertSameRepositoryCount(databaseSizeBeforeUpdate);
+    }
+
+    @Test
+    @Transactional
+    void putWithIdMismatchTransactionItem() throws Exception {
+        long databaseSizeBeforeUpdate = getRepositoryCount();
+        transactionItem.setId(longCount.incrementAndGet());
+
+        // If url ID doesn't match entity ID, it will throw BadRequestAlertException
+        restTransactionItemMockMvc
+            .perform(
+                put(ENTITY_API_URL_ID, longCount.incrementAndGet())
+                    .with(csrf())
+                    .contentType(MediaType.APPLICATION_JSON)
+                    .content(om.writeValueAsBytes(transactionItem))
+            )
+            .andExpect(status().isBadRequest());
+
+        // Validate the TransactionItem in the database
+        assertSameRepositoryCount(databaseSizeBeforeUpdate);
+    }
+
+    @Test
+    @Transactional
+    void putWithMissingIdPathParamTransactionItem() throws Exception {
+        long databaseSizeBeforeUpdate = getRepositoryCount();
+        transactionItem.setId(longCount.incrementAndGet());
+
+        // If url ID doesn't match entity ID, it will throw BadRequestAlertException
+        restTransactionItemMockMvc
+            .perform(
+                put(ENTITY_API_URL).with(csrf()).contentType(MediaType.APPLICATION_JSON).content(om.writeValueAsBytes(transactionItem))
+            )
+            .andExpect(status().isMethodNotAllowed());
+
+        // Validate the TransactionItem in the database
+        assertSameRepositoryCount(databaseSizeBeforeUpdate);
+    }
+
+    @Test
+    @Transactional
+    void partialUpdateTransactionItemWithPatch() throws Exception {
+        // Initialize the database
+        insertedTransactionItem = transactionItemRepository.saveAndFlush(transactionItem);
+
+        long databaseSizeBeforeUpdate = getRepositoryCount();
+
+        // Update the transactionItem using partial update
+        TransactionItem partialUpdatedTransactionItem = new TransactionItem();
+        partialUpdatedTransactionItem.setId(transactionItem.getId());
+
+        partialUpdatedTransactionItem.amount(UPDATED_AMOUNT).date(UPDATED_DATE);
+
+        restTransactionItemMockMvc
+            .perform(
+                patch(ENTITY_API_URL_ID, partialUpdatedTransactionItem.getId())
+                    .with(csrf())
+                    .contentType("application/merge-patch+json")
+                    .content(om.writeValueAsBytes(partialUpdatedTransactionItem))
+            )
+            .andExpect(status().isOk());
+
+        // Validate the TransactionItem in the database
+
+        assertSameRepositoryCount(databaseSizeBeforeUpdate);
+        assertTransactionItemUpdatableFieldsEquals(
+            createUpdateProxyForBean(partialUpdatedTransactionItem, transactionItem),
+            getPersistedTransactionItem(transactionItem)
+        );
+    }
+
+    @Test
+    @Transactional
+    void fullUpdateTransactionItemWithPatch() throws Exception {
+        // Initialize the database
+        insertedTransactionItem = transactionItemRepository.saveAndFlush(transactionItem);
+
+        long databaseSizeBeforeUpdate = getRepositoryCount();
+
+        // Update the transactionItem using partial update
+        TransactionItem partialUpdatedTransactionItem = new TransactionItem();
+        partialUpdatedTransactionItem.setId(transactionItem.getId());
+
+        partialUpdatedTransactionItem.amount(UPDATED_AMOUNT).date(UPDATED_DATE).comment(UPDATED_COMMENT);
+
+        restTransactionItemMockMvc
+            .perform(
+                patch(ENTITY_API_URL_ID, partialUpdatedTransactionItem.getId())
+                    .with(csrf())
+                    .contentType("application/merge-patch+json")
+                    .content(om.writeValueAsBytes(partialUpdatedTransactionItem))
+            )
+            .andExpect(status().isOk());
+
+        // Validate the TransactionItem in the database
+
+        assertSameRepositoryCount(databaseSizeBeforeUpdate);
+        assertTransactionItemUpdatableFieldsEquals(
+            partialUpdatedTransactionItem,
+            getPersistedTransactionItem(partialUpdatedTransactionItem)
+        );
+    }
+
+    @Test
+    @Transactional
+    void patchNonExistingTransactionItem() throws Exception {
+        long databaseSizeBeforeUpdate = getRepositoryCount();
+        transactionItem.setId(longCount.incrementAndGet());
+
+        // If the entity doesn't have an ID, it will throw BadRequestAlertException
+        restTransactionItemMockMvc
+            .perform(
+                patch(ENTITY_API_URL_ID, transactionItem.getId())
+                    .with(csrf())
+                    .contentType("application/merge-patch+json")
+                    .content(om.writeValueAsBytes(transactionItem))
+            )
+            .andExpect(status().isBadRequest());
+
+        // Validate the TransactionItem in the database
+        assertSameRepositoryCount(databaseSizeBeforeUpdate);
+    }
+
+    @Test
+    @Transactional
+    void patchWithIdMismatchTransactionItem() throws Exception {
+        long databaseSizeBeforeUpdate = getRepositoryCount();
+        transactionItem.setId(longCount.incrementAndGet());
+
+        // If url ID doesn't match entity ID, it will throw BadRequestAlertException
+        restTransactionItemMockMvc
+            .perform(
+                patch(ENTITY_API_URL_ID, longCount.incrementAndGet())
+                    .with(csrf())
+                    .contentType("application/merge-patch+json")
+                    .content(om.writeValueAsBytes(transactionItem))
+            )
+            .andExpect(status().isBadRequest());
+
+        // Validate the TransactionItem in the database
+        assertSameRepositoryCount(databaseSizeBeforeUpdate);
+    }
+
+    @Test
+    @Transactional
+    void patchWithMissingIdPathParamTransactionItem() throws Exception {
+        long databaseSizeBeforeUpdate = getRepositoryCount();
+        transactionItem.setId(longCount.incrementAndGet());
+
+        // If url ID doesn't match entity ID, it will throw BadRequestAlertException
+        restTransactionItemMockMvc
+            .perform(
+                patch(ENTITY_API_URL)
+                    .with(csrf())
+                    .contentType("application/merge-patch+json")
+                    .content(om.writeValueAsBytes(transactionItem))
+            )
+            .andExpect(status().isMethodNotAllowed());
+
+        // Validate the TransactionItem in the database
+        assertSameRepositoryCount(databaseSizeBeforeUpdate);
+    }
+
+    @Test
+    @Transactional
+    void deleteTransactionItem() throws Exception {
+        // Initialize the database
+        insertedTransactionItem = transactionItemRepository.saveAndFlush(transactionItem);
+
+        long databaseSizeBeforeDelete = getRepositoryCount();
+
+        // Delete the transactionItem
+        restTransactionItemMockMvc
+            .perform(delete(ENTITY_API_URL_ID, transactionItem.getId()).with(csrf()).accept(MediaType.APPLICATION_JSON))
+            .andExpect(status().isNoContent());
+
+        // Validate the database contains one less item
+        assertDecrementedRepositoryCount(databaseSizeBeforeDelete);
+    }
+
+    protected long getRepositoryCount() {
+        return transactionItemRepository.count();
+    }
+
+    protected void assertIncrementedRepositoryCount(long countBefore) {
+        assertThat(countBefore + 1).isEqualTo(getRepositoryCount());
+    }
+
+    protected void assertDecrementedRepositoryCount(long countBefore) {
+        assertThat(countBefore - 1).isEqualTo(getRepositoryCount());
+    }
+
+    protected void assertSameRepositoryCount(long countBefore) {
+        assertThat(countBefore).isEqualTo(getRepositoryCount());
+    }
+
+    protected TransactionItem getPersistedTransactionItem(TransactionItem transactionItem) {
+        return transactionItemRepository.findById(transactionItem.getId()).orElseThrow();
+    }
+
+    protected void assertPersistedTransactionItemToMatchAllProperties(TransactionItem expectedTransactionItem) {
+        assertTransactionItemAllPropertiesEquals(expectedTransactionItem, getPersistedTransactionItem(expectedTransactionItem));
+    }
+
+    protected void assertPersistedTransactionItemToMatchUpdatableProperties(TransactionItem expectedTransactionItem) {
+        assertTransactionItemAllUpdatablePropertiesEquals(expectedTransactionItem, getPersistedTransactionItem(expectedTransactionItem));
+    }
+}

src/test/java/com/sasiedzi/event/web/rest/TransactionResourceIT.java

@@ -305,7 +305,7 @@ class TransactionResourceIT {
         Transaction partialUpdatedTransaction = new Transaction();
         partialUpdatedTransaction.setId(transaction.getId());
 
-        partialUpdatedTransaction.type(UPDATED_TYPE).comment(UPDATED_COMMENT);
+        partialUpdatedTransaction.comment(UPDATED_COMMENT);
 
         restTransactionMockMvc
             .perform(