diff --git a/.jhipster/TransactionItem.json b/.jhipster/TransactionItem.json new file mode 100644 index 0000000..3627e1d --- /dev/null +++ b/.jhipster/TransactionItem.json @@ -0,0 +1,42 @@ +{ + "annotations": { + "changelogDate": "20241113135446" + }, + "fields": [ + { + "fieldName": "amount", + "fieldType": "BigDecimal" + }, + { + "fieldName": "date", + "fieldType": "LocalDate" + }, + { + "fieldName": "comment", + "fieldType": "String" + } + ], + "name": "TransactionItem", + "pagination": "no", + "readOnly": false, + "relationships": [ + { + "otherEntityField": "name", + "otherEntityName": "userAccount", + "otherEntityRelationshipName": "transactionItem", + "relationshipName": "userAccount", + "relationshipSide": "left", + "relationshipType": "many-to-many" + }, + { + "otherEntityField": "id", + "otherEntityName": "transaction", + "otherEntityRelationshipName": "transactionItem", + "relationshipName": "transaction", + "relationshipSide": "left", + "relationshipType": "one-to-many" + } + ], + "searchEngine": "no", + "service": "no" +} diff --git a/.yo-rc.json b/.yo-rc.json index 3d3259e..26d7f45 100644 --- a/.yo-rc.json +++ b/.yo-rc.json @@ -15,10 +15,10 @@ "enableHibernateCache": null, "enableSwaggerCodegen": false, "enableTranslation": false, - "entities": ["Charge", "Event", "Registration", "Transaction", "UserAccount"], + "entities": ["Charge", "Event", "Registration", "Transaction", "UserAccount", "TransactionItem"], "feignClient": null, "jhipsterVersion": "8.7.2", - "lastLiquibaseTimestamp": 1731505842000, + "lastLiquibaseTimestamp": 1731506086000, "messageBroker": false, "microfrontend": null, "microfrontends": [], diff --git a/src/main/java/com/sasiedzi/event/domain/Event.java b/src/main/java/com/sasiedzi/event/domain/Event.java index 5556c4b..2a170af 100644 --- a/src/main/java/com/sasiedzi/event/domain/Event.java +++ b/src/main/java/com/sasiedzi/event/domain/Event.java @@ -48,7 +48,7 @@ public class Event implements Serializable { private Set registrations = new HashSet<>(); @OneToMany(fetch = FetchType.LAZY, mappedBy = "event") - @JsonIgnoreProperties(value = { "event" }, allowSetters = true) + @JsonIgnoreProperties(value = { "event", "transactionItem" }, allowSetters = true) private Set transactions = new HashSet<>(); // jhipster-needle-entity-add-field - JHipster will add fields here diff --git a/src/main/java/com/sasiedzi/event/domain/Transaction.java b/src/main/java/com/sasiedzi/event/domain/Transaction.java index 7e61fc5..fb3de48 100644 --- a/src/main/java/com/sasiedzi/event/domain/Transaction.java +++ b/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 diff --git a/src/main/java/com/sasiedzi/event/domain/TransactionItem.java b/src/main/java/com/sasiedzi/event/domain/TransactionItem.java new file mode 100644 index 0000000..f1448e4 --- /dev/null +++ b/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 userAccounts = new HashSet<>(); + + @OneToMany(fetch = FetchType.LAZY, mappedBy = "transactionItem") + @JsonIgnoreProperties(value = { "event", "transactionItem" }, allowSetters = true) + private Set 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 getUserAccounts() { + return this.userAccounts; + } + + public void setUserAccounts(Set userAccounts) { + this.userAccounts = userAccounts; + } + + public TransactionItem userAccounts(Set 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 getTransactions() { + return this.transactions; + } + + public void setTransactions(Set 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 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() + "'" + + "}"; + } +} diff --git a/src/main/java/com/sasiedzi/event/domain/UserAccount.java b/src/main/java/com/sasiedzi/event/domain/UserAccount.java index 00390be..384d2f9 100644 --- a/src/main/java/com/sasiedzi/event/domain/UserAccount.java +++ b/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 users = new HashSet<>(); + @ManyToMany(fetch = FetchType.LAZY, mappedBy = "userAccounts") + @JsonIgnoreProperties(value = { "userAccounts", "transactions" }, allowSetters = true) + private Set 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 getTransactionItems() { + return this.transactionItems; + } + + public void setTransactionItems(Set 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 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 diff --git a/src/main/java/com/sasiedzi/event/repository/TransactionItemRepository.java b/src/main/java/com/sasiedzi/event/repository/TransactionItemRepository.java new file mode 100644 index 0000000..9a3ab7c --- /dev/null +++ b/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 { + default Optional findOneWithEagerRelationships(Long id) { + return this.fetchBagRelationships(this.findById(id)); + } + + default List findAllWithEagerRelationships() { + return this.fetchBagRelationships(this.findAll()); + } + + default Page findAllWithEagerRelationships(Pageable pageable) { + return this.fetchBagRelationships(this.findAll(pageable)); + } +} diff --git a/src/main/java/com/sasiedzi/event/repository/TransactionItemRepositoryWithBagRelationships.java b/src/main/java/com/sasiedzi/event/repository/TransactionItemRepositoryWithBagRelationships.java new file mode 100644 index 0000000..4fbf0d7 --- /dev/null +++ b/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 fetchBagRelationships(Optional transactionItem); + + List fetchBagRelationships(List transactionItems); + + Page fetchBagRelationships(Page transactionItems); +} diff --git a/src/main/java/com/sasiedzi/event/repository/TransactionItemRepositoryWithBagRelationshipsImpl.java b/src/main/java/com/sasiedzi/event/repository/TransactionItemRepositoryWithBagRelationshipsImpl.java new file mode 100644 index 0000000..feeebed --- /dev/null +++ b/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 fetchBagRelationships(Optional transactionItem) { + return transactionItem.map(this::fetchUserAccounts); + } + + @Override + public Page fetchBagRelationships(Page transactionItems) { + return new PageImpl<>( + fetchBagRelationships(transactionItems.getContent()), + transactionItems.getPageable(), + transactionItems.getTotalElements() + ); + } + + @Override + public List fetchBagRelationships(List 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 fetchUserAccounts(List transactionItems) { + HashMap order = new HashMap<>(); + IntStream.range(0, transactionItems.size()).forEach(index -> order.put(transactionItems.get(index).getId(), index)); + List 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; + } +} diff --git a/src/main/java/com/sasiedzi/event/web/rest/TransactionItemResource.java b/src/main/java/com/sasiedzi/event/web/rest/TransactionItemResource.java new file mode 100644 index 0000000..adcedb9 --- /dev/null +++ b/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 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 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 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 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 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 getTransactionItem(@PathVariable("id") Long id) { + LOG.debug("REST request to get TransactionItem : {}", id); + Optional 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 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(); + } +} diff --git a/src/main/resources/config/liquibase/changelog/20241113134007_added_entity_Transaction.xml b/src/main/resources/config/liquibase/changelog/20241113134007_added_entity_Transaction.xml index a176e96..c48f42c 100644 --- a/src/main/resources/config/liquibase/changelog/20241113134007_added_entity_Transaction.xml +++ b/src/main/resources/config/liquibase/changelog/20241113134007_added_entity_Transaction.xml @@ -26,6 +26,9 @@ + + + diff --git a/src/main/resources/config/liquibase/changelog/20241113134007_added_entity_constraints_Transaction.xml b/src/main/resources/config/liquibase/changelog/20241113134007_added_entity_constraints_Transaction.xml index edaca56..9d1a100 100644 --- a/src/main/resources/config/liquibase/changelog/20241113134007_added_entity_constraints_Transaction.xml +++ b/src/main/resources/config/liquibase/changelog/20241113134007_added_entity_constraints_Transaction.xml @@ -16,5 +16,12 @@ referencedColumnNames="id" referencedTableName="event" /> + + diff --git a/src/main/resources/config/liquibase/changelog/20241113135446_added_entity_TransactionItem.xml b/src/main/resources/config/liquibase/changelog/20241113135446_added_entity_TransactionItem.xml new file mode 100644 index 0000000..53fdc61 --- /dev/null +++ b/src/main/resources/config/liquibase/changelog/20241113135446_added_entity_TransactionItem.xml @@ -0,0 +1,67 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/main/resources/config/liquibase/changelog/20241113135446_added_entity_constraints_TransactionItem.xml b/src/main/resources/config/liquibase/changelog/20241113135446_added_entity_constraints_TransactionItem.xml new file mode 100644 index 0000000..b61aff3 --- /dev/null +++ b/src/main/resources/config/liquibase/changelog/20241113135446_added_entity_constraints_TransactionItem.xml @@ -0,0 +1,27 @@ + + + + + + + + + + diff --git a/src/main/resources/config/liquibase/fake-data/transaction_item.csv b/src/main/resources/config/liquibase/fake-data/transaction_item.csv new file mode 100644 index 0000000..3a39abf --- /dev/null +++ b/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 diff --git a/src/main/resources/config/liquibase/master.xml b/src/main/resources/config/liquibase/master.xml index 33047c4..3f0bb26 100644 --- a/src/main/resources/config/liquibase/master.xml +++ b/src/main/resources/config/liquibase/master.xml @@ -16,11 +16,13 @@ + + diff --git a/src/test/java/com/sasiedzi/event/domain/TransactionAsserts.java b/src/test/java/com/sasiedzi/event/domain/TransactionAsserts.java index 29d6c5c..6909593 100644 --- a/src/test/java/com/sasiedzi/event/domain/TransactionAsserts.java +++ b/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())); } } diff --git a/src/test/java/com/sasiedzi/event/domain/TransactionItemAsserts.java b/src/test/java/com/sasiedzi/event/domain/TransactionItemAsserts.java new file mode 100644 index 0000000..85575de --- /dev/null +++ b/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())); + } +} diff --git a/src/test/java/com/sasiedzi/event/domain/TransactionItemTest.java b/src/test/java/com/sasiedzi/event/domain/TransactionItemTest.java new file mode 100644 index 0000000..f3892bb --- /dev/null +++ b/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(); + } +} diff --git a/src/test/java/com/sasiedzi/event/domain/TransactionItemTestSamples.java b/src/test/java/com/sasiedzi/event/domain/TransactionItemTestSamples.java new file mode 100644 index 0000000..6697cba --- /dev/null +++ b/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()); + } +} diff --git a/src/test/java/com/sasiedzi/event/domain/TransactionTest.java b/src/test/java/com/sasiedzi/event/domain/TransactionTest.java index 26c20da..d145950 100644 --- a/src/test/java/com/sasiedzi/event/domain/TransactionTest.java +++ b/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(); + } } diff --git a/src/test/java/com/sasiedzi/event/domain/UserAccountAsserts.java b/src/test/java/com/sasiedzi/event/domain/UserAccountAsserts.java index 039839c..e71e661 100644 --- a/src/test/java/com/sasiedzi/event/domain/UserAccountAsserts.java +++ b/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())); } } diff --git a/src/test/java/com/sasiedzi/event/domain/UserAccountTest.java b/src/test/java/com/sasiedzi/event/domain/UserAccountTest.java index 1201790..fb7631c 100644 --- a/src/test/java/com/sasiedzi/event/domain/UserAccountTest.java +++ b/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); + } } diff --git a/src/test/java/com/sasiedzi/event/web/rest/EventResourceIT.java b/src/test/java/com/sasiedzi/event/web/rest/EventResourceIT.java index a93cf4f..e004b8a 100644 --- a/src/test/java/com/sasiedzi/event/web/rest/EventResourceIT.java +++ b/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( diff --git a/src/test/java/com/sasiedzi/event/web/rest/RegistrationResourceIT.java b/src/test/java/com/sasiedzi/event/web/rest/RegistrationResourceIT.java index b240a74..a400f13 100644 --- a/src/test/java/com/sasiedzi/event/web/rest/RegistrationResourceIT.java +++ b/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( diff --git a/src/test/java/com/sasiedzi/event/web/rest/TransactionItemResourceIT.java b/src/test/java/com/sasiedzi/event/web/rest/TransactionItemResourceIT.java new file mode 100644 index 0000000..ee3fb2c --- /dev/null +++ b/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)); + } +} diff --git a/src/test/java/com/sasiedzi/event/web/rest/TransactionResourceIT.java b/src/test/java/com/sasiedzi/event/web/rest/TransactionResourceIT.java index e88d59a..b34aeba 100644 --- a/src/test/java/com/sasiedzi/event/web/rest/TransactionResourceIT.java +++ b/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(