Adjust Copy domain

backend/src/main/kotlin/com/ksidelta/libruch/modules/copy/CopyAggregate.kt

@@ -6,7 +6,6 @@ import org.axonframework.commandhandling.CommandHandler
 import org.axonframework.eventsourcing.EventSourcingHandler
 import org.axonframework.modelling.command.AggregateIdentifier
 import org.axonframework.modelling.command.AggregateLifecycle.apply
-import org.axonframework.modelling.command.TargetAggregateIdentifier
 import org.axonframework.spring.stereotype.Aggregate
 import java.util.*
 
@@ -15,26 +14,37 @@ class CopyAggregate() {
 
     @AggregateIdentifier
     lateinit var copyId: UUID
-
+    lateinit var organisation: Party.Organisation
+    lateinit var copyStatus: CopyStatus
+    lateinit var borrower: Party.User
+    lateinit var name: String
     @CommandHandler
     constructor(command: RegisterNewCopy) : this() {
         apply(command.run {
             NewCopyRegistered(
                 copyId = UUID.randomUUID(),
-                isbn = isbn,
-                owner = owner,
+                isbn = command.isbn,
+                owner = command.owner,
+                organisation = command.organisation,
+                name = command.name
             )
         })
     }
 
     @EventSourcingHandler
     fun on(evt: NewCopyRegistered) {
         this.copyId = evt.copyId
+        this.copyStatus = CopyStatus.AVAILABLE
     }
 }
 
 
-data class RegisterNewCopy(val isbn: String, val owner: Party)
+data class RegisterNewCopy(val isbn: String,val owner: Party.User, val organisation: Party.Organisation, val name: String) {
+}
+
 
+data class NewCopyRegistered(val copyId: UUID, val isbn: String, val owner: Party.User, val organisation: Party.Organisation, val name: String)
 
-data class NewCopyRegistered(val copyId: UUID, val isbn: String, val owner: Party)
+enum class CopyStatus{
+    AVAILABLE, BORROWED
+}

backend/src/main/kotlin/com/ksidelta/libruch/modules/copy/CopyAvailabilityReadModel.kt

@@ -21,6 +21,7 @@ class CopyEventProcessor(val copyReadModelRepository: CopyReadModelRepository) {
                 id = event.copyId,
                 isbn = event.isbn,
                 owner = event.owner.partyId,
+                status = CopyStatus.AVAILABLE
             )
         )
 }
@@ -29,6 +30,8 @@ class CopyEventProcessor(val copyReadModelRepository: CopyReadModelRepository) {
 interface CopyReadModelRepository : CrudRepository<CopyAvailabilityModel, UUID> {
     fun findAllByOwner(owner: Party): Iterable<CopyAvailabilityModel>
     fun findAllByOwnerIn(owner: Collection<Party>): Iterable<CopyAvailabilityModel>
+
+    fun findByNameAndOrganisationIn(name: String, organisations: Collection<Party.Organisation>): Iterable<CopyAvailabilityModel>
 }
 
 @Entity(name = "copy_availability_model")
@@ -37,6 +40,7 @@ data class CopyAvailabilityModel(
     val id: UUID,
     val isbn: String,
     val owner: UUID,
+    val status: CopyStatus
 )
 
 

backend/src/main/kotlin/com/ksidelta/libruch/modules/copy/CopyController.kt

@@ -23,7 +23,14 @@ class CopyController(
     suspend fun create(@RequestBody body: CreateCopyDTO, principal: Principal) =
         body.run {
             val user = authenticationService.findUser(principal)
-            val aggregateId = commandGateway.send<UUID>(RegisterNewCopy(isbn, Party.User(user.id))).await()
+            val aggregateId = commandGateway.send<UUID>(
+                RegisterNewCopy(
+                    isbn,
+                    user,
+                    Party.Organisation(body.organisationID),
+                    body.name
+                )
+            ).await()
             CreatedCopyDTO(aggregateId)
         }
 
@@ -38,16 +45,37 @@ class CopyController(
                 .let { CopyAvailabilityListDTO(it) }
         }
 
+    @GetMapping("/search")
+    suspend fun listCopiesByName(@RequestBody body: searchDTO, principal: Principal) : SearchCopyListDTO =
+        authenticationService.withUser(principal) {it.organisations}.let {
+            queryGateway.query(
+                QueryByNameAndOrganisations(
+                    body.name,
+                    authenticationService.findUser(principal),
+                    authenticationService.findUser(principal).organisations),
+                ResponseTypes.multipleInstancesOf(CopyAvailabilityModel::class.java)
+            ).await()
+                .map { it.run { CopyAvailabilityDTO(id = it.id, isbn = it.isbn) } }
+                .let { SearchCopyListDTO(it) }
+        }
+
+
 }
 
-data class CreateCopyDTO(val isbn: String);
-data class CreatedCopyDTO(val id: UUID);
+
+class searchDTO (val name: String) {
+}
+
+data class SearchCopyListDTO (val l: List<CopyAvailabilityDTO>)
+
+data class CreateCopyDTO(val isbn: String, val organisationID: UUID, val owner: Party.User, val name: String)
+data class CreatedCopyDTO(val id: UUID)
 
 data class CopyAvailabilityListDTO(
     val copies: List<CopyAvailabilityDTO>
 )
 
 data class CopyAvailabilityDTO(
     val id: UUID,
-    var isbn: String,
+    var isbn: String
 )

backend/src/main/kotlin/com/ksidelta/libruch/modules/copy/CopyQueryHandler.kt

@@ -18,8 +18,17 @@ class CopyQueryHandler(val copyReadModelRepository: CopyReadModelRepository) {
     fun query(queryByOwners: QueryByOwners) =
         copyReadModelRepository.findAllByOwnerIn(owner = queryByOwners.owners).toList()
 
+    @QueryHandler
+    fun query(queryByName: QueryByNameAndOrganisations) =
+        copyReadModelRepository.findByNameAndOrganisationIn(name = queryByName.name, organisations = queryByName.organisations)
 }
 
 class QueryAllCopies() {}
 class QueryByOwner(val owner: Party) {}
 class QueryByOwners(val owners: Collection<Party>) {}
+
+class QueryByNameAndOrganisations(
+    val name: String,
+    val user: Party.User,
+    val organisations: Collection<Party.Organisation>
+)