From b070931c987be92ffea8132dac5ca4d8326e1e47 Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Thu, 30 Apr 2026 16:45:51 -0400
Subject: [PATCH 01/48] Core - API - review and polish of instance mutex
 utility

---
 .../serviceState/InstanceMutexService.java    | 130 +++++++++++------
 .../InstanceMutexServiceTest.java             | 135 +++++++++++++-----
 2 files changed, 185 insertions(+), 80 deletions(-)

diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexService.java
index f26e330c7..1862c027d 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexService.java
@@ -14,6 +14,7 @@
 import tech.ebp.oqm.core.api.exception.MutexWaitTimeoutException;
 import tech.ebp.oqm.core.api.model.InstanceMutex;
 import tech.ebp.oqm.core.api.model.collectionStats.CollectionStats;
+import tech.ebp.oqm.core.api.model.object.MainObject;
 import tech.ebp.oqm.core.api.model.rest.search.InstanceMutexSearch;
 import tech.ebp.oqm.core.api.service.mongo.TopLevelMongoService;
 
@@ -33,44 +34,65 @@
 /**
  * Provides an interface through which to provide mutex functionality between instances of the core api.
  * <p>
+ * Important data:
+ * <ul>
+ *    <li>Mutex id: the id of the mutex to use; Is used to identify the specific mutex to work off of</li>
+ *    <li>Identity: the identity of the entity trying to use the mutex, defaults to this instance's running uuid</li>
+ *    <li>Additional ID; An additional identity to identify within one instance; added onto the base identity when doing lock/frees</li>
+ * </ul>
+ *
+ * <p>
  * Use:
  * <ol>
- *     <li>Call {@link #register(String)} to ensure mutex exists.</li>
+ *     <li>Call {@link #register(String)} to ensure mutex exists. Always call at least once before locking.</li>
  *     <li>Call {@link #lock(String, Optional)} to grab the lock.</li>
  *     <li>Call {@link #free(String, Optional)} to free the lock.</li>
+ *     <li>Use {@link #getResource(boolean, String, Optional)} to get a locking resource usable in a try-with-resources. Call {@link #register(String)} before using.</li>
  * </ol>
+ * Details:
+ * <ul>
+ *     <li>NOT re-entrant safe. A second call to lock() on these mutexes from the same identity will fail to lock</li>
+ * </ul>
  * <p>
  * Original inspiration: https://www.disk91.com/2018/technology/programming/springboot-mongo-create-a-mutex-to-synchronize-multiple-frontends/
  */
 @ApplicationScoped
 @Slf4j
 public class InstanceMutexService extends TopLevelMongoService<InstanceMutex, InstanceMutexSearch, CollectionStats> {
-
+	
+	public static <T extends MainObject> String getMutexIdFor(T object) {
+		if (object.getId() == null) {
+			throw new IllegalArgumentException("Cannot get mutex id for object with null id");
+		}
+		return object.getClass().getSimpleName() + "-" + object.getId();
+	}
+	
 	private TemporalAmount lockExpire = Duration.of(10, ChronoUnit.MINUTES);
-
+	
 	@ConfigProperty(name = "quarkus.uuid")
 	protected String instanceUuid;
-
+	
 	protected InstanceMutexService() {
 		super(InstanceMutex.class);
 	}
-
+	
 	protected String getIdentity(Optional<String> additionalIdentity) {
-		return this.instanceUuid + additionalIdentity.map(s -> "-" + s).orElse("");
+		return this.instanceUuid + additionalIdentity.map(s->"-" + s).orElse("");
 	}
-
+	
 	private void clearDuplicateMutexes(String mutexId) {
+		//TODO:: cache, to only do one check for any one mutex?
 		List<InstanceMutex> mutexes = this.getTypedCollection().find(eq("mutexId", mutexId)).into(new ArrayList<>());
 		if (mutexes.size() > 1) {
 			log.info("Multiple mutex objects for {} detected ({} total mutexes). Deleting extra.", mutexId, mutexes.size());
 			mutexes.removeFirst();
-
+			
 			for (InstanceMutex mutex : mutexes) {
 				this.getTypedCollection().deleteOne(eq("_id", mutex.getId()));
 			}
 		}
 	}
-
+	
 	/**
 	 * Registers the mutex with the given id. Always call this before starting to use the mutex.
 	 *
@@ -79,20 +101,20 @@ private void clearDuplicateMutexes(String mutexId) {
 	public void register(String mutexId) {
 		// Verify if exists
 		List<InstanceMutex> existingMutexes = this.getTypedCollection().find(eq("mutexId", mutexId)).into(new ArrayList<>());
-
-		log.info("Existent mutexes: {}", existingMutexes);
-
+		
+		log.debug("Existent mutexes: {}", existingMutexes);
+		
 		if (existingMutexes.isEmpty()) {
 			// create it assuming no collision at this point
 			InstanceMutex newMutex = new InstanceMutex(mutexId);
 			log.info("Creating new mutex {}", newMutex);
-
+			
 			UpdateResult result = this.getTypedCollection().updateOne(
 				eq("mutexId", mutexId),
 				Updates.set("mutexId", mutexId),
 				new UpdateOptions().upsert(true)
 			);
-
+			
 			if (result.getUpsertedId() != null) {
 				log.info("Mutex {} created.", mutexId);
 			} else {
@@ -104,7 +126,7 @@ public void register(String mutexId) {
 			this.clearDuplicateMutexes(mutexId);
 		}
 	}
-
+	
 	/**
 	 * Locks the mutex with the given id.
 	 * <p>
@@ -112,17 +134,18 @@ public void register(String mutexId) {
 	 * <p>
 	 * Call {@link #register(String)} before using this method.
 	 *
-	 * @param mutexId            The is of the mutex to get the lock for
+	 * @param mutexId The is of the mutex to get the lock for
 	 * @param additionalIdentity If an additional identity is required. Only use if need the mutex to offer concurrency within the same instance of the app.
+	 *
 	 * @return true when reserved, false when not.
 	 */
 	public boolean lock(@NonNull String mutexId, Optional<String> additionalIdentity) {
 		String identity = this.getIdentity(additionalIdentity);
 		Bson mutexIdEquals = eq("mutexId", mutexId);
-
+		
 		//ensure only one mutex object
 		this.clearDuplicateMutexes(mutexId);
-
+		
 		// try an update
 		InstanceMutex old = this.getTypedCollection().findOneAndUpdate(
 			and(
@@ -131,7 +154,7 @@ public boolean lock(@NonNull String mutexId, Optional<String> additionalIdentity
 					not(exists("taken")),
 					eq("taken", false)
 				)
-
+			
 			),
 			Updates.combine(
 				Updates.set("taken", true),
@@ -139,7 +162,7 @@ public boolean lock(@NonNull String mutexId, Optional<String> additionalIdentity
 				Updates.set("takenBy", identity)
 			)
 		);
-
+		
 		if (old != null) {
 			// success ...
 			// Update the information
@@ -148,36 +171,45 @@ public boolean lock(@NonNull String mutexId, Optional<String> additionalIdentity
 			return true;
 		} else {
 			log.info("Failed to reserve Mutex {} for {}", mutexId, identity);
-
+			
 			InstanceMutex lockedMutex = this.getTypedCollection().find(mutexIdEquals).first();
 			log.debug("Locked mutex: {}", lockedMutex);
-
+			
 			if (lockedMutex == null) {
-				log.warn("No mutex found. It needs to be registered first.");
+				throw new IllegalStateException("Mutex was not registered before usage: " + mutexId);
 			} else if (lockedMutex.getTakenAt() != null && ZonedDateTime.now().isAfter(lockedMutex.getTakenAt().plus(this.lockExpire))) {
 				this.getTypedCollection().findOneAndUpdate(mutexIdEquals, Updates.set("taken", false));
 				log.warn("Unlocked mutex that appeared deadlocked: {}", mutexId);
 			} else {
 				log.debug("Was locked. returning.");
 			}
-
+			
 			return false;
 		}
 	}
-
+	
+	/**
+	 * Convenience wrapper for {@link #lock(String, Optional)}
+	 * @param mutexId
+	 * @return
+	 */
 	public boolean lock(@NonNull String mutexId) {
 		return this.lock(mutexId, Optional.empty());
 	}
-
+	
+	//TODO:: add await to lock
+	
 	/**
 	 * Free a mutex previously reserved.
 	 *
-	 * @param mutexId            The id of the mutex to free
+	 * TODO:: return bool for if actually freed
+	 *
+	 * @param mutexId The id of the mutex to free
 	 * @param additionalIdentity If needed to mutex threads inside the same service, provide this
 	 */
 	public void free(@NonNull String mutexId, Optional<String> additionalIdentity) {
 		String identity = this.getIdentity(additionalIdentity);
-
+		
 		InstanceMutex mutex = this.getTypedCollection().findOneAndUpdate(
 			and(
 				eq("mutexId", mutexId),
@@ -190,14 +222,14 @@ public void free(@NonNull String mutexId, Optional<String> additionalIdentity) {
 				Updates.set("takenBy", null)
 			)
 		);
-
+		
 		if (mutex == null) {
-			log.info("Mutex NOT freed. Either not taken or not taken by this identity. Mutex: {}", mutex);
+			log.warn("Mutex NOT freed. Either not taken or not taken by this identity. Mutex: {}", mutex);
 		} else {
 			log.info("Mutex FREED: {}", mutexId);
 		}
 	}
-
+	
 	public void free(@NonNull String mutexId) {
 		this.free(mutexId, Optional.empty());
 	}
@@ -207,6 +239,21 @@ public int getCurrentSchemaVersion() {
 		return InstanceMutex.CUR_SCHEMA_VERSION;
 	}
 	
+	
+	public InstanceMutexResource getResource(boolean startLocked, String mutexId, Optional<String> additionalId) throws InterruptedException {
+		InstanceMutexResource resource = InstanceMutexResource.builder()
+											 .mutexService(this)
+											 .mutexId(mutexId)
+											 .additionalIdentity(additionalId)
+											 .build();
+		if (startLocked) {
+			resource.awaitLock();
+		}
+		
+		return resource;
+	}
+	
+	
 	/**
 	 * Class to enable usage in a try-with-resources.
 	 * <p>
@@ -215,25 +262,26 @@ public int getCurrentSchemaVersion() {
 	@Data
 	@Builder
 	public static class InstanceMutexResource implements Closeable {
+		
 		@NonNull
 		@NotNull
 		private InstanceMutexService mutexService;
-
+		
 		@NonNull
 		@NotNull
 		@NotBlank
 		private String mutexId;
-
+		
 		@NonNull
 		@NotNull
 		@lombok.Builder.Default
 		private Optional<String> additionalIdentity = Optional.empty();
-
+		
 		@NonNull
 		@NotNull
 		@lombok.Builder.Default
 		private Optional<Duration> timeToWait = Optional.empty();
-
+		
 		/**
 		 * Awaits for the lock to be acquired before returning this object.
 		 *
@@ -242,20 +290,20 @@ public static class InstanceMutexResource implements Closeable {
 		public InstanceMutexResource awaitLock() throws MutexWaitTimeoutException, InterruptedException {
 			Duration toWait = this.getTimeToWait().orElse(Duration.ofHours(1));
 			LocalDateTime expires = LocalDateTime.now().plus(toWait);
-
-			this.getMutexService().register(this.getMutexId());
-
+			
+			//			this.getMutexService().register(this.getMutexId());
+			
 			do {
 				boolean result = this.getMutexService().lock(this.getMutexId(), this.getAdditionalIdentity());
-
+				
 				if (result) {
 					return this;
 				}
-				Thread.sleep(50);//TODO:: make configurable wait time
+				Thread.sleep(50);//TODO:: make configurable wait time, random
 			} while (LocalDateTime.now().isBefore(expires));
 			throw new MutexWaitTimeoutException();
 		}
-
+		
 		@Override
 		public void close() throws IOException {
 			this.getMutexService().free(this.getMutexId(), this.getAdditionalIdentity());
diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexServiceTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexServiceTest.java
index a6118b315..ff0fc6161 100644
--- a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexServiceTest.java
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexServiceTest.java
@@ -11,6 +11,7 @@
 import org.junit.jupiter.params.provider.MethodSource;
 import tech.ebp.oqm.core.api.testResources.testClasses.RunningServerTest;
 
+import java.io.IOException;
 import java.time.Duration;
 import java.time.LocalDateTime;
 import java.time.temporal.ChronoUnit;
@@ -23,7 +24,7 @@
 @Slf4j
 @QuarkusTest
 public class InstanceMutexServiceTest extends RunningServerTest {
-
+	
 	public static Stream<Arguments> getParams() {
 		return Stream.of(
 			Arguments.of(2, 10, Duration.of(250, ChronoUnit.MILLIS)),
@@ -33,26 +34,26 @@ public static Stream<Arguments> getParams() {
 			Arguments.of(20, 20, Duration.of(150, ChronoUnit.MILLIS))
 		);
 	}
-
+	
 	@Inject
 	InstanceMutexService instanceMutexService;
-
+	
 	@Test
 	public void basicTest() {
 		String mutexId = "testMutex";
 		this.instanceMutexService.register(mutexId);
-
+		
 		assertTrue(this.instanceMutexService.lock(mutexId));
-
+		
 		assertFalse(this.instanceMutexService.lock(mutexId));
-
+		
 		this.instanceMutexService.free(mutexId);
-
+		
 		assertTrue(this.instanceMutexService.lock(mutexId));
 		this.instanceMutexService.free(mutexId);
 	}
-
-
+	
+	
 	@ParameterizedTest
 	@MethodSource("getParams")
 	public void threadTest(int numThreads, int numIterations, Duration workDuration) throws InterruptedException, ExecutionException {
@@ -60,37 +61,37 @@ public void threadTest(int numThreads, int numIterations, Duration workDuration)
 		List<Future<List<ThreadResult>>> futures = new ArrayList<>(numThreads);
 		SortedSet<ThreadResult> results = new TreeSet<>();
 		ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
-
+		
 		TestThread.TestThreadBuilder threadBuilder = TestThread.builder()
-			.mutexId(mutexId)
-			.numIterations(numIterations)
-			.durationOfWork(workDuration)
-			.instanceMutexService(instanceMutexService);
-
+														 .mutexId(mutexId)
+														 .numIterations(numIterations)
+														 .durationOfWork(workDuration)
+														 .instanceMutexService(instanceMutexService);
+		
 		for (int i = 1; i <= numThreads; i++) {
 			threadBuilder.threadId("testThread-" + i);
-
+			
 			futures.add(executor.submit(threadBuilder.build()));
 		}
 		executor.shutdown();
 		while (!executor.awaitTermination(1, TimeUnit.MINUTES)) {
 			log.info("Still waiting on threads...");
 		}
-
+		
 		for (Future<List<ThreadResult>> future : futures) {
 			results.addAll(future.get());
 		}
-
+		
 		assertEquals(numIterations * numThreads, results.size());
-
+		
 		//TODO:: check results
 		log.info("Results: {}", results);
-
+		
 		Iterator<ThreadResult> iterator = results.iterator();
 		ThreadResult cur = iterator.next();
 		while (iterator.hasNext()) {
 			ThreadResult next = iterator.next();
-
+			
 			assertTrue(
 				next.getStart().isAfter(cur.getStart()),
 				"result " + cur + " start overlaps with the next result " + next + " (next start is before cur start)"
@@ -99,62 +100,66 @@ public void threadTest(int numThreads, int numIterations, Duration workDuration)
 				(next.getStart().isAfter(cur.getEnd()) || next.getStart().equals(cur.getEnd())),
 				"result " + cur + " overlaps with the next result " + next + " (next start is before cur end)"
 			);
-
+			
 			cur = next;
 		}
-
+		
 	}
-
+	
 	@Builder
 	@Data
 	@AllArgsConstructor
 	static
 	class ThreadResult implements Comparable<ThreadResult> {
+		
 		private String threadId;
 		private LocalDateTime start;
 		private LocalDateTime end;
-
+		
 		@Override
 		public int compareTo(@NonNull InstanceMutexServiceTest.ThreadResult threadResult) {
 			return this.getStart().compareTo(threadResult.getStart());
 		}
 	}
-
+	
 	@Builder
 	@Slf4j
 	@AllArgsConstructor
 	static class TestThread implements Callable<List<ThreadResult>> {
-
+		
 		private String mutexId;
 		private String threadId;
 		private InstanceMutexService instanceMutexService;
 		private int numIterations;
 		private Duration durationOfWork;
-
+		
 		@SneakyThrows
 		@Override
 		public List<ThreadResult> call() {
 			log.info("Running test thread {}", this.threadId);
-
+			
+			Random rand = new Random();
+			
 			this.instanceMutexService.register(this.mutexId);
-
-//			Thread.sleep(500);
-
+			
+			//			Thread.sleep(500);
+			
 			List<ThreadResult> results = new ArrayList<>(this.numIterations);
 			for (int i = 1; i <= this.numIterations; i++) {
 				log.info("Thread {} waiting for lock on iteration {}", this.threadId, i);
 				while (!instanceMutexService.lock(this.mutexId, Optional.of(this.threadId))) {
-					Thread.sleep(50);
+					//noinspection BusyWait
+					Thread.sleep(rand.nextInt(0, 50));
 				}
 				log.info("Thread {} got lock on iteration {}/{}", this.threadId, i, this.numIterations);
 				ThreadResult.ThreadResultBuilder resultBuilder = ThreadResult.builder()
-					.threadId(this.threadId)
-					.start(LocalDateTime.now());
-
+																	 .threadId(this.threadId)
+																	 .start(LocalDateTime.now());
+				
 				Thread.sleep(this.durationOfWork);
-
+				
 				resultBuilder.end(LocalDateTime.now());
-
+				
 				this.instanceMutexService.free(this.mutexId, Optional.of(this.threadId));
 				log.info("Thread {} done doing work & released lock on iteration {}", this.threadId, i);
 				results.add(resultBuilder.build());
@@ -163,5 +168,57 @@ public List<ThreadResult> call() {
 			return results;
 		}
 	}
-
+	
+	@Test
+	public void testWithResources() throws InterruptedException {
+		String id = "testWithResources";
+		
+		log.info("Starting mutex with resources check");
+		
+		this.instanceMutexService.register(id);
+		
+		try (
+			InstanceMutexService.InstanceMutexResource mutex = this.instanceMutexService.getResource(true, id, Optional.empty())
+		) {
+			log.info("In the critical section, 1");
+		} catch(IOException e) {
+			throw new RuntimeException(e);
+		}
+		
+		log.info("In between mutex try-with-resources");
+		
+		try (
+			InstanceMutexService.InstanceMutexResource mutex = this.instanceMutexService.getResource(true, id, Optional.empty())
+		) {
+			log.info("In the critical section, 2");
+		} catch(IOException e) {
+			throw new RuntimeException(e);
+		}
+		
+		log.info("Finished mutex 2");
+	}
+	
+	@Test
+	public void testUseBeforeRegister() {
+		assertEquals(
+			"Mutex was not registered before usage: testUseBeforeRegister",
+			assertThrows(
+				IllegalStateException.class, ()->{
+					this.instanceMutexService.lock("testUseBeforeRegister");
+				}
+			).getMessage()
+		);
+	}
+	
+	@Test
+	public void testSameEntityDoubleLock() {
+		String id = "testSameEntityDoubleLock";
+		
+		this.instanceMutexService.register(id);
+		
+		assertTrue(this.instanceMutexService.lock(id));
+		assertFalse(this.instanceMutexService.lock(id, Optional.of("foo")));
+		assertFalse(this.instanceMutexService.lock(id));
+	}
+	
 }

From 7413b2677326c1d3c5b0d1f8d758cf74941c7df4 Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Fri, 1 May 2026 17:31:01 -0400
Subject: [PATCH 02/48] Core - API - polish and documentation of mutex
 utilities

---
 .../ebp/oqm/core/api/config/MutexConfig.java  |  29 ++++
 .../serviceState/InstanceMutexService.java    | 157 +++++++++++++-----
 .../InstanceMutexServiceTest.java             | 104 ++++++++----
 3 files changed, 215 insertions(+), 75 deletions(-)
 create mode 100644 software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/config/MutexConfig.java

diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/config/MutexConfig.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/config/MutexConfig.java
new file mode 100644
index 000000000..1ca406551
--- /dev/null
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/config/MutexConfig.java
@@ -0,0 +1,29 @@
+package tech.ebp.oqm.core.api.config;
+
+import io.smallrye.config.ConfigMapping;
+import io.smallrye.config.WithDefault;
+
+import java.time.Duration;
+
+@ConfigMapping(prefix = "service.mutex", namingStrategy = ConfigMapping.NamingStrategy.VERBATIM)
+public interface MutexConfig {
+	
+	@WithDefault("${quarkus.uuid}")
+	String instanceId();
+	
+	@WithDefault("10m")
+	Duration lockExpireDuration();
+	
+	AwaitConfig await();
+	
+	interface AwaitConfig {
+		@WithDefault("30s")
+		Duration timeout();
+		
+		@WithDefault("0ms")
+		Duration loopPauseMin();
+		
+		@WithDefault("50ms")
+		Duration loopPauseMax();
+	}
+}
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexService.java
index 1862c027d..4a9177192 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexService.java
@@ -3,14 +3,17 @@
 import com.mongodb.client.model.*;
 import com.mongodb.client.result.UpdateResult;
 import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
 import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.NotNull;
+import lombok.AccessLevel;
 import lombok.Builder;
 import lombok.Data;
+import lombok.Getter;
 import lombok.NonNull;
 import lombok.extern.slf4j.Slf4j;
 import org.bson.conversions.Bson;
-import org.eclipse.microprofile.config.inject.ConfigProperty;
+import tech.ebp.oqm.core.api.config.MutexConfig;
 import tech.ebp.oqm.core.api.exception.MutexWaitTimeoutException;
 import tech.ebp.oqm.core.api.model.InstanceMutex;
 import tech.ebp.oqm.core.api.model.collectionStats.CollectionStats;
@@ -23,11 +26,10 @@
 import java.time.Duration;
 import java.time.LocalDateTime;
 import java.time.ZonedDateTime;
-import java.time.temporal.ChronoUnit;
-import java.time.temporal.TemporalAmount;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
+import java.util.Random;
 
 import static com.mongodb.client.model.Filters.*;
 
@@ -67,19 +69,28 @@ public static <T extends MainObject> String getMutexIdFor(T object) {
 		return object.getClass().getSimpleName() + "-" + object.getId();
 	}
 	
-	private TemporalAmount lockExpire = Duration.of(10, ChronoUnit.MINUTES);
 	
-	@ConfigProperty(name = "quarkus.uuid")
-	protected String instanceUuid;
+	@Inject
+	@Getter(AccessLevel.PRIVATE)
+	MutexConfig mutexConfig;
 	
 	protected InstanceMutexService() {
 		super(InstanceMutex.class);
 	}
 	
+	/**
+	 * Builds the identity for the mutex. returned value used as final value for identity in mutex mongo collection.
+	 * @param additionalIdentity If there is an additional identity to provide.
+	 * @return
+	 */
 	protected String getIdentity(Optional<String> additionalIdentity) {
-		return this.instanceUuid + additionalIdentity.map(s->"-" + s).orElse("");
+		return this.getMutexConfig().instanceId() + additionalIdentity.map(s->"-" + s).orElse("");
 	}
 	
+	/**
+	 * Clears any duplicate mutexes for the given mutex id. This is to prevent multiple instances of the same mutex from being created.
+	 * @param mutexId The id of the mutex to clear duplicates for.
+	 */
 	private void clearDuplicateMutexes(String mutexId) {
 		//TODO:: cache, to only do one check for any one mutex?
 		List<InstanceMutex> mutexes = this.getTypedCollection().find(eq("mutexId", mutexId)).into(new ArrayList<>());
@@ -170,18 +181,18 @@ public boolean lock(@NonNull String mutexId, Optional<String> additionalIdentity
 			log.info("Acquired lock for {} on mutex {}", identity, mutexId);
 			return true;
 		} else {
-			log.info("Failed to reserve Mutex {} for {}", mutexId, identity);
+			log.debug("Failed to reserve Mutex {} for {}", mutexId, identity);
 			
 			InstanceMutex lockedMutex = this.getTypedCollection().find(mutexIdEquals).first();
-			log.debug("Locked mutex: {}", lockedMutex);
+			log.trace("Locked mutex: {}", lockedMutex);
 			
 			if (lockedMutex == null) {
 				throw new IllegalStateException("Mutex was not registered before usage: " + mutexId);
-			} else if (lockedMutex.getTakenAt() != null && ZonedDateTime.now().isAfter(lockedMutex.getTakenAt().plus(this.lockExpire))) {
+			} else if (lockedMutex.getTakenAt() != null && ZonedDateTime.now().isAfter(lockedMutex.getTakenAt().plus(this.getMutexConfig().lockExpireDuration()))) {
 				this.getTypedCollection().findOneAndUpdate(mutexIdEquals, Updates.set("taken", false));
 				log.warn("Unlocked mutex that appeared deadlocked: {}", mutexId);
 			} else {
-				log.debug("Was locked. returning.");
+				log.trace("Was locked. returning.");
 			}
 			
 			return false;
@@ -190,24 +201,58 @@ public boolean lock(@NonNull String mutexId, Optional<String> additionalIdentity
 	
 	/**
 	 * Convenience wrapper for {@link #lock(String, Optional)}
+	 *
 	 * @param mutexId
+	 *
 	 * @return
 	 */
 	public boolean lock(@NonNull String mutexId) {
 		return this.lock(mutexId, Optional.empty());
 	}
 	
-	//TODO:: add await to lock
+	/**
+	 * Awaits for the lock to be acquired via looping with calls to {@link #lock(String, Optional)} until lock acquired or timeout.
+	 *
+	 * WILL block the thread, waiting/sleeping in the loop between calls to lock.
+	 *
+	 * @param mutexId The id of the mutex to get the lock for
+	 * @param additionalIdentity If an additional identity is required. Only use if need the mutex to offer concurrency within the same instance of the app.
+	 * @throws MutexWaitTimeoutException If the lock is not acquired within the timeout period.
+	 * @throws InterruptedException If the thread is interrupted while waiting for the lock.
+	 */
+	public void awaitLock(@NonNull String mutexId, Optional<String> additionalIdentity) throws MutexWaitTimeoutException, InterruptedException {
+		Duration toWait = this.getMutexConfig().await().timeout();
+		LocalDateTime expires = LocalDateTime.now().plus(toWait);
+		long maitTimeMin = this.getMutexConfig().await().loopPauseMin().toMillis();
+		long maitTimeMax = this.getMutexConfig().await().loopPauseMax().toMillis();
+		Random random = new Random();
+		
+		//			this.getMutexService().register(this.getMutexId());
+		
+		log.debug("Awaiting lock for {} with timeout of {}. Max wait time: {}. Min wait time: {}", mutexId, toWait, maitTimeMax, maitTimeMin);
+		
+		do {
+			boolean result = this.lock(mutexId, additionalIdentity);
+			
+			if (result) {
+				return;
+			}
+			
+			Thread.sleep(
+				random.nextLong(maitTimeMin, maitTimeMax)
+			);
+		} while (LocalDateTime.now().isBefore(expires));
+		throw new MutexWaitTimeoutException();
+	}
 	
 	/**
 	 * Free a mutex previously reserved.
 	 *
-	 * TODO:: return bool for if actually freed
-	 *
 	 * @param mutexId The id of the mutex to free
+	 * @return true if freed, false if not.
 	 * @param additionalIdentity If needed to mutex threads inside the same service, provide this
 	 */
-	public void free(@NonNull String mutexId, Optional<String> additionalIdentity) {
+	public boolean free(@NonNull String mutexId, Optional<String> additionalIdentity) {
 		String identity = this.getIdentity(additionalIdentity);
 		
 		InstanceMutex mutex = this.getTypedCollection().findOneAndUpdate(
@@ -225,13 +270,20 @@ public void free(@NonNull String mutexId, Optional<String> additionalIdentity) {
 		
 		if (mutex == null) {
 			log.warn("Mutex NOT freed. Either not taken or not taken by this identity. Mutex: {}", mutex);
+			return false;
 		} else {
 			log.info("Mutex FREED: {}", mutexId);
+			return true;
 		}
 	}
 	
-	public void free(@NonNull String mutexId) {
-		this.free(mutexId, Optional.empty());
+	/**
+	 * Convenience wrapper for {@link #free(String, Optional)}
+	 * @param mutexId The id of the mutex to free
+	 * @return true if freed, false if not.
+	 */
+	public boolean free(@NonNull String mutexId) {
+		return this.free(mutexId, Optional.empty());
 	}
 	
 	@Override
@@ -239,8 +291,18 @@ public int getCurrentSchemaVersion() {
 		return InstanceMutex.CUR_SCHEMA_VERSION;
 	}
 	
-	
-	public InstanceMutexResource getResource(boolean startLocked, String mutexId, Optional<String> additionalId) throws InterruptedException {
+	/**
+	 * Gets a new resource to use for locking in try-with-resources.
+	 *
+	 * @param startLocked if to start the lock immediately. If true, awaits for the lock to be acquired before returning.
+	 * @param mutexId the id of the mutex to use
+	 * @param additionalId an additional identity to use if needed
+	 *
+	 * @return The resource to use in a try-with-resources block.
+	 * @throws MutexWaitTimeoutException If set to start locked and the lock is not acquired within the timeout period.
+	 * @throws InterruptedException If the thread is interrupted while waiting for the lock.
+	 */
+	public InstanceMutexResource getResource(boolean startLocked, String mutexId, Optional<String> additionalId) throws MutexWaitTimeoutException, InterruptedException {
 		InstanceMutexResource resource = InstanceMutexResource.builder()
 											 .mutexService(this)
 											 .mutexId(mutexId)
@@ -253,11 +315,23 @@ public InstanceMutexResource getResource(boolean startLocked, String mutexId, Op
 		return resource;
 	}
 	
+	/**
+	 * Convenience wrapper for {@link #getResource(boolean, String, Optional)} with startLocked set to true.
+	 *
+	 * @param mutexId the id of the mutex to use
+	 * @param additionalId an additional identity to use if needed
+	 *
+	 * @return The resource to use in a try-with-resources block.
+	 * @throws MutexWaitTimeoutException If the lock is not acquired within the timeout period.
+	 * @throws InterruptedException If the thread is interrupted while waiting for the lock.
+	 */
+	public InstanceMutexResource getResource(String mutexId, Optional<String> additionalId) throws MutexWaitTimeoutException, InterruptedException {
+		return this.getResource(true, mutexId, additionalId);
+	}
+	
 	
 	/**
 	 * Class to enable usage in a try-with-resources.
-	 * <p>
-	 * TODO:: test
 	 */
 	@Data
 	@Builder
@@ -277,35 +351,34 @@ public static class InstanceMutexResource implements Closeable {
 		@lombok.Builder.Default
 		private Optional<String> additionalIdentity = Optional.empty();
 		
-		@NonNull
-		@NotNull
-		@lombok.Builder.Default
-		private Optional<Duration> timeToWait = Optional.empty();
+		/**
+		 * Attempts to lock the mutex.
+		 * <p>
+		 * Wrapper for {@link #InstanceMutexService#lock(String, Optional)}
+		 *
+		 * @return If the lock was acquired or not
+		 */
+		public boolean lock() {
+			return this.mutexService.lock(this.getMutexId(), this.getAdditionalIdentity());
+		}
 		
 		/**
 		 * Awaits for the lock to be acquired before returning this object.
+		 * <p>
+		 * Wrapper for {@link #InstanceMutexService#awaitLock(String, Optional)}
 		 *
-		 * @return This object when the lock is acquired.
+		 * @throws MutexWaitTimeoutException If the lock is not acquired within the timeout period.
+		 * @throws InterruptedException If the thread is interrupted while waiting for the lock.
 		 */
-		public InstanceMutexResource awaitLock() throws MutexWaitTimeoutException, InterruptedException {
-			Duration toWait = this.getTimeToWait().orElse(Duration.ofHours(1));
-			LocalDateTime expires = LocalDateTime.now().plus(toWait);
-			
-			//			this.getMutexService().register(this.getMutexId());
-			
-			do {
-				boolean result = this.getMutexService().lock(this.getMutexId(), this.getAdditionalIdentity());
-				
-				if (result) {
-					return this;
-				}
-				Thread.sleep(50);//TODO:: make configurable wait time, random
-			} while (LocalDateTime.now().isBefore(expires));
-			throw new MutexWaitTimeoutException();
+		public void awaitLock() throws MutexWaitTimeoutException, InterruptedException {
+			this.mutexService.awaitLock(this.getMutexId(), this.getAdditionalIdentity());
 		}
 		
+		/**
+		 * Frees the lock.
+		 */
 		@Override
-		public void close() throws IOException {
+		public void close() {
 			this.getMutexService().free(this.getMutexId(), this.getAdditionalIdentity());
 		}
 	}
diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexServiceTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexServiceTest.java
index ff0fc6161..5c0ae6632 100644
--- a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexServiceTest.java
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexServiceTest.java
@@ -5,10 +5,12 @@
 import jakarta.inject.Inject;
 import lombok.*;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.time.StopWatch;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
+import tech.ebp.oqm.core.api.exception.MutexWaitTimeoutException;
 import tech.ebp.oqm.core.api.testResources.testClasses.RunningServerTest;
 
 import java.io.IOException;
@@ -27,47 +29,48 @@ public class InstanceMutexServiceTest extends RunningServerTest {
 	
 	public static Stream<Arguments> getParams() {
 		return Stream.of(
-			Arguments.of(2, 10, Duration.of(250, ChronoUnit.MILLIS)),
-			Arguments.of(3, 10, Duration.of(250, ChronoUnit.MILLIS)),
-			Arguments.of(5, 10, Duration.of(250, ChronoUnit.MILLIS)),
-			Arguments.of(10, 10, Duration.of(250, ChronoUnit.MILLIS)),
-			Arguments.of(20, 20, Duration.of(150, ChronoUnit.MILLIS))
+			Arguments.of(false, 2, 10, Duration.of(250, ChronoUnit.MILLIS)),
+			Arguments.of(true, 2, 10, Duration.of(250, ChronoUnit.MILLIS)),
+			Arguments.of(false, 3, 10, Duration.of(250, ChronoUnit.MILLIS)),
+			Arguments.of(true, 3, 10, Duration.of(250, ChronoUnit.MILLIS)),
+			Arguments.of(false, 5, 10, Duration.of(250, ChronoUnit.MILLIS)),
+			Arguments.of(true, 5, 10, Duration.of(250, ChronoUnit.MILLIS)),
+			
+			Arguments.of(false, 2, 20, Duration.of(250, ChronoUnit.MILLIS)),
+			Arguments.of(true, 2, 20, Duration.of(250, ChronoUnit.MILLIS)),
+			Arguments.of(false, 3, 20, Duration.of(250, ChronoUnit.MILLIS)),
+			Arguments.of(true, 3, 20, Duration.of(250, ChronoUnit.MILLIS)),
+			Arguments.of(false, 5, 20, Duration.of(250, ChronoUnit.MILLIS)),
+			Arguments.of(true, 5, 20, Duration.of(250, ChronoUnit.MILLIS)),
+			
+			Arguments.of(false, 10, 10, Duration.of(250, ChronoUnit.MILLIS)),
+			Arguments.of(true, 10, 10, Duration.of(250, ChronoUnit.MILLIS)),
+			Arguments.of(false, 20, 20, Duration.of(150, ChronoUnit.MILLIS)),
+			Arguments.of(true, 20, 20, Duration.of(150, ChronoUnit.MILLIS))
 		);
 	}
 	
 	@Inject
 	InstanceMutexService instanceMutexService;
 	
-	@Test
-	public void basicTest() {
-		String mutexId = "testMutex";
-		this.instanceMutexService.register(mutexId);
-		
-		assertTrue(this.instanceMutexService.lock(mutexId));
-		
-		assertFalse(this.instanceMutexService.lock(mutexId));
-		
-		this.instanceMutexService.free(mutexId);
-		
-		assertTrue(this.instanceMutexService.lock(mutexId));
-		this.instanceMutexService.free(mutexId);
-	}
-	
 	
 	@ParameterizedTest
 	@MethodSource("getParams")
-	public void threadTest(int numThreads, int numIterations, Duration workDuration) throws InterruptedException, ExecutionException {
+	public void threadTest(boolean await, int numThreads, int numIterations, Duration workDuration) throws InterruptedException, ExecutionException {
 		String mutexId = "testMutex2";
 		List<Future<List<ThreadResult>>> futures = new ArrayList<>(numThreads);
 		SortedSet<ThreadResult> results = new TreeSet<>();
 		ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
+		Duration expectedWaitTime = Duration.of(numThreads * numIterations * workDuration.toMillis(), ChronoUnit.MILLIS);
 		
 		TestThread.TestThreadBuilder threadBuilder = TestThread.builder()
+														 .await(await)
 														 .mutexId(mutexId)
 														 .numIterations(numIterations)
 														 .durationOfWork(workDuration)
 														 .instanceMutexService(instanceMutexService);
 		
+		StopWatch overall = StopWatch.createStarted();
 		for (int i = 1; i <= numThreads; i++) {
 			threadBuilder.threadId("testThread-" + i);
 			
@@ -81,6 +84,7 @@ public void threadTest(int numThreads, int numIterations, Duration workDuration)
 		for (Future<List<ThreadResult>> future : futures) {
 			results.addAll(future.get());
 		}
+		overall.stop();
 		
 		assertEquals(numIterations * numThreads, results.size());
 		
@@ -104,6 +108,9 @@ public void threadTest(int numThreads, int numIterations, Duration workDuration)
 			cur = next;
 		}
 		
+		Duration expectedVsActualTimeDiff = overall.getDuration().minus(expectedWaitTime);
+		log.info("Perfect efficiency vs actual time: {} vs {} (difference: {})", expectedWaitTime, overall.getDuration(), expectedVsActualTimeDiff);
+		
 	}
 	
 	@Builder
@@ -127,6 +134,7 @@ public int compareTo(@NonNull InstanceMutexServiceTest.ThreadResult threadResult
 	@AllArgsConstructor
 	static class TestThread implements Callable<List<ThreadResult>> {
 		
+		private boolean await;
 		private String mutexId;
 		private String threadId;
 		private InstanceMutexService instanceMutexService;
@@ -138,18 +146,21 @@ static class TestThread implements Callable<List<ThreadResult>> {
 		public List<ThreadResult> call() {
 			log.info("Running test thread {}", this.threadId);
 			
-			Random rand = new Random();
+			Optional<String> threadIdOpt = Optional.ofNullable(this.threadId);
 			
 			this.instanceMutexService.register(this.mutexId);
 			
-			//			Thread.sleep(500);
-			
 			List<ThreadResult> results = new ArrayList<>(this.numIterations);
 			for (int i = 1; i <= this.numIterations; i++) {
 				log.info("Thread {} waiting for lock on iteration {}", this.threadId, i);
-				while (!instanceMutexService.lock(this.mutexId, Optional.of(this.threadId))) {
-					//noinspection BusyWait
-					Thread.sleep(rand.nextInt(0, 50));
+				
+				if(await){
+					instanceMutexService.awaitLock(this.mutexId, threadIdOpt);
+				} else {
+					//noinspection StatementWithEmptyBody
+					while (!instanceMutexService.lock(this.mutexId, threadIdOpt)) {
+						//nothing to do
+					}
 				}
 				log.info("Thread {} got lock on iteration {}/{}", this.threadId, i, this.numIterations);
 				ThreadResult.ThreadResultBuilder resultBuilder = ThreadResult.builder()
@@ -160,7 +171,8 @@ public List<ThreadResult> call() {
 				
 				resultBuilder.end(LocalDateTime.now());
 				
-				this.instanceMutexService.free(this.mutexId, Optional.of(this.threadId));
+				assertTrue(this.instanceMutexService.free(this.mutexId, Optional.of(this.threadId)));
+				
 				log.info("Thread {} done doing work & released lock on iteration {}", this.threadId, i);
 				results.add(resultBuilder.build());
 			}
@@ -169,6 +181,21 @@ public List<ThreadResult> call() {
 		}
 	}
 	
+	@Test
+	public void basicTest() {
+		String mutexId = "testMutex";
+		this.instanceMutexService.register(mutexId);
+		
+		assertTrue(this.instanceMutexService.lock(mutexId));
+		
+		assertFalse(this.instanceMutexService.lock(mutexId));
+		
+		assertTrue(this.instanceMutexService.free(mutexId));
+		
+		assertTrue(this.instanceMutexService.lock(mutexId));
+		this.instanceMutexService.free(mutexId);
+	}
+	
 	@Test
 	public void testWithResources() throws InterruptedException {
 		String id = "testWithResources";
@@ -181,8 +208,6 @@ public void testWithResources() throws InterruptedException {
 			InstanceMutexService.InstanceMutexResource mutex = this.instanceMutexService.getResource(true, id, Optional.empty())
 		) {
 			log.info("In the critical section, 1");
-		} catch(IOException e) {
-			throw new RuntimeException(e);
 		}
 		
 		log.info("In between mutex try-with-resources");
@@ -191,8 +216,6 @@ public void testWithResources() throws InterruptedException {
 			InstanceMutexService.InstanceMutexResource mutex = this.instanceMutexService.getResource(true, id, Optional.empty())
 		) {
 			log.info("In the critical section, 2");
-		} catch(IOException e) {
-			throw new RuntimeException(e);
 		}
 		
 		log.info("Finished mutex 2");
@@ -217,8 +240,23 @@ public void testSameEntityDoubleLock() {
 		this.instanceMutexService.register(id);
 		
 		assertTrue(this.instanceMutexService.lock(id));
-		assertFalse(this.instanceMutexService.lock(id, Optional.of("foo")));
 		assertFalse(this.instanceMutexService.lock(id));
+		assertFalse(this.instanceMutexService.lock(id, Optional.of("foo")));
+	}
+	
+	@Test
+	public void testAwaitTimeout() {
+		String id = "testAwaitTimeout";
+		
+		this.instanceMutexService.register(id);
+		
+		assertTrue(this.instanceMutexService.lock(id));
+		
+		assertThrows(
+			MutexWaitTimeoutException.class, () ->{
+				this.instanceMutexService.awaitLock(id, Optional.of("foo"));
+			}
+		);
 	}
 	
 }

From 42f39623f55f531b31a913da036063939351bdd4 Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Wed, 13 May 2026 23:24:11 -0400
Subject: [PATCH 03/48] Core - API - adding mutex to applied transaction
 service / added add handler to mongo services to optionally handle adding
 objects. Used this to create mutex for items.

---
 .../core/api/service/mongo/InventoryItemService.java | 12 ++++++++++++
 .../core/api/service/mongo/MongoObjectService.java   |  5 +++++
 .../transactions/AppliedTransactionService.java      |  9 ++++++++-
 .../service/serviceState/InstanceMutexService.java   |  4 ++++
 4 files changed, 29 insertions(+), 1 deletion(-)

diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/InventoryItemService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/InventoryItemService.java
index 1865278f6..55c0e6671 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/InventoryItemService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/InventoryItemService.java
@@ -18,6 +18,8 @@
 import tech.ebp.oqm.core.api.config.CoreApiInteractingEntity;
 import tech.ebp.oqm.core.api.interfaces.endpoints.inventory.items.StoredInItemEndpoints;
 import tech.ebp.oqm.core.api.model.collectionStats.InvItemCollectionStats;
+import tech.ebp.oqm.core.api.model.object.history.details.HistoryDetail;
+import tech.ebp.oqm.core.api.model.object.interactingEntity.InteractingEntity;
 import tech.ebp.oqm.core.api.model.object.media.Image;
 import tech.ebp.oqm.core.api.model.object.media.file.FileAttachment;
 import tech.ebp.oqm.core.api.model.object.storage.ItemCategory;
@@ -30,6 +32,7 @@
 import tech.ebp.oqm.core.api.service.ItemStatsService;
 import tech.ebp.oqm.core.api.exception.db.DbNotFoundException;
 import tech.ebp.oqm.core.api.service.notification.HistoryEventNotificationService;
+import tech.ebp.oqm.core.api.service.serviceState.InstanceMutexService;
 
 import javax.measure.Quantity;
 import javax.measure.Unit;
@@ -82,6 +85,9 @@ public class InventoryItemService extends MongoHistoriedObjectService<InventoryI
 	@Inject
 	StoredInItemEndpoints storedInItemEndpoints;
 	
+	@Inject
+	InstanceMutexService instanceMutexService;
+	
 	public InventoryItemService() {
 		super(InventoryItem.class, false);
 	}
@@ -275,6 +281,12 @@ public InvItemCollectionStats getStats(String oqmDbIdOrName) {
 				   .build();
 	}
 	
+	@Override
+	protected void handleAdd(InventoryItem object) {
+		super.handleAdd(object);
+		this.instanceMutexService.register(object);
+	}
+	
 	public List<InventoryItem> getItemsInBlock(String oqmDbIdOrName, ObjectId storageBlockId) {
 		return this.list(
 			oqmDbIdOrName,
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/MongoObjectService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/MongoObjectService.java
index 256aa58c1..deb3b1253 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/MongoObjectService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/MongoObjectService.java
@@ -420,6 +420,10 @@ public T update(String oqmDbIdOrName, @Valid T object) throws DbNotFoundExceptio
 		return this.update(oqmDbIdOrName, null, object, false);
 	}
 	
+	protected void handleAdd(T object){
+		//TODO:: nothing to do for default
+	}
+	
 	/**
 	 * Adds an object to the collection. Adds a created history event and the object's new object id to that object in-place.
 	 *
@@ -445,6 +449,7 @@ public T add(String oqmDbIdOrName, ClientSession session, @NonNull @Valid T obje
 		object.setId(result.getInsertedId().asObjectId().getValue());
 		
 		log.info("Added. Id: {}", object.getId());
+		this.handleAdd(object);
 		return object;
 	}
 	
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/AppliedTransactionService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/AppliedTransactionService.java
index 81d75add0..35148d648 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/AppliedTransactionService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/AppliedTransactionService.java
@@ -26,6 +26,7 @@
 import tech.ebp.oqm.core.api.service.mongo.StoredService;
 import tech.ebp.oqm.core.api.service.mongo.transactions.appliers.*;
 import tech.ebp.oqm.core.api.service.mongo.utils.MongoSessionWrapper;
+import tech.ebp.oqm.core.api.service.serviceState.InstanceMutexService;
 
 import java.util.*;
 
@@ -51,6 +52,9 @@ public class AppliedTransactionService extends MongoObjectService<AppliedTransac
 	@Getter
 	Map<TransactionType, TransactionApplier> appliers = new HashMap<>();
 	
+	@Inject
+	InstanceMutexService instanceMutexService;
+	
 	public AppliedTransactionService() {
 		super(AppliedTransaction.class);
 	}
@@ -89,7 +93,10 @@ public <T extends ItemStoredTransaction> AppliedTransaction apply(
 		InteractingEntity interactingEntity,
 		HistoryDetail... details
 	) throws Exception {
-		try (MongoSessionWrapper csw = new MongoSessionWrapper(cs, this)) {
+		try (
+			InstanceMutexService.InstanceMutexResource mutex = this.instanceMutexService.getResource(InstanceMutexService.getMutexIdFor(inventoryItem), Optional.empty());
+			MongoSessionWrapper csw = new MongoSessionWrapper(cs, this)
+		) {
 			return csw.runTransaction(()->{
 				log.info("Applying {} transaction ", itemStoredTransaction.getType());
 				log.debug("Transaction: {}", itemStoredTransaction);
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexService.java
index 4a9177192..2c40bb62c 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexService.java
@@ -138,6 +138,10 @@ public void register(String mutexId) {
 		}
 	}
 	
+	public void register(MainObject object) {
+		this.register(InstanceMutexService.getMutexIdFor(object));
+	}
+	
 	/**
 	 * Locks the mutex with the given id.
 	 * <p>

From 560b4229718d33ac9cbe295de1edbd4466814977 Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Thu, 14 May 2026 22:42:46 -0400
Subject: [PATCH 04/48] Core - API - adding mutex to item updates

---
 .../api/service/mongo/InventoryItemService.java     | 13 +++++++++++++
 .../service/serviceState/InstanceMutexService.java  | 10 +++++++++-
 2 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/InventoryItemService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/InventoryItemService.java
index 55c0e6671..1b7171e72 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/InventoryItemService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/InventoryItemService.java
@@ -287,6 +287,19 @@ protected void handleAdd(InventoryItem object) {
 		this.instanceMutexService.register(object);
 	}
 	
+	@Override
+	public InventoryItem update(String oqmDbIdOrName, ClientSession cs, ObjectId id, ObjectNode updateJson, InteractingEntity interactingEntity, HistoryDetail ... details) {
+		try(
+			InstanceMutexService.InstanceMutexResource mutex = this.instanceMutexService.getResource(InstanceMutexService.getMutexIdFor(InventoryItem.class, id), Optional.empty());
+			){
+			return super.update(oqmDbIdOrName, cs, id, updateJson, interactingEntity, details);
+		} catch(IllegalStateException e){
+			throw new DbNotFoundException(InventoryItem.class, id);
+		} catch(InterruptedException e) {
+			throw new RuntimeException("Failed to acquire mutex for item (interrupted wait)" + id.toHexString(), e);
+		}
+	}
+	
 	public List<InventoryItem> getItemsInBlock(String oqmDbIdOrName, ObjectId storageBlockId) {
 		return this.list(
 			oqmDbIdOrName,
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexService.java
index 2c40bb62c..938e17100 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexService.java
@@ -13,6 +13,7 @@
 import lombok.NonNull;
 import lombok.extern.slf4j.Slf4j;
 import org.bson.conversions.Bson;
+import org.bson.types.ObjectId;
 import tech.ebp.oqm.core.api.config.MutexConfig;
 import tech.ebp.oqm.core.api.exception.MutexWaitTimeoutException;
 import tech.ebp.oqm.core.api.model.InstanceMutex;
@@ -62,11 +63,18 @@
 @Slf4j
 public class InstanceMutexService extends TopLevelMongoService<InstanceMutex, InstanceMutexSearch, CollectionStats> {
 	
+	public static <T extends MainObject> String getMutexIdFor(Class<?> clazz, ObjectId id) {
+		return clazz.getSimpleName() + "-" + id;
+	}
+	
 	public static <T extends MainObject> String getMutexIdFor(T object) {
+		if(object == null) {
+			throw new IllegalArgumentException("Cannot get mutex id for null object");
+		}
 		if (object.getId() == null) {
 			throw new IllegalArgumentException("Cannot get mutex id for object with null id");
 		}
-		return object.getClass().getSimpleName() + "-" + object.getId();
+		return getMutexIdFor(object.getClass(), object.getId());
 	}
 	
 	

From 345174cb2887f6c525d1795f454cd90b8eb22769 Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Thu, 14 May 2026 23:56:06 -0400
Subject: [PATCH 05/48] Lib - Core API for Quarkus - removed now defunct rest
 method

---
 .../runtime/restClient/OqmCoreApiClientService.java    | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/software/libs/core-api-lib-quarkus/runtime/src/main/java/tech/ebp/oqm/lib/core/api/quarkus/runtime/restClient/OqmCoreApiClientService.java b/software/libs/core-api-lib-quarkus/runtime/src/main/java/tech/ebp/oqm/lib/core/api/quarkus/runtime/restClient/OqmCoreApiClientService.java
index a6c746350..c1880605e 100644
--- a/software/libs/core-api-lib-quarkus/runtime/src/main/java/tech/ebp/oqm/lib/core/api/quarkus/runtime/restClient/OqmCoreApiClientService.java
+++ b/software/libs/core-api-lib-quarkus/runtime/src/main/java/tech/ebp/oqm/lib/core/api/quarkus/runtime/restClient/OqmCoreApiClientService.java
@@ -516,16 +516,6 @@ Uni<ObjectNode> invItemStoredGet(
 		@PathParam("storedId") String storedId
 	);
 
-	@PUT
-	@Path(INV_ITEM_STORED_ROOT_ENDPOINT + "/{storedId}")
-	@Produces(MediaType.APPLICATION_JSON)
-	Uni<ObjectNode> invItemStoredUpdate(
-		@HeaderParam(Constants.AUTH_HEADER_NAME) String token,
-		@PathParam("oqmDbIdOrName") String oqmDbIdOrName,
-		@PathParam("storedId") String storedId,
-		ObjectNode updateObject
-	);
-
 	@GET
 	@Path(INV_ITEM_STORED_ROOT_ENDPOINT + "/history")
 	@Produces(MediaType.APPLICATION_JSON)

From 8e5e0ebd3562e4bea21651bb69188ff622754743 Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Fri, 15 May 2026 00:36:20 -0400
Subject: [PATCH 06/48] Core - API - now doing item mutex on stored updates

---
 .../inventory/items/StoredEndpoints.java      | 36 -------------------
 .../items/StoredInItemEndpoints.java          |  8 ++++-
 .../core/api/service/mongo/StoredService.java | 21 ++++++++++-
 3 files changed, 27 insertions(+), 38 deletions(-)

diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/StoredEndpoints.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/StoredEndpoints.java
index ce7d36db2..fb9d3cbdc 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/StoredEndpoints.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/StoredEndpoints.java
@@ -131,42 +131,6 @@ public Stored get(@PathParam("storedItemId") ObjectId id) {
 		return this.applyDefaults(super.get(id));
 	}
 	
-	@PUT
-	@Path("{storedItemId}")
-	@Operation(
-		summary = "Updates a particular stored item. If applicable, amounts are disregarded. Use the transact endpoint to modify amounts, or add/remove stored items",
-		description = "Partial update to a object. Do not need to supply all fields, just the one(s) you wish to update."
-	)
-	@APIResponse(
-		responseCode = "200",
-		description = "Object updated."
-	)
-	@APIResponse(
-		responseCode = "400",
-		description = "Bad request given. Data given could not pass validation.",
-		content = @Content(mediaType = "text/plain")
-	)
-	@APIResponse(
-		responseCode = "404",
-		description = "Bad request given, could not find object at given id.",
-		content = @Content(mediaType = "text/plain")
-	)
-	@APIResponse(
-		responseCode = "410",
-		description = "Object requested has been deleted.",
-		content = @Content(mediaType = "text/plain")
-	)
-	@RolesAllowed(Roles.INVENTORY_EDIT)
-	@Produces(MediaType.APPLICATION_JSON)
-	public Stored update(
-		@PathParam("storedItemId")
-		ObjectId id,
-		@Schema(type = SchemaType.OBJECT, implementation = Stored.class, description = "Partial object updates; supply all or some of values to update.")
-		ObjectNode updates
-	) {
-		return this.applyDefaults(super.update(id, updates));
-	}
-	
 	@GET
 	@Path("{storedItemId}/history")
 	@Operation(
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/StoredInItemEndpoints.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/StoredInItemEndpoints.java
index c2f7ccc9b..8f381da6e 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/StoredInItemEndpoints.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/StoredInItemEndpoints.java
@@ -154,7 +154,13 @@ public Stored update(
 		@Schema(type = SchemaType.OBJECT, implementation = Stored.class, description = "Partial object updates; supply all or some of values to update.")
 		ObjectNode updates
 	) {
-		return this.applyDefaults(super.update(id, updates));
+		log.info("Updating {} from REST interface with id {}", this.getObjectClass().getSimpleName(), id);
+		
+		Stored updated = this.getObjectService().update(this.getOqmDbIdOrName(), null, id, updates, this.getInteractingEntity());
+		
+		log.info("Updated {} with id {}", updated.getClass().getSimpleName(), id);
+		
+		return this.applyDefaults(updated);
 	}
 	
 	@GET
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/StoredService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/StoredService.java
index 2bbe8b189..474d19637 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/StoredService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/StoredService.java
@@ -14,6 +14,8 @@
 import org.jetbrains.annotations.NotNull;
 import tech.ebp.oqm.core.api.config.CoreApiInteractingEntity;
 import tech.ebp.oqm.core.api.model.collectionStats.CollectionStats;
+import tech.ebp.oqm.core.api.model.object.history.details.HistoryDetail;
+import tech.ebp.oqm.core.api.model.object.interactingEntity.InteractingEntity;
 import tech.ebp.oqm.core.api.model.object.storage.items.InventoryItem;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.*;
 import tech.ebp.oqm.core.api.model.rest.search.StoredSearch;
@@ -21,6 +23,7 @@
 import tech.ebp.oqm.core.api.service.mongo.search.ItemAwareSearchResult;
 import tech.ebp.oqm.core.api.service.mongo.search.SearchResult;
 import tech.ebp.oqm.core.api.service.notification.HistoryEventNotificationService;
+import tech.ebp.oqm.core.api.service.serviceState.InstanceMutexService;
 
 import java.util.*;
 
@@ -56,6 +59,9 @@ public class StoredService extends MongoHistoriedObjectService<Stored, StoredSea
 	@Getter(AccessLevel.PRIVATE)
 	HistoryEventNotificationService hens;
 	
+	@Inject
+	InstanceMutexService instanceMutexService;
+	
 	@Override
 	public Set<String> getDisallowedUpdateFields() {
 		Set<String> output = new HashSet<>(super.getDisallowedUpdateFields());
@@ -157,7 +163,7 @@ public void ensureObjectValid(String oqmDbIdOrName, boolean newObject, Stored ne
 	
 	@Override
 	public boolean needsDerivedUpdatesAfterUpdate(@NotNull Stored stored, ObjectNode updates) {
-		
+		//TODO
 		return false;
 	}
 	
@@ -189,6 +195,19 @@ public CollectionStats getStats(String oqmDbIdOrName) {
 				   .build();
 	}
 	
+	public Stored update(String oqmDbIdOrName, ClientSession cs, InventoryItem item, ObjectId id, ObjectNode updateJson, InteractingEntity interactingEntity,
+		HistoryDetail... details) {
+		
+		try(
+			InstanceMutexService.InstanceMutexResource mutex = this.instanceMutexService.getResource(InstanceMutexService.getMutexIdFor(InventoryItem.class, id), Optional.empty());
+		){
+			return super.update(oqmDbIdOrName, cs, id, updateJson, interactingEntity, details);
+		} catch(InterruptedException e) {
+			throw new RuntimeException("Failed to get lock for item; interrupted.", e);
+		}
+	}
+	
+	
 	public <T extends Stored> SearchResult<T> getStoredForItemBlock(String oqmDbIdOrName, ClientSession cs, ObjectId itemId, ObjectId storageBlockId, Class<T> type) {
 		StoredSearch search = new StoredSearch()
 								  .setInventoryItemId(itemId)

From a81fc1085dddbffcb564934b84c6bfe0ea120c0e Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Fri, 15 May 2026 13:30:54 -0400
Subject: [PATCH 07/48] Core - API - version bump for dev

---
 software/core/oqm-core-api/build.gradle                       | 2 +-
 .../core/oqm-core-api/src/test/resources/application.yaml     | 4 +++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/software/core/oqm-core-api/build.gradle b/software/core/oqm-core-api/build.gradle
index dcec7fed9..ff8a46dda 100644
--- a/software/core/oqm-core-api/build.gradle
+++ b/software/core/oqm-core-api/build.gradle
@@ -8,7 +8,7 @@ plugins {
 }
 
 group 'com.ebp.openQuarterMaster'
-version '4.4.7'
+version '4.4.8-SNAPSHOT'
 
 repositories {
 	mavenCentral()
diff --git a/software/core/oqm-core-api/src/test/resources/application.yaml b/software/core/oqm-core-api/src/test/resources/application.yaml
index c7e643f9c..62d02b30a 100644
--- a/software/core/oqm-core-api/src/test/resources/application.yaml
+++ b/software/core/oqm-core-api/src/test/resources/application.yaml
@@ -9,8 +9,10 @@ quarkus:
   http:
     port: 8081
   log:
-    level: TRACE
+    level: INFO
     category:
+      "tech.ebp.oqm":
+        level: TRACE
       "com.github.dockerjava.zerodep.shaded.org.apache.hc.client5.http.wire": # Debug wire transfer statements. Far too much spam of hexadecimal
         level: INFO
   mongodb:

From 53a53dd8beede88faab3881f96e0c55e288ee640 Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Fri, 15 May 2026 13:37:27 -0400
Subject: [PATCH 08/48] Core - API - Organized applied transaction service
 tests

---
 .../mongo/AppliedTransactionServiceTest.java  | 3758 -----------------
 .../AddAmountAppliedTransactionTest.java      |  341 ++
 .../AddWholeAppliedTransactionTest.java       |  293 ++
 .../AppliedTransactionServiceTest.java        |  295 ++
 ...eckinFullAmountAppliedTransactionTest.java |  426 ++
 .../CheckinWholeAppliedTransactionTest.java   |  274 ++
 .../CheckoutAmountAppliedTransactionTest.java |  486 +++
 .../CheckoutWholeAppliedTransactionTest.java  |  272 ++
 .../SetAmountAppliedTransactionTest.java      |  311 ++
 .../SubtractAmountAppliedTransactionTest.java |  491 +++
 .../SubtractWholeAppliedTransactionTest.java  |   45 +
 .../TransferAmountAppliedTransactionTest.java |  726 ++++
 .../TransferWholeAppliedTransactionTest.java  |  276 ++
 13 files changed, 4236 insertions(+), 3758 deletions(-)
 delete mode 100644 software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/AppliedTransactionServiceTest.java
 create mode 100644 software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/AddAmountAppliedTransactionTest.java
 create mode 100644 software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/AddWholeAppliedTransactionTest.java
 create mode 100644 software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/AppliedTransactionServiceTest.java
 create mode 100644 software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/CheckinFullAmountAppliedTransactionTest.java
 create mode 100644 software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/CheckinWholeAppliedTransactionTest.java
 create mode 100644 software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/CheckoutAmountAppliedTransactionTest.java
 create mode 100644 software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/CheckoutWholeAppliedTransactionTest.java
 create mode 100644 software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/SetAmountAppliedTransactionTest.java
 create mode 100644 software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/SubtractAmountAppliedTransactionTest.java
 create mode 100644 software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/SubtractWholeAppliedTransactionTest.java
 create mode 100644 software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/TransferAmountAppliedTransactionTest.java
 create mode 100644 software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/TransferWholeAppliedTransactionTest.java

diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/AppliedTransactionServiceTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/AppliedTransactionServiceTest.java
deleted file mode 100644
index ed5d18ba3..000000000
--- a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/AppliedTransactionServiceTest.java
+++ /dev/null
@@ -1,3758 +0,0 @@
-
-package tech.ebp.oqm.core.api.service.mongo;
-
-import com.fasterxml.jackson.core.JsonProcessingException;
-import io.quarkus.test.common.QuarkusTestResource;
-import io.quarkus.test.junit.QuarkusTest;
-import io.quarkus.test.kafka.InjectKafkaCompanion;
-import io.quarkus.test.kafka.KafkaCompanionResource;
-import io.smallrye.reactive.messaging.kafka.companion.ConsumerTask;
-import io.smallrye.reactive.messaging.kafka.companion.KafkaCompanion;
-import jakarta.inject.Inject;
-import jakarta.validation.ValidationException;
-import lombok.Getter;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.kafka.common.errors.UnknownTopicOrPartitionException;
-import org.bson.types.ObjectId;
-import org.junit.jupiter.api.Test;
-import tech.ebp.oqm.core.api.model.object.ObjectUtils;
-import tech.ebp.oqm.core.api.model.object.history.EventType;
-import tech.ebp.oqm.core.api.model.object.history.ObjectHistoryEvent;
-import tech.ebp.oqm.core.api.model.object.history.details.ItemTransactionDetail;
-import tech.ebp.oqm.core.api.model.object.history.events.CreateEvent;
-import tech.ebp.oqm.core.api.model.object.history.events.DeleteEvent;
-import tech.ebp.oqm.core.api.model.object.history.events.ReCreateEvent;
-import tech.ebp.oqm.core.api.model.object.history.events.UpdateEvent;
-import tech.ebp.oqm.core.api.model.object.interactingEntity.InteractingEntity;
-import tech.ebp.oqm.core.api.model.object.storage.checkout.CheckoutDetails;
-import tech.ebp.oqm.core.api.model.object.storage.checkout.ItemAmountCheckout;
-import tech.ebp.oqm.core.api.model.object.storage.checkout.ItemCheckout;
-import tech.ebp.oqm.core.api.model.object.storage.checkout.ItemWholeCheckout;
-import tech.ebp.oqm.core.api.model.object.storage.checkout.checkinDetails.ReturnFullCheckinDetails;
-import tech.ebp.oqm.core.api.model.object.storage.checkout.checkinDetails.checkedInBy.CheckedInByOqmEntity;
-import tech.ebp.oqm.core.api.model.object.storage.checkout.checkoutFor.CheckoutForOqmEntity;
-import tech.ebp.oqm.core.api.model.object.storage.items.InventoryItem;
-import tech.ebp.oqm.core.api.model.object.storage.items.StorageType;
-import tech.ebp.oqm.core.api.model.object.storage.items.stored.AmountStored;
-import tech.ebp.oqm.core.api.model.object.storage.items.stored.Stored;
-import tech.ebp.oqm.core.api.model.object.storage.items.stored.UniqueStored;
-import tech.ebp.oqm.core.api.model.object.storage.items.transactions.AppliedTransaction;
-import tech.ebp.oqm.core.api.model.object.storage.items.transactions.ItemStoredTransaction;
-import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.add.AddAmountTransaction;
-import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.add.AddWholeTransaction;
-import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.checkin.CheckinFullTransaction;
-import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.checkout.CheckoutAmountTransaction;
-import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.checkout.CheckoutWholeTransaction;
-import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.set.SetAmountTransaction;
-import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.subtract.SubAmountTransaction;
-import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.transfer.TransferAmountTransaction;
-import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.transfer.TransferWholeTransaction;
-import tech.ebp.oqm.core.api.model.object.storage.storageBlock.StorageBlock;
-import tech.ebp.oqm.core.api.model.rest.search.HistorySearch;
-import tech.ebp.oqm.core.api.model.rest.search.ItemCheckoutSearch;
-import tech.ebp.oqm.core.api.model.rest.search.StoredSearch;
-import tech.ebp.oqm.core.api.service.mongo.search.SearchResult;
-import tech.ebp.oqm.core.api.service.mongo.transactions.AppliedTransactionService;
-import tech.ebp.oqm.core.api.model.messaging.EventNotificationWrapper;
-import tech.ebp.oqm.core.api.service.notification.HistoryEventNotificationService;
-import tech.ebp.oqm.core.api.testResources.data.InventoryItemTestObjectCreator;
-import tech.ebp.oqm.core.api.testResources.data.StorageBlockTestObjectCreator;
-import tech.ebp.oqm.core.api.testResources.testClasses.KafkaTest;
-import tech.ebp.oqm.core.api.testResources.testClasses.MongoObjectServiceTest;
-import tech.units.indriya.quantity.Quantities;
-
-import java.time.ZonedDateTime;
-import java.util.List;
-import java.util.stream.Collectors;
-
-import static org.junit.jupiter.api.Assertions.*;
-import static tech.ebp.oqm.core.api.model.object.history.details.HistoryDetailType.ITEM_TRANSACTION;
-import static tech.ebp.oqm.core.api.testResources.TestConstants.DEFAULT_TEST_DB_NAME;
-
-/**
- * TODO:: rework to test each class individually, test nominally here
- */
-@Slf4j
-@QuarkusTest
-@QuarkusTestResource(value = KafkaCompanionResource.class, restrictToAnnotatedClass = true)
-class AppliedTransactionServiceTest extends MongoObjectServiceTest<AppliedTransaction, AppliedTransactionService> implements KafkaTest {
-	
-	@Inject
-	AppliedTransactionService appliedTransactionService;
-	
-	@Inject
-	StorageBlockService storageBlockService;
-	
-	@Inject
-	StorageBlockTestObjectCreator storageBlockTestObjectCreator;
-	
-	@Inject
-	InventoryItemService inventoryItemService;
-	
-	@Inject
-	InventoryItemTestObjectCreator itemTestObjectCreator;
-	
-	@Inject
-	StoredService storedService;
-	
-	@Inject
-	ItemCheckoutService checkoutService;
-	
-	@Getter
-	@InjectKafkaCompanion
-	KafkaCompanion kafkaCompanion;
-	
-	//TODO:: these default tests
-	@Override
-	protected AppliedTransaction getTestObject() {
-		return null;//TODO
-	}
-	//
-	//	@Test
-	//	public void injectTest() {
-	//		assertNotNull(appliedTransactionService);
-	//	}
-	//
-	//	@Test
-	//	public void listTest() {
-	//		this.defaultListTest(this.appliedTransactionService);
-	//	}
-	//
-	//	@Test
-	//	public void countTest() {
-	//		this.defaultCountTest(this.appliedTransactionService);
-	//	}
-	//
-	//	@Test
-	//	public void addTest() {
-	//		this.defaultAddTest(this.appliedTransactionService);
-	//	}
-	//
-	//	@Test
-	//	public void getObjectIdTest() {
-	//		this.defaultGetObjectIdTest(this.appliedTransactionService);
-	//	}
-	//
-	//	@Test
-	//	public void getStringTest() {
-	//		this.defaultGetStringTest(this.appliedTransactionService);
-	//	}
-	//
-	//	@Test
-	//	public void removeAllTest() {
-	//		this.defaultRemoveAllTest(this.appliedTransactionService);
-	//	}
-	
-	
-	private InventoryItem setupItem(StorageType storageType, InteractingEntity entity) {
-		StorageBlock storageBlock = storageBlockTestObjectCreator.getTestObject();
-		this.storageBlockService.add(DEFAULT_TEST_DB_NAME, storageBlock, entity);
-		InventoryItem item = this.itemTestObjectCreator.getTestObject().setStorageType(storageType);
-		item.getStorageBlocks().add(storageBlock.getId());
-		this.inventoryItemService.add(DEFAULT_TEST_DB_NAME, item, entity);
-		return item;
-	}
-	
-	private void clearQueues() {
-		this.kafkaCompanion
-			.topics()
-			.delete(HistoryEventNotificationService.ALL_EVENT_TOPIC)
-		//			.clear(HistoryEventNotificationService.ALL_EVENT_TOPIC)
-		;
-	}
-	
-	//TODO:: this with all following tests
-	private List<EventNotificationWrapper> assertMessages(
-		EventType... expectedEvents
-	) throws JsonProcessingException {
-		//TODO:: get list of all sent messages instead of predicted number
-		//		List<EventNotificationWrapper> eventWrappers = new ArrayList<>();
-		//		boolean awaiting = true;
-		//		do{
-		//			try {
-		//				eventWrappers.add(
-		//					ObjectUtils.OBJECT_MAPPER.readValue(
-		//						this.kafkaCompanion.consumeStrings()
-		//							.fromTopics(HistoryEventNotificationService.ALL_EVENT_TOPIC, 1)
-		//							.awaitCompletion(Duration.of(10, ChronoUnit.SECONDS))
-		//							.getFirstRecord().value(),
-		//
-		//
-		////						this.kafkaCompanion.consumeStrings()
-		////							.fromTopics(HistoryEventNotificationService.ALL_EVENT_TOPIC)
-		////							.awaitNextRecord(Duration.of(10, ChronoUnit.SECONDS))
-		//////							.stream().findFirst().get().value(),
-		//////							.getFirstRecord().value(),
-		//						EventNotificationWrapper.class
-		//					)
-		//				);
-		//				log.info("Got another wrapper");
-		//			} catch (AssertionError e){
-		//				awaiting = false;
-		//			}
-		//		}while(awaiting);
-		
-		
-		try {
-			
-			ConsumerTask<String, String> messagesFromAll = this.kafkaCompanion.consumeStrings().fromTopics(
-				HistoryEventNotificationService.ALL_EVENT_TOPIC
-				, expectedEvents.length
-			);
-			messagesFromAll.awaitCompletion();
-			assertEquals(expectedEvents.length, messagesFromAll.count());
-			
-			List<EventNotificationWrapper> eventWrappers = messagesFromAll.stream()
-															   .map(record->{
-																   try {
-																	   return ObjectUtils.OBJECT_MAPPER.readValue(record.value(), EventNotificationWrapper.class);
-																   } catch(JsonProcessingException e) {
-																	   throw new RuntimeException(e);
-																   }
-															   })
-															   .collect(Collectors.toList());
-			log.info("Found messages for transaction: {}", eventWrappers);
-			
-			assertEquals(expectedEvents.length, eventWrappers.size());
-			
-			for (int i = 0; i < expectedEvents.length; i++) {
-				EventNotificationWrapper curWrapper = eventWrappers.get(i);
-				EventType expectedType = expectedEvents[i];
-				
-				assertEquals(expectedType, curWrapper.getEvent().getType(), "Unexpected type of transaction at index " + i);
-			}
-			
-			return eventWrappers;
-		} catch(UnknownTopicOrPartitionException e) {
-			log.warn("Failed to clear queues", e);
-			throw e;
-		}
-	}
-	
-	
-	//<editor-fold desc="Apply- Add Amount">
-	@Test
-	public void applyAddAmountSuccessBulkNotInBlock() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.BULK, entity);
-		
-		
-		ItemStoredTransaction preApplyTransaction = AddAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.toBlock(item.getStorageBlocks().getFirst())
-														.build();
-		
-		try {
-			this.clearQueues();
-		} catch(UnknownTopicOrPartitionException e) {
-			log.warn("Failed to clear queues", e);
-		}
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(1, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		
-		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(5, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 1);
-		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
-		
-		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
-		assertEquals(storedFromSearch, stored);
-		assertEquals(Quantities.getQuantity(5, item.getUnit()), stored.getAmount());
-		
-		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
-		assertFalse(storedHistory.isEmpty());
-		UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
-		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-		
-		//TODO:: this, #1080
-//		List<EventNotificationWrapper> messages = this.assertMessages(
-//			EventType.CREATE,
-//			EventType.UPDATE
-//		);
-		//TODO:: verify messages
-	}
-	
-	@Test
-	public void applyAddAmountSuccessBulkAlreadyInBlock() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.BULK, entity);
-		
-		AmountStored originalStored = AmountStored.builder()
-										  .item(item.getId())
-										  .storageBlock(item.getStorageBlocks().getFirst())
-										  .amount(Quantities.getQuantity(5, item.getUnit()))
-										  .build();
-		this.storedService.add(DEFAULT_TEST_DB_NAME, originalStored, entity);
-		
-		
-		ItemStoredTransaction preApplyTransaction = AddAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.toBlock(item.getStorageBlocks().getFirst())
-														.build();
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(1, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(10, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 1);
-		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
-		
-		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
-		assertEquals(originalStored.getId(), stored.getId());
-		assertEquals(storedFromSearch, stored);
-		assertEquals(Quantities.getQuantity(10, item.getUnit()), stored.getAmount());
-		
-		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
-		assertFalse(storedHistory.isEmpty());
-		UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
-		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-	}
-	
-	@Test
-	public void applyAddAmountSuccessAmtListNewEntry() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
-		
-		ItemStoredTransaction preApplyTransaction = AddAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.toBlock(item.getStorageBlocks().getFirst())
-														.build();
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(1, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(5, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 1);
-		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
-		
-		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
-		assertEquals(storedFromSearch, stored);
-		assertEquals(Quantities.getQuantity(5, item.getUnit()), stored.getAmount());
-		
-		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
-		assertFalse(storedHistory.isEmpty());
-		UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
-		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-	}
-	
-	@Test
-	public void applyAddAmountSuccessAmtListExistingStored() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
-		
-		AmountStored originalStored = AmountStored.builder()
-										  .item(item.getId())
-										  .storageBlock(item.getStorageBlocks().getFirst())
-										  .amount(Quantities.getQuantity(5, item.getUnit()))
-										  .build();
-		this.storedService.add(DEFAULT_TEST_DB_NAME, originalStored, entity);
-		
-		
-		ItemStoredTransaction preApplyTransaction = AddAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.toBlock(item.getStorageBlocks().getFirst())
-														.toStored(originalStored.getId())
-														.build();
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(1, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(10, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 1);
-		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
-		
-		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
-		assertEquals(originalStored.getId(), stored.getId());
-		assertEquals(storedFromSearch, stored);
-		assertEquals(Quantities.getQuantity(10, item.getUnit()), stored.getAmount());
-		
-		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
-		assertFalse(storedHistory.isEmpty());
-		UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
-		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-	}
-	
-	@Test
-	public void applyAddAmountFailUniqueMulti() {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.UNIQUE_MULTI, entity);
-		
-		ItemStoredTransaction preApplyTransaction = AddAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.toBlock(item.getStorageBlocks().getFirst())
-														.build();
-		
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("Cannot add an amount to a unique item.", e.getMessage());
-	}
-	
-	@Test
-	public void applyAddAmountFailUniqueSingle() {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.UNIQUE_SINGLE, entity);
-		
-		ItemStoredTransaction preApplyTransaction = AddAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.toBlock(item.getStorageBlocks().getFirst())
-														.build();
-		
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("Cannot add an amount to a unique item.", e.getMessage());
-	}
-	
-	@Test
-	public void applyAddAmountFailBulkBlockNotInInventory() {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.BULK, entity);
-		
-		ObjectId badBlockId = new ObjectId();
-		ItemStoredTransaction preApplyTransaction = AddAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.toBlock(badBlockId)
-														.build();
-		
-		ValidationException e = assertThrows(ValidationException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("Storage block " + badBlockId + " not used to hold this item (" + item.getId().toHexString() + ").", e.getMessage());
-	}
-	
-	@Test
-	public void applyAddAmountFailBulkStoredNotInBlock() {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.BULK, entity);
-		
-		ObjectId badStoredId = new ObjectId();
-		ItemStoredTransaction preApplyTransaction = AddAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.toStored(badStoredId)
-														.toBlock(item.getStorageBlocks().getFirst())
-														.build();
-		
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("To Stored given does not match stored found in block.", e.getMessage());
-	}
-	
-	@Test
-	public void applyAddAmountFailAmtListBadStored() {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
-		
-		ObjectId badStoredId = new ObjectId();
-		ItemStoredTransaction preApplyTransaction = AddAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.toStored(badStoredId)
-														.toBlock(item.getStorageBlocks().getFirst())
-														.build();
-		
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("Could not find Stored with id " + badStoredId, e.getMessage());
-	}
-	
-	@Test
-	public void applyAddAmountFailAmtListBadStoredNotInBlock() {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
-		
-		ObjectId origBlock = item.getStorageBlocks().getFirst();
-		ObjectId otherBlockId = this.storageBlockService.add(DEFAULT_TEST_DB_NAME, StorageBlock.builder().label(FAKER.location().building()).build(), entity).getId();
-		
-		item.getStorageBlocks().add(otherBlockId);
-		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
-		
-		AmountStored originalStored = AmountStored.builder()
-										  .item(item.getId())
-										  .storageBlock(origBlock)
-										  .amount(Quantities.getQuantity(5, item.getUnit()))
-										  .build();
-		this.storedService.add(DEFAULT_TEST_DB_NAME, originalStored, entity);
-		
-		ItemStoredTransaction preApplyTransaction = AddAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.toStored(originalStored.getId())
-														.toBlock(otherBlockId)
-														.build();
-		
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("To Stored given does not exist in block.", e.getMessage());
-	}
-	
-	//TODO:: any more?
-	//</editor-fold>
-	//<editor-fold desc="Apply- Add Whole">
-	
-	@Test
-	public void applyAddWholeSuccessAmtList() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
-		
-		ItemStoredTransaction preApplyTransaction = AddWholeTransaction.builder()
-														.toAdd(
-															AmountStored.builder()
-																.item(item.getId())
-																.amount(Quantities.getQuantity(5, item.getUnit()))
-																.storageBlock(item.getStorageBlocks().getFirst())
-																.build()
-														)
-														.toBlock(item.getStorageBlocks().getFirst())
-														.build();
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(1, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(5, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 1);
-		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
-		
-		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
-		assertEquals(storedFromSearch, stored);
-		assertEquals(Quantities.getQuantity(5, item.getUnit()), stored.getAmount());
-		
-		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
-		assertFalse(storedHistory.isEmpty());
-		CreateEvent event = (CreateEvent) storedHistory.getResults().getFirst();
-		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-	}
-	
-	@Test
-	public void applyAddWholeSuccessUniqueMulti() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.UNIQUE_MULTI, entity);
-		
-		ItemStoredTransaction preApplyTransaction = AddWholeTransaction.builder()
-														.toAdd(
-															UniqueStored.builder()
-																.item(item.getId())
-																.storageBlock(item.getStorageBlocks().getFirst())
-																.build()
-														)
-														.toBlock(item.getStorageBlocks().getFirst())
-														.build();
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(1, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(1, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 1);
-		UniqueStored storedFromSearch = (UniqueStored) storedSearchResult.getResults().getFirst();
-		
-		UniqueStored stored = (UniqueStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
-		assertEquals(storedFromSearch, stored);
-		
-		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
-		assertFalse(storedHistory.isEmpty());
-		CreateEvent event = (CreateEvent) storedHistory.getResults().getFirst();
-		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-	}
-	
-	@Test
-	public void applyAddWholeSuccessUniqueSingle() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.UNIQUE_SINGLE, entity);
-		
-		ItemStoredTransaction preApplyTransaction = AddWholeTransaction.builder()
-														.toAdd(
-															UniqueStored.builder()
-																.item(item.getId())
-																.storageBlock(item.getStorageBlocks().getFirst())
-																.build()
-														)
-														.toBlock(item.getStorageBlocks().getFirst())
-														.build();
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(1, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(1, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 1);
-		UniqueStored storedFromSearch = (UniqueStored) storedSearchResult.getResults().getFirst();
-		
-		UniqueStored stored = (UniqueStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
-		assertEquals(storedFromSearch, stored);
-		
-		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
-		assertFalse(storedHistory.isEmpty());
-		CreateEvent event = (CreateEvent) storedHistory.getResults().getFirst();
-		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-	}
-	
-	@Test
-	public void applyAddWholeFailBulk() {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.BULK, entity);
-		
-		ItemStoredTransaction preApplyTransaction = AddWholeTransaction.builder()
-														.toAdd(
-															AmountStored.builder()
-																.item(item.getId())
-																.amount(Quantities.getQuantity(5, item.getUnit()))
-																.storageBlock(item.getStorageBlocks().getFirst())
-																.build()
-														)
-														.toBlock(item.getStorageBlocks().getFirst())
-														.build();
-		
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("Cannot add whole item to a bulk storage typed item.", e.getMessage());
-	}
-	
-	@Test
-	public void applyAddWholeFailAnotherUniqueSingle() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.UNIQUE_SINGLE, entity);
-		
-		ItemStoredTransaction preApplyTransaction = AddWholeTransaction.builder()
-														.toAdd(
-															UniqueStored.builder()
-																.item(item.getId())
-																.storageBlock(item.getStorageBlocks().getFirst())
-																.build()
-														)
-														.toBlock(item.getStorageBlocks().getFirst())
-														.build();
-		
-		this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		ValidationException e = assertThrows(ValidationException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("Cannot add more than one stored held for type UNIQUE_SINGLE", e.getMessage());
-	}
-	
-	@Test
-	public void applyAddWholeFailMismatchedBlock() {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.UNIQUE_SINGLE, entity);
-		
-		ItemStoredTransaction preApplyTransaction = AddWholeTransaction.builder()
-														.toAdd(
-															UniqueStored.builder()
-																.item(item.getId())
-																.storageBlock(new ObjectId())
-																.build()
-														)
-														.toBlock(item.getStorageBlocks().getFirst())
-														.build();
-		
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("To Block given does not match block marked in stored.", e.getMessage());
-		
-		ItemStoredTransaction preApplyTransaction2 = AddWholeTransaction.builder()
-														 .toAdd(
-															 UniqueStored.builder()
-																 .item(item.getId())
-																 .storageBlock(item.getStorageBlocks().getFirst())
-																 .build()
-														 )
-														 .toBlock(new ObjectId())
-														 .build();
-		
-		e = assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction2, entity));
-		assertEquals("To Block given does not match block marked in stored.", e.getMessage());
-	}
-	
-	@Test
-	public void applyAddWholeFailBlockNotInItem() {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.UNIQUE_SINGLE, entity);
-		
-		ItemStoredTransaction preApplyTransaction = AddWholeTransaction.builder()
-														.toAdd(
-															UniqueStored.builder()
-																.item(item.getId())
-																.storageBlock(new ObjectId())
-																.build()
-														)
-														.toBlock(item.getStorageBlocks().getFirst())
-														.build();
-		
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("To Block given does not match block marked in stored.", e.getMessage());
-	}
-	
-	@Test
-	public void applyAddWholeFailItemMismatched() {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.UNIQUE_SINGLE, entity);
-		
-		ItemStoredTransaction preApplyTransaction = AddWholeTransaction.builder()
-														.toAdd(
-															UniqueStored.builder()
-																.item(new ObjectId())
-																.storageBlock(item.getStorageBlocks().getFirst())
-																.build()
-														)
-														.toBlock(item.getStorageBlocks().getFirst())
-														.build();
-		
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("Stored given is not associated with item.", e.getMessage());
-	}
-	
-	//TODO:: any more?
-	//</editor-fold>
-	//<editor-fold desc="Apply- Checkin Full">
-	@Test
-	public void applyCheckinFullAmountSuccessBulkToBlock() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.BULK, entity);
-		ObjectId blockId = item.getStorageBlocks().getFirst();
-		
-		AmountStored initialStored = AmountStored.builder()
-										 .item(item.getId())
-										 .storageBlock(blockId)
-										 .amount(Quantities.getQuantity(5, item.getUnit()))
-										 .build();
-		this.storedService.add(DEFAULT_TEST_DB_NAME, initialStored, entity);
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(
-			DEFAULT_TEST_DB_NAME, null, item,
-			CheckoutAmountTransaction.builder()
-				.fromStored(initialStored.getId())
-				.amount(Quantities.getQuantity(4, item.getUnit()))
-				.checkoutDetails(CheckoutDetails.builder().checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build()).build())
-				.build(),
-			entity
-		);
-		ObjectId checkoutId =
-			this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setCheckOutTransaction(appliedTransaction.getId()))
-				.getResults()
-				.getFirst()
-				.getId();
-		//		AppliedTransaction checkoutTransactionId = this.appliedTransactionService.get(DEFAULT_TEST_DB_NAME, appliedTransactionId);
-		
-		ReturnFullCheckinDetails
-			details =
-			ReturnFullCheckinDetails.builder().notes(FAKER.lorem().paragraph()).checkedInBy(CheckedInByOqmEntity.builder().entity(entity.getId()).build()).build();
-		ItemStoredTransaction preApplyTransaction = CheckinFullTransaction.builder()
-														.checkoutId(checkoutId)
-														.toBlock(blockId)
-														.details(details)
-														.build();
-		
-		appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(1, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(5, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 1);
-		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
-		
-		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
-		assertEquals(storedFromSearch, stored);
-		assertEquals(Quantities.getQuantity(5, item.getUnit()), stored.getAmount());
-		
-		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
-		assertFalse(storedHistory.isEmpty());
-		UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
-		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-		
-		
-		SearchResult<ItemCheckout>
-			checkoutSearch =
-			this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setStillCheckedOut(false).setItemCheckedOut(item.getId()));
-		assertEquals(checkoutSearch.getNumResults(), 1);
-		ItemAmountCheckout resultingCheckout = (ItemAmountCheckout) checkoutSearch.getResults().getFirst();
-		
-		assertEquals(appliedTransaction.getId(), resultingCheckout.getCheckInTransaction());
-		assertEquals(details, resultingCheckout.getCheckInDetails());
-	}
-	
-	@Test
-	public void applyCheckinFullAmountSuccessBulkToBlockWithoutStored() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.BULK, entity);
-		ObjectId origBlockId = item.getStorageBlocks().getFirst();
-		ObjectId newBlockId = this.storageBlockService.add(DEFAULT_TEST_DB_NAME, StorageBlock.builder().label(FAKER.location().building()).build(), entity).getId();
-		item.getStorageBlocks().add(newBlockId);
-		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
-		
-		AmountStored initialStored = AmountStored.builder()
-										 .item(item.getId())
-										 .storageBlock(origBlockId)
-										 .amount(Quantities.getQuantity(5, item.getUnit()))
-										 .build();
-		this.storedService.add(DEFAULT_TEST_DB_NAME, initialStored, entity);
-		
-		ObjectId checkoutTransactionId = this.appliedTransactionService.apply(
-			DEFAULT_TEST_DB_NAME, null, item,
-			CheckoutAmountTransaction.builder()
-				.fromStored(initialStored.getId())
-				.amount(Quantities.getQuantity(4, item.getUnit()))
-				.checkoutDetails(CheckoutDetails.builder().checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build()).build())
-				.build(),
-			entity
-		).getId();
-		ObjectId
-			checkoutId =
-			this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setCheckOutTransaction(checkoutTransactionId)).getResults().getFirst().getId();
-		//		AppliedTransaction checkoutTransactionId = this.appliedTransactionService.get(DEFAULT_TEST_DB_NAME, appliedTransactionId);
-		
-		ReturnFullCheckinDetails
-			details =
-			ReturnFullCheckinDetails.builder().notes(FAKER.lorem().paragraph()).checkedInBy(CheckedInByOqmEntity.builder().entity(entity.getId()).build()).build();
-		ItemStoredTransaction preApplyTransaction = CheckinFullTransaction.builder()
-														.checkoutId(checkoutId)
-														.toBlock(newBlockId)
-														.details(details)
-														.build();
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(1, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		assertEquals(2, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(5, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 2);
-		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
-		
-		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
-		assertEquals(storedFromSearch, stored);
-		assertEquals(Quantities.getQuantity(4, item.getUnit()), stored.getAmount());
-		
-		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
-		assertFalse(storedHistory.isEmpty());
-		UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
-		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-		
-		
-		SearchResult<ItemCheckout>
-			checkoutSearch =
-			this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setStillCheckedOut(false).setItemCheckedOut(item.getId()));
-		assertEquals(checkoutSearch.getNumResults(), 1);
-		ItemAmountCheckout resultingCheckout = (ItemAmountCheckout) checkoutSearch.getResults().getFirst();
-		
-		assertEquals(appliedTransaction.getId(), resultingCheckout.getCheckInTransaction());
-		assertEquals(details, resultingCheckout.getCheckInDetails());
-	}
-	
-	@Test
-	public void applyCheckinFullAmountSuccessBulkToStored() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.BULK, entity);
-		ObjectId blockId = item.getStorageBlocks().getFirst();
-		
-		AmountStored initialStored = AmountStored.builder()
-										 .item(item.getId())
-										 .storageBlock(blockId)
-										 .amount(Quantities.getQuantity(5, item.getUnit()))
-										 .build();
-		this.storedService.add(DEFAULT_TEST_DB_NAME, initialStored, entity);
-		
-		ObjectId checkoutTransactionId = this.appliedTransactionService.apply(
-			DEFAULT_TEST_DB_NAME, null, item,
-			CheckoutAmountTransaction.builder()
-				.fromStored(initialStored.getId())
-				.amount(Quantities.getQuantity(4, item.getUnit()))
-				.checkoutDetails(CheckoutDetails.builder().checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build()).build())
-				.build(),
-			entity
-		).getId();
-		ObjectId
-			checkoutId =
-			this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setCheckOutTransaction(checkoutTransactionId)).getResults().getFirst().getId();
-		//		AppliedTransaction checkoutTransactionId = this.appliedTransactionService.get(DEFAULT_TEST_DB_NAME, appliedTransactionId);
-		
-		ReturnFullCheckinDetails
-			details =
-			ReturnFullCheckinDetails.builder().notes(FAKER.lorem().paragraph()).checkedInBy(CheckedInByOqmEntity.builder().entity(entity.getId()).build()).build();
-		ItemStoredTransaction preApplyTransaction = CheckinFullTransaction.builder()
-														.checkoutId(checkoutId)
-														.toStored(initialStored.getId())
-														.details(details)
-														.build();
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(1, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(5, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 1);
-		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
-		
-		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
-		assertEquals(storedFromSearch, stored);
-		assertEquals(Quantities.getQuantity(5, item.getUnit()), stored.getAmount());
-		
-		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
-		assertFalse(storedHistory.isEmpty());
-		UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
-		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-		
-		
-		SearchResult<ItemCheckout>
-			checkoutSearch =
-			this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setStillCheckedOut(false).setItemCheckedOut(item.getId()));
-		assertEquals(checkoutSearch.getNumResults(), 1);
-		ItemAmountCheckout resultingCheckout = (ItemAmountCheckout) checkoutSearch.getResults().getFirst();
-		
-		assertEquals(appliedTransaction.getId(), resultingCheckout.getCheckInTransaction());
-		assertEquals(details, resultingCheckout.getCheckInDetails());
-	}
-	
-	@Test
-	public void applyCheckinFullAmountSuccessAmtListToStored() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
-		ObjectId blockId = item.getStorageBlocks().getFirst();
-		
-		AmountStored initialStored = AmountStored.builder()
-										 .item(item.getId())
-										 .storageBlock(blockId)
-										 .amount(Quantities.getQuantity(5, item.getUnit()))
-										 .build();
-		this.storedService.add(DEFAULT_TEST_DB_NAME, initialStored, entity);
-		
-		ObjectId checkoutTransactionId = this.appliedTransactionService.apply(
-			DEFAULT_TEST_DB_NAME, null, item,
-			CheckoutAmountTransaction.builder()
-				.fromStored(initialStored.getId())
-				.amount(Quantities.getQuantity(4, item.getUnit()))
-				.checkoutDetails(CheckoutDetails.builder().checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build()).build())
-				.build(),
-			entity
-		).getId();
-		ObjectId
-			checkoutId =
-			this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setCheckOutTransaction(checkoutTransactionId)).getResults().getFirst().getId();
-		//		AppliedTransaction checkoutTransactionId = this.appliedTransactionService.get(DEFAULT_TEST_DB_NAME, appliedTransactionId);
-		
-		ReturnFullCheckinDetails details =
-			ReturnFullCheckinDetails.builder().notes(FAKER.lorem().paragraph()).checkedInBy(CheckedInByOqmEntity.builder().entity(entity.getId()).build()).build();
-		ItemStoredTransaction preApplyTransaction = CheckinFullTransaction.builder()
-														.checkoutId(checkoutId)
-														.toStored(initialStored.getId())
-														.details(details)
-														.build();
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(1, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(5, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 1);
-		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
-		
-		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
-		assertEquals(storedFromSearch, stored);
-		assertEquals(Quantities.getQuantity(5, item.getUnit()), stored.getAmount());
-		
-		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
-		assertFalse(storedHistory.isEmpty());
-		UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
-		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-		
-		
-		SearchResult<ItemCheckout>
-			checkoutSearch =
-			this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setStillCheckedOut(false).setItemCheckedOut(item.getId()));
-		assertEquals(checkoutSearch.getNumResults(), 1);
-		ItemAmountCheckout resultingCheckout = (ItemAmountCheckout) checkoutSearch.getResults().getFirst();
-		
-		assertEquals(appliedTransaction.getId(), resultingCheckout.getCheckInTransaction());
-		assertEquals(details, resultingCheckout.getCheckInDetails());
-	}
-	
-	@Test
-	public void applyCheckinFullAmountSuccessAmtListToBlock() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
-		ObjectId blockId = item.getStorageBlocks().getFirst();
-		
-		AmountStored initialStored = AmountStored.builder()
-										 .item(item.getId())
-										 .storageBlock(blockId)
-										 .amount(Quantities.getQuantity(5, item.getUnit()))
-										 .build();
-		this.storedService.add(DEFAULT_TEST_DB_NAME, initialStored, entity);
-		
-		ObjectId checkoutTransactionId = this.appliedTransactionService.apply(
-			DEFAULT_TEST_DB_NAME, null, item,
-			CheckoutAmountTransaction.builder()
-				.fromStored(initialStored.getId())
-				.amount(Quantities.getQuantity(4, item.getUnit()))
-				.checkoutDetails(CheckoutDetails.builder().checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build()).build())
-				.build(),
-			entity
-		).getId();
-		ObjectId
-			checkoutId =
-			this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setCheckOutTransaction(checkoutTransactionId)).getResults().getFirst().getId();
-		//		AppliedTransaction checkoutTransactionId = this.appliedTransactionService.get(DEFAULT_TEST_DB_NAME, appliedTransactionId);
-		
-		ReturnFullCheckinDetails
-			details =
-			ReturnFullCheckinDetails.builder().notes(FAKER.lorem().paragraph()).checkedInBy(CheckedInByOqmEntity.builder().entity(entity.getId()).build()).build();
-		ItemStoredTransaction preApplyTransaction = CheckinFullTransaction.builder()
-														.checkoutId(checkoutId)
-														.toBlock(blockId)
-														.details(details)
-														.build();
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(1, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		assertEquals(2, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(5, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 2);
-		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
-		
-		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
-		assertEquals(storedFromSearch, stored);
-		assertEquals(Quantities.getQuantity(4, item.getUnit()), stored.getAmount());
-		
-		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
-		assertFalse(storedHistory.isEmpty());
-		UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
-		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-		
-		
-		SearchResult<ItemCheckout>
-			checkoutSearch =
-			this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setStillCheckedOut(false).setItemCheckedOut(item.getId()));
-		assertEquals(checkoutSearch.getNumResults(), 1);
-		ItemAmountCheckout resultingCheckout = (ItemAmountCheckout) checkoutSearch.getResults().getFirst();
-		
-		assertEquals(appliedTransaction.getId(), resultingCheckout.getCheckInTransaction());
-		assertEquals(details, resultingCheckout.getCheckInDetails());
-	}
-	
-	@Test
-	public void applyCheckinFullWholeSuccessBulk() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.BULK, entity);
-		ObjectId blockId = item.getStorageBlocks().getFirst();
-		
-		AmountStored initialStored = AmountStored.builder()
-										 .item(item.getId())
-										 .storageBlock(blockId)
-										 .amount(Quantities.getQuantity(5, item.getUnit()))
-										 .build();
-		this.storedService.add(DEFAULT_TEST_DB_NAME, initialStored, entity);
-		
-		ObjectId checkoutTransactionId = this.appliedTransactionService.apply(
-			DEFAULT_TEST_DB_NAME, null, item,
-			CheckoutWholeTransaction.builder()
-				.toCheckout(initialStored.getId())
-				.checkoutDetails(CheckoutDetails.builder().checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build()).build())
-				.build(),
-			entity
-		).getId();
-		ObjectId
-			checkoutId =
-			this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setCheckOutTransaction(checkoutTransactionId)).getResults().getFirst().getId();
-		//		AppliedTransaction checkoutTransactionId = this.appliedTransactionService.get(DEFAULT_TEST_DB_NAME, appliedTransactionId);
-		
-		ReturnFullCheckinDetails
-			details =
-			ReturnFullCheckinDetails.builder().notes(FAKER.lorem().paragraph()).checkedInBy(CheckedInByOqmEntity.builder().entity(entity.getId()).build()).build();
-		ItemStoredTransaction preApplyTransaction = CheckinFullTransaction.builder()
-														.checkoutId(checkoutId)
-														.toBlock(blockId)
-														.details(details)
-														.build();
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(1, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(5, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 1);
-		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
-		
-		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
-		assertEquals(storedFromSearch, stored);
-		assertEquals(Quantities.getQuantity(5, item.getUnit()), stored.getAmount());
-		
-		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
-		assertFalse(storedHistory.isEmpty());
-		ReCreateEvent event = (ReCreateEvent) storedHistory.getResults().getFirst();
-		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-		
-		
-		SearchResult<ItemCheckout>
-			checkoutSearch =
-			this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setStillCheckedOut(false).setItemCheckedOut(item.getId()));
-		assertEquals(checkoutSearch.getNumResults(), 1);
-		ItemWholeCheckout resultingCheckout = (ItemWholeCheckout) checkoutSearch.getResults().getFirst();
-		
-		assertEquals(appliedTransaction.getId(), resultingCheckout.getCheckInTransaction());
-		assertEquals(details, resultingCheckout.getCheckInDetails());
-	}
-	
-	@Test
-	public void applyCheckinFullWholeSuccessUniqueMulti() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.UNIQUE_MULTI, entity);
-		ObjectId blockId = item.getStorageBlocks().getFirst();
-		
-		UniqueStored initialStored = UniqueStored.builder()
-										 .item(item.getId())
-										 .storageBlock(blockId)
-										 .build();
-		this.storedService.add(DEFAULT_TEST_DB_NAME, initialStored, entity);
-		
-		ObjectId checkoutTransactionId = this.appliedTransactionService.apply(
-			DEFAULT_TEST_DB_NAME, null, item,
-			CheckoutWholeTransaction.builder()
-				.toCheckout(initialStored.getId())
-				.checkoutDetails(CheckoutDetails.builder().checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build()).build())
-				.build(),
-			entity
-		).getId();
-		ObjectId
-			checkoutId =
-			this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setCheckOutTransaction(checkoutTransactionId)).getResults().getFirst().getId();
-		//		AppliedTransaction checkoutTransactionId = this.appliedTransactionService.get(DEFAULT_TEST_DB_NAME, appliedTransactionId);
-		
-		ReturnFullCheckinDetails
-			details =
-			ReturnFullCheckinDetails.builder().notes(FAKER.lorem().paragraph()).checkedInBy(CheckedInByOqmEntity.builder().entity(entity.getId()).build()).build();
-		ItemStoredTransaction preApplyTransaction = CheckinFullTransaction.builder()
-														.checkoutId(checkoutId)
-														.toBlock(blockId)
-														.details(details)
-														.build();
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(1, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(1, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 1);
-		UniqueStored storedFromSearch = (UniqueStored) storedSearchResult.getResults().getFirst();
-		
-		UniqueStored stored = (UniqueStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
-		assertEquals(storedFromSearch, stored);
-		
-		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
-		assertFalse(storedHistory.isEmpty());
-		ReCreateEvent event = (ReCreateEvent) storedHistory.getResults().getFirst();
-		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-		
-		
-		SearchResult<ItemCheckout>
-			checkoutSearch =
-			this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setStillCheckedOut(false).setItemCheckedOut(item.getId()));
-		assertEquals(checkoutSearch.getNumResults(), 1);
-		ItemWholeCheckout resultingCheckout = (ItemWholeCheckout) checkoutSearch.getResults().getFirst();
-		
-		assertEquals(appliedTransaction.getId(), resultingCheckout.getCheckInTransaction());
-		assertEquals(details, resultingCheckout.getCheckInDetails());
-	}
-	
-	@Test
-	public void applyCheckinFullWholeSuccessUniqueSingle() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.UNIQUE_SINGLE, entity);
-		ObjectId blockId = item.getStorageBlocks().getFirst();
-		
-		UniqueStored initialStored = UniqueStored.builder()
-										 .item(item.getId())
-										 .storageBlock(blockId)
-										 .build();
-		this.storedService.add(DEFAULT_TEST_DB_NAME, initialStored, entity);
-		
-		ObjectId checkoutTransactionId = this.appliedTransactionService.apply(
-			DEFAULT_TEST_DB_NAME, null, item,
-			CheckoutWholeTransaction.builder()
-				.toCheckout(initialStored.getId())
-				.checkoutDetails(CheckoutDetails.builder().checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build()).build())
-				.build(),
-			entity
-		).getId();
-		ObjectId
-			checkoutId =
-			this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setCheckOutTransaction(checkoutTransactionId)).getResults().getFirst().getId();
-		//		AppliedTransaction checkoutTransactionId = this.appliedTransactionService.get(DEFAULT_TEST_DB_NAME, appliedTransactionId);
-		
-		ReturnFullCheckinDetails
-			details =
-			ReturnFullCheckinDetails.builder().notes(FAKER.lorem().paragraph()).checkedInBy(CheckedInByOqmEntity.builder().entity(entity.getId()).build()).build();
-		ItemStoredTransaction preApplyTransaction = CheckinFullTransaction.builder()
-														.checkoutId(checkoutId)
-														.toBlock(blockId)
-														.details(details)
-														.build();
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(1, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(1, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 1);
-		UniqueStored storedFromSearch = (UniqueStored) storedSearchResult.getResults().getFirst();
-		
-		UniqueStored stored = (UniqueStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
-		assertEquals(storedFromSearch, stored);
-		
-		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
-		assertFalse(storedHistory.isEmpty());
-		ReCreateEvent event = (ReCreateEvent) storedHistory.getResults().getFirst();
-		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-		
-		
-		SearchResult<ItemCheckout>
-			checkoutSearch =
-			this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setStillCheckedOut(false).setItemCheckedOut(item.getId()));
-		assertEquals(checkoutSearch.getNumResults(), 1);
-		ItemWholeCheckout resultingCheckout = (ItemWholeCheckout) checkoutSearch.getResults().getFirst();
-		
-		assertEquals(appliedTransaction.getId(), resultingCheckout.getCheckInTransaction());
-		assertEquals(details, resultingCheckout.getCheckInDetails());
-	}
-	
-	
-	//TODO:: fail - amount list - amount - to stored (not existing)
-	//TODO:: Fail - amount - No 'to' given
-	//TODO:: Fail - amount - 'to block' given for list
-	//TODO:: fail - whole - no to block given
-	//TODO:: fail - mismatched item/stored/block
-	//TODO:: any more?
-	//</editor-fold>
-	//<editor-fold desc="Apply- Checkin Part">
-	//TODO:: When we have this implemented
-	//</editor-fold>
-	//<editor-fold desc="Apply- Checkin Loss">
-	//TODO:: When we have this implemented
-	//</editor-fold>
-	//<editor-fold desc="Apply- Checkout Amount">
-	
-	@Test
-	public void applyCheckoutAmountSuccessBulkFromBlock() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.BULK, entity);
-		ObjectId blockId = item.getStorageBlocks().getFirst();
-		
-		ObjectId initialStoredId = this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			AmountStored.builder()
-				.item(item.getId())
-				.storageBlock(blockId)
-				.amount(Quantities.getQuantity(6, item.getUnit()))
-				.build(),
-			entity
-		).getId();
-		
-		CheckoutDetails details = CheckoutDetails.builder()
-									  .checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build())
-									  .build();
-		ItemStoredTransaction preApplyTransaction = CheckoutAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.fromBlock(blockId)
-														.checkoutDetails(details)
-														.build();
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(1, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(1, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 1);
-		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
-		
-		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
-		assertEquals(storedFromSearch, stored);
-		assertEquals(Quantities.getQuantity(1, item.getUnit()), stored.getAmount());
-		
-		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
-		assertFalse(storedHistory.isEmpty());
-		UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
-		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-		
-		SearchResult<ItemCheckout> checkoutSearch = this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setItemCheckedOut(item.getId()));
-		assertEquals(checkoutSearch.getNumResults(), 1);
-		ItemAmountCheckout resultingCheckout = (ItemAmountCheckout) checkoutSearch.getResults().getFirst();
-		
-		assertEquals(initialStoredId, resultingCheckout.getFromStored());
-		assertEquals(details, resultingCheckout.getCheckoutDetails());
-		assertEquals(appliedTransaction.getId(), resultingCheckout.getCheckOutTransaction());
-		assertEquals(Quantities.getQuantity(5, item.getUnit()), resultingCheckout.getCheckedOut());
-	}
-	
-	@Test
-	public void applyCheckoutAmountSuccessBulkFromStored() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.BULK, entity);
-		ObjectId blockId = item.getStorageBlocks().getFirst();
-		
-		ObjectId initialStoredId = this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			AmountStored.builder()
-				.item(item.getId())
-				.storageBlock(blockId)
-				.amount(Quantities.getQuantity(6, item.getUnit()))
-				.build(),
-			entity
-		).getId();
-		
-		CheckoutDetails details = CheckoutDetails.builder()
-									  .checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build())
-									  .build();
-		ItemStoredTransaction preApplyTransaction = CheckoutAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.fromStored(initialStoredId)
-														.checkoutDetails(details)
-														.build();
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(1, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(1, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 1);
-		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
-		
-		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
-		assertEquals(storedFromSearch, stored);
-		assertEquals(Quantities.getQuantity(1, item.getUnit()), stored.getAmount());
-		
-		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
-		assertFalse(storedHistory.isEmpty());
-		UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
-		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-		
-		SearchResult<ItemCheckout> checkoutSearch = this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setItemCheckedOut(item.getId()));
-		assertEquals(checkoutSearch.getNumResults(), 1);
-		ItemAmountCheckout resultingCheckout = (ItemAmountCheckout) checkoutSearch.getResults().getFirst();
-		
-		assertEquals(initialStoredId, resultingCheckout.getFromStored());
-		assertEquals(details, resultingCheckout.getCheckoutDetails());
-		assertEquals(appliedTransaction.getId(), resultingCheckout.getCheckOutTransaction());
-		assertEquals(Quantities.getQuantity(5, item.getUnit()), resultingCheckout.getCheckedOut());
-	}
-	
-	@Test
-	public void applyCheckoutAmountSuccessAmtList() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
-		ObjectId blockId = item.getStorageBlocks().getFirst();
-		
-		ObjectId initialStoredId = this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			AmountStored.builder()
-				.item(item.getId())
-				.storageBlock(blockId)
-				.amount(Quantities.getQuantity(6, item.getUnit()))
-				.build(),
-			entity
-		).getId();
-		
-		CheckoutDetails details = CheckoutDetails.builder()
-									  .checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build())
-									  .build();
-		ItemStoredTransaction preApplyTransaction = CheckoutAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.fromStored(initialStoredId)
-														.checkoutDetails(details)
-														.build();
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(1, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(1, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 1);
-		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
-		
-		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
-		assertEquals(storedFromSearch, stored);
-		assertEquals(Quantities.getQuantity(1, item.getUnit()), stored.getAmount());
-		
-		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
-		assertFalse(storedHistory.isEmpty());
-		UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
-		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-		
-		SearchResult<ItemCheckout> checkoutSearch = this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setItemCheckedOut(item.getId()));
-		assertEquals(checkoutSearch.getNumResults(), 1);
-		ItemAmountCheckout resultingCheckout = (ItemAmountCheckout) checkoutSearch.getResults().getFirst();
-		
-		assertEquals(initialStoredId, resultingCheckout.getFromStored());
-		assertEquals(details, resultingCheckout.getCheckoutDetails());
-		assertEquals(appliedTransaction.getId(), resultingCheckout.getCheckOutTransaction());
-		assertEquals(Quantities.getQuantity(5, item.getUnit()), resultingCheckout.getCheckedOut());
-	}
-	
-	@Test
-	public void applyCheckoutAmountFailBulkFromNothing() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.BULK, entity);
-		ObjectId blockId = item.getStorageBlocks().getFirst();
-		
-		ObjectId initialStoredId = this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			AmountStored.builder()
-				.item(item.getId())
-				.storageBlock(blockId)
-				.amount(Quantities.getQuantity(6, item.getUnit()))
-				.build(),
-			entity
-		).getId();
-		
-		CheckoutDetails details = CheckoutDetails.builder()
-									  .checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build())
-									  .build();
-		ItemStoredTransaction preApplyTransaction = CheckoutAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.checkoutDetails(details)
-														.build();
-		
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("No stored or block given to checkout from.", e.getMessage());
-	}
-	
-	@Test
-	public void applyCheckoutAmountFailAmtListFromNothing() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
-		ObjectId blockId = item.getStorageBlocks().getFirst();
-		
-		ObjectId initialStoredId = this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			AmountStored.builder()
-				.item(item.getId())
-				.storageBlock(blockId)
-				.amount(Quantities.getQuantity(6, item.getUnit()))
-				.build(),
-			entity
-		).getId();
-		
-		CheckoutDetails details = CheckoutDetails.builder()
-									  .checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build())
-									  .build();
-		ItemStoredTransaction preApplyTransaction = CheckoutAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.checkoutDetails(details)
-														.build();
-		
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("No stored given to checkout from.", e.getMessage());
-	}
-	
-	@Test
-	public void applyCheckoutAmountFailAmtListFromNoStored() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
-		ObjectId blockId = item.getStorageBlocks().getFirst();
-		
-		ObjectId initialStoredId = this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			AmountStored.builder()
-				.item(item.getId())
-				.storageBlock(blockId)
-				.amount(Quantities.getQuantity(6, item.getUnit()))
-				.build(),
-			entity
-		).getId();
-		
-		CheckoutDetails details = CheckoutDetails.builder()
-									  .checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build())
-									  .build();
-		ItemStoredTransaction preApplyTransaction = CheckoutAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.fromBlock(blockId)
-														.checkoutDetails(details)
-														.build();
-		
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("No stored given to checkout from.", e.getMessage());
-	}
-	
-	@Test
-	public void applyCheckoutAmountFailAmtListBadBlock() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
-		ObjectId blockId = item.getStorageBlocks().getFirst();
-		
-		ObjectId initialStoredId = this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			AmountStored.builder()
-				.item(item.getId())
-				.storageBlock(blockId)
-				.amount(Quantities.getQuantity(6, item.getUnit()))
-				.build(),
-			entity
-		).getId();
-		
-		CheckoutDetails details = CheckoutDetails.builder()
-									  .checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build())
-									  .build();
-		ItemStoredTransaction preApplyTransaction = CheckoutAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.fromBlock(new ObjectId())
-														.fromStored(initialStoredId)
-														.checkoutDetails(details)
-														.build();
-		
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("From Storage block given mismatched stored's block.", e.getMessage());
-	}
-	
-	@Test
-	public void applyCheckoutAmountFailBulkNotEnoughToCheckout() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.BULK, entity);
-		ObjectId blockId = item.getStorageBlocks().getFirst();
-		
-		ObjectId initialStoredId = this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			AmountStored.builder()
-				.item(item.getId())
-				.storageBlock(blockId)
-				.amount(Quantities.getQuantity(6, item.getUnit()))
-				.build(),
-			entity
-		).getId();
-		
-		CheckoutDetails details = CheckoutDetails.builder()
-									  .checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build())
-									  .build();
-		ItemStoredTransaction preApplyTransaction = CheckoutAmountTransaction.builder()
-														.amount(Quantities.getQuantity(7, item.getUnit()))
-														.fromBlock(blockId)
-														.fromStored(initialStoredId)
-														.checkoutDetails(details)
-														.build();
-		
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("Resulting amount less than zero. (subtracting 7 units from 6 units resulting in -1 units)", e.getMessage());
-	}
-	
-	@Test
-	public void applyCheckoutAmountFailAmtListNotEnoughToCheckout() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
-		ObjectId blockId = item.getStorageBlocks().getFirst();
-		
-		ObjectId initialStoredId = this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			AmountStored.builder()
-				.item(item.getId())
-				.storageBlock(blockId)
-				.amount(Quantities.getQuantity(6, item.getUnit()))
-				.build(),
-			entity
-		).getId();
-		
-		CheckoutDetails details = CheckoutDetails.builder()
-									  .checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build())
-									  .build();
-		ItemStoredTransaction preApplyTransaction = CheckoutAmountTransaction.builder()
-														.amount(Quantities.getQuantity(7, item.getUnit()))
-														.fromBlock(blockId)
-														.fromStored(initialStoredId)
-														.checkoutDetails(details)
-														.build();
-		
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("Resulting amount less than zero. (subtracting 7 units from 6 units resulting in -1 units)", e.getMessage());
-	}
-	
-	@Test
-	public void applyCheckoutAmountFailUniqueSingle() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.UNIQUE_SINGLE, entity);
-		ObjectId blockId = item.getStorageBlocks().getFirst();
-		
-		ObjectId initialStoredId = this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			UniqueStored.builder()
-				.item(item.getId())
-				.storageBlock(blockId)
-				.build(),
-			entity
-		).getId();
-		
-		CheckoutDetails details = CheckoutDetails.builder()
-									  .checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build())
-									  .build();
-		ItemStoredTransaction preApplyTransaction = CheckoutAmountTransaction.builder()
-														.amount(Quantities.getQuantity(7, item.getUnit()))
-														.fromBlock(blockId)
-														.fromStored(initialStoredId)
-														.checkoutDetails(details)
-														.build();
-		
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("Cannot checkout an amount from a unique type.", e.getMessage());
-	}
-	
-	@Test
-	public void applyCheckoutAmountFailUniqueMulti() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.UNIQUE_MULTI, entity);
-		ObjectId blockId = item.getStorageBlocks().getFirst();
-		
-		ObjectId initialStoredId = this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			UniqueStored.builder()
-				.item(item.getId())
-				.storageBlock(blockId)
-				.build(),
-			entity
-		).getId();
-		
-		CheckoutDetails details = CheckoutDetails.builder()
-									  .checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build())
-									  .build();
-		ItemStoredTransaction preApplyTransaction = CheckoutAmountTransaction.builder()
-														.amount(Quantities.getQuantity(7, item.getUnit()))
-														.fromBlock(blockId)
-														.fromStored(initialStoredId)
-														.checkoutDetails(details)
-														.build();
-		
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("Cannot checkout an amount from a unique type.", e.getMessage());
-	}
-	
-	//TODO:: fail - mismatched item/stored/block
-	//TODO:: any more?
-	//</editor-fold>
-	//<editor-fold desc="Apply- Checkout Whole">
-	
-	@Test
-	public void applyCheckoutWholeSuccessBulk() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.BULK, entity);
-		ObjectId blockId = item.getStorageBlocks().getFirst();
-		
-		AmountStored initialStored = AmountStored.builder()
-										 .item(item.getId())
-										 .storageBlock(blockId)
-										 .amount(Quantities.getQuantity(6, item.getUnit()))
-										 .build();
-		ObjectId initialStoredId = this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			initialStored,
-			entity
-		).getId();
-		
-		CheckoutDetails details = CheckoutDetails.builder()
-									  .checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build())
-									  .build();
-		ItemStoredTransaction preApplyTransaction = CheckoutWholeTransaction.builder()
-														.toCheckout(initialStoredId)
-														.checkoutDetails(details)
-														.build();
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(1, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		assertEquals(0, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(0, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 0);
-		
-		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(initialStoredId));
-		assertFalse(storedHistory.isEmpty());
-		DeleteEvent event = (DeleteEvent) storedHistory.getResults().getFirst();
-		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-		
-		SearchResult<ItemCheckout> checkoutSearch = this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setItemCheckedOut(item.getId()));
-		assertEquals(checkoutSearch.getNumResults(), 1);
-		ItemWholeCheckout resultingCheckout = (ItemWholeCheckout) checkoutSearch.getResults().getFirst();
-		
-		assertEquals(details, resultingCheckout.getCheckoutDetails());
-		assertEquals(appliedTransaction.getId(), resultingCheckout.getCheckOutTransaction());
-		assertEquals(initialStored, resultingCheckout.getCheckedOut());
-	}
-	
-	@Test
-	public void applyCheckoutWholeSuccessAmtList() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
-		ObjectId blockId = item.getStorageBlocks().getFirst();
-		
-		AmountStored initialStored = AmountStored.builder()
-										 .item(item.getId())
-										 .storageBlock(blockId)
-										 .amount(Quantities.getQuantity(6, item.getUnit()))
-										 .build();
-		ObjectId initialStoredId = this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			initialStored,
-			entity
-		).getId();
-		
-		CheckoutDetails details = CheckoutDetails.builder()
-									  .checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build())
-									  .build();
-		ItemStoredTransaction preApplyTransaction = CheckoutWholeTransaction.builder()
-														.toCheckout(initialStoredId)
-														.checkoutDetails(details)
-														.build();
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(1, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		assertEquals(0, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(0, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 0);
-		
-		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(initialStoredId));
-		assertFalse(storedHistory.isEmpty());
-		DeleteEvent event = (DeleteEvent) storedHistory.getResults().getFirst();
-		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-		
-		SearchResult<ItemCheckout> checkoutSearch = this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setItemCheckedOut(item.getId()));
-		assertEquals(checkoutSearch.getNumResults(), 1);
-		ItemWholeCheckout resultingCheckout = (ItemWholeCheckout) checkoutSearch.getResults().getFirst();
-		
-		assertEquals(details, resultingCheckout.getCheckoutDetails());
-		assertEquals(appliedTransaction.getId(), resultingCheckout.getCheckOutTransaction());
-		assertEquals(initialStored, resultingCheckout.getCheckedOut());
-	}
-	
-	@Test
-	public void applyCheckoutWholeSuccessUniqueMulti() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.UNIQUE_MULTI, entity);
-		ObjectId blockId = item.getStorageBlocks().getFirst();
-		
-		UniqueStored initialStored = UniqueStored.builder()
-										 .item(item.getId())
-										 .storageBlock(blockId)
-										 .build();
-		ObjectId initialStoredId = this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			initialStored,
-			entity
-		).getId();
-		
-		CheckoutDetails details = CheckoutDetails.builder()
-									  .checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build())
-									  .build();
-		ItemStoredTransaction preApplyTransaction = CheckoutWholeTransaction.builder()
-														.toCheckout(initialStoredId)
-														.checkoutDetails(details)
-														.build();
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(1, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		assertEquals(0, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(0, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 0);
-		
-		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(initialStoredId));
-		assertFalse(storedHistory.isEmpty());
-		DeleteEvent event = (DeleteEvent) storedHistory.getResults().getFirst();
-		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-		
-		SearchResult<ItemCheckout> checkoutSearch = this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setItemCheckedOut(item.getId()));
-		assertEquals(checkoutSearch.getNumResults(), 1);
-		ItemWholeCheckout resultingCheckout = (ItemWholeCheckout) checkoutSearch.getResults().getFirst();
-		
-		assertEquals(details, resultingCheckout.getCheckoutDetails());
-		assertEquals(appliedTransaction.getId(), resultingCheckout.getCheckOutTransaction());
-		assertEquals(initialStored, resultingCheckout.getCheckedOut());
-	}
-	
-	@Test
-	public void applyCheckoutWholeSuccessUniqueSingle() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.UNIQUE_SINGLE, entity);
-		ObjectId blockId = item.getStorageBlocks().getFirst();
-		
-		UniqueStored initialStored = UniqueStored.builder()
-										 .item(item.getId())
-										 .storageBlock(blockId)
-										 .build();
-		ObjectId initialStoredId = this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			initialStored,
-			entity
-		).getId();
-		
-		CheckoutDetails details = CheckoutDetails.builder()
-									  .checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build())
-									  .build();
-		ItemStoredTransaction preApplyTransaction = CheckoutWholeTransaction.builder()
-														.toCheckout(initialStoredId)
-														.checkoutDetails(details)
-														.build();
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(1, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		assertEquals(0, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(0, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 0);
-		
-		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(initialStoredId));
-		assertFalse(storedHistory.isEmpty());
-		DeleteEvent event = (DeleteEvent) storedHistory.getResults().getFirst();
-		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-		
-		SearchResult<ItemCheckout> checkoutSearch = this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setItemCheckedOut(item.getId()));
-		assertEquals(checkoutSearch.getNumResults(), 1);
-		ItemWholeCheckout resultingCheckout = (ItemWholeCheckout) checkoutSearch.getResults().getFirst();
-		
-		assertEquals(details, resultingCheckout.getCheckoutDetails());
-		assertEquals(appliedTransaction.getId(), resultingCheckout.getCheckOutTransaction());
-		assertEquals(initialStored, resultingCheckout.getCheckedOut());
-	}
-	
-	//TODO:: fail - mismatched item/stored/block
-	//TODO:: any more?
-	//</editor-fold>
-	//<editor-fold desc="Apply- Set Amount">
-	@Test
-	public void applySetAmountSuccessBulkNotInBlock() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.BULK, entity);
-		
-		ItemStoredTransaction preApplyTransaction = SetAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.block(item.getStorageBlocks().getFirst())
-														.build();
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(1, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(5, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 1);
-		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
-		
-		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
-		assertEquals(storedFromSearch, stored);
-		assertEquals(Quantities.getQuantity(5, item.getUnit()), stored.getAmount());
-		
-		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
-		assertFalse(storedHistory.isEmpty());
-		UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
-		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-	}
-	
-	
-	@Test
-	public void applySetAmountSuccessBulkAlreadyInBlock() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.BULK, entity);
-		
-		AmountStored originalStored = AmountStored.builder()
-										  .item(item.getId())
-										  .storageBlock(item.getStorageBlocks().getFirst())
-										  .amount(Quantities.getQuantity(5, item.getUnit()))
-										  .build();
-		this.storedService.add(DEFAULT_TEST_DB_NAME, originalStored, entity);
-		
-		
-		ItemStoredTransaction preApplyTransaction = SetAmountTransaction.builder()
-														.amount(Quantities.getQuantity(6, item.getUnit()))
-														.block(item.getStorageBlocks().getFirst())
-														.build();
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(1, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(6, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 1);
-		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
-		
-		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
-		assertEquals(originalStored.getId(), stored.getId());
-		assertEquals(storedFromSearch, stored);
-		assertEquals(Quantities.getQuantity(6, item.getUnit()), stored.getAmount());
-		
-		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
-		assertFalse(storedHistory.isEmpty());
-		UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
-		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-	}
-	
-	
-	@Test
-	public void applySetAmountSuccessAmtListExistingStored() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
-		
-		AmountStored originalStored = AmountStored.builder()
-										  .item(item.getId())
-										  .storageBlock(item.getStorageBlocks().getFirst())
-										  .amount(Quantities.getQuantity(5, item.getUnit()))
-										  .build();
-		this.storedService.add(DEFAULT_TEST_DB_NAME, originalStored, entity);
-		
-		
-		ItemStoredTransaction preApplyTransaction = SetAmountTransaction.builder()
-														.amount(Quantities.getQuantity(6, item.getUnit()))
-														.block(item.getStorageBlocks().getFirst())
-														.stored(originalStored.getId())
-														.build();
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(1, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(6, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 1);
-		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
-		
-		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
-		assertEquals(originalStored.getId(), stored.getId());
-		assertEquals(storedFromSearch, stored);
-		assertEquals(Quantities.getQuantity(6, item.getUnit()), stored.getAmount());
-		
-		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
-		assertFalse(storedHistory.isEmpty());
-		UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
-		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-	}
-	
-	@Test
-	public void applySetAmountFailUniqueMulti() {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.UNIQUE_MULTI, entity);
-		
-		ItemStoredTransaction preApplyTransaction = SetAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.block(item.getStorageBlocks().getFirst())
-														.build();
-		
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("Cannot add an amount to a unique item.", e.getMessage());
-	}
-	
-	@Test
-	public void applySetAmountFailUniqueSingle() {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.UNIQUE_SINGLE, entity);
-		
-		ItemStoredTransaction preApplyTransaction = SetAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.block(item.getStorageBlocks().getFirst())
-														.build();
-		
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("Cannot add an amount to a unique item.", e.getMessage());
-	}
-	
-	@Test
-	public void applySetAmountFailBulkBlockNotInInventory() {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.BULK, entity);
-		
-		ObjectId badBlockId = new ObjectId();
-		ItemStoredTransaction preApplyTransaction = SetAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.block(badBlockId)
-														.build();
-		
-		ValidationException e = assertThrows(ValidationException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("Storage block " + badBlockId + " not used to hold this item (" + item.getId() + ").", e.getMessage());
-	}
-	
-	@Test
-	public void applySetAmountFailBulkStoredNotInBlock() {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.BULK, entity);
-		
-		ObjectId badStoredId = new ObjectId();
-		ItemStoredTransaction preApplyTransaction = SetAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.stored(badStoredId)
-														.block(item.getStorageBlocks().getFirst())
-														.build();
-		
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("To Stored given does not match stored found in block.", e.getMessage());
-	}
-	
-	@Test
-	public void applySetAmountFailAmtListBadStored() {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
-		
-		ObjectId badStoredId = new ObjectId();
-		ItemStoredTransaction preApplyTransaction = SetAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.stored(badStoredId)
-														.block(item.getStorageBlocks().getFirst())
-														.build();
-		
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("Could not find Stored with id " + badStoredId, e.getMessage());
-	}
-	
-	@Test
-	public void applySetAmountFailAmtListBadStoredNotInBlock() {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
-		
-		ObjectId origBlock = item.getStorageBlocks().getFirst();
-		ObjectId otherBlockId = this.storageBlockService.add(DEFAULT_TEST_DB_NAME, StorageBlock.builder().label(FAKER.location().building()).build(), entity).getId();
-		
-		item.getStorageBlocks().add(otherBlockId);
-		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
-		
-		AmountStored originalStored = AmountStored.builder()
-										  .item(item.getId())
-										  .storageBlock(origBlock)
-										  .amount(Quantities.getQuantity(5, item.getUnit()))
-										  .build();
-		this.storedService.add(DEFAULT_TEST_DB_NAME, originalStored, entity);
-		
-		ItemStoredTransaction preApplyTransaction = SetAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.stored(originalStored.getId())
-														.block(otherBlockId)
-														.build();
-		
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("To Stored given does not exist in block.", e.getMessage());
-	}
-	
-	@Test
-	public void applySetAmountFailAmtListNewEntry() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
-		
-		ItemStoredTransaction preApplyTransaction = SetAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.block(item.getStorageBlocks().getFirst())
-														.build();
-		
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("Must specify a stored to set the amount of.", e.getMessage());
-	}
-	
-	//TODO:: any more?
-	//</editor-fold>
-	//<editor-fold desc="Apply- Subtract Amount">
-	@Test
-	public void applySubtractAmountSuccessBulkBlock() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.BULK, entity);
-		
-		this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			AmountStored.builder()
-				.amount(Quantities.getQuantity(5, item.getUnit()))
-				.item(item.getId())
-				.storageBlock(item.getStorageBlocks().getFirst())
-				.build(),
-			entity
-		);
-		
-		ItemStoredTransaction preApplyTransaction = SubAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.fromBlock(item.getStorageBlocks().getFirst())
-														.build();
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(1, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(0, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 1);
-		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
-		
-		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
-		assertEquals(storedFromSearch, stored);
-		assertEquals(Quantities.getQuantity(0, item.getUnit()), stored.getAmount());
-		
-		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
-		assertFalse(storedHistory.isEmpty());
-		UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
-		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-	}
-	
-	@Test
-	public void applySubtractAmountSuccessBulkStored() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.BULK, entity);
-		
-		AmountStored initialStored = AmountStored.builder()
-										 .amount(Quantities.getQuantity(5, item.getUnit()))
-										 .item(item.getId())
-										 .storageBlock(item.getStorageBlocks().getFirst())
-										 .build();
-		this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			initialStored,
-			entity
-		);
-		
-		ItemStoredTransaction preApplyTransaction = SubAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.fromBlock(item.getStorageBlocks().getFirst())
-														.fromStored(initialStored.getId())
-														.build();
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(1, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(0, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 1);
-		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
-		
-		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
-		assertEquals(storedFromSearch, stored);
-		assertEquals(Quantities.getQuantity(0, item.getUnit()), stored.getAmount());
-		
-		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
-		assertFalse(storedHistory.isEmpty());
-		UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
-		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-	}
-	
-	@Test
-	public void applySubtractAmountSuccessList() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
-		
-		AmountStored initialStored = AmountStored.builder()
-										 .amount(Quantities.getQuantity(5, item.getUnit()))
-										 .item(item.getId())
-										 .storageBlock(item.getStorageBlocks().getFirst())
-										 .build();
-		this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			initialStored,
-			entity
-		);
-		
-		ItemStoredTransaction preApplyTransaction = SubAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.fromBlock(item.getStorageBlocks().getFirst())
-														.fromStored(initialStored.getId())
-														.build();
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(1, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(0, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 1);
-		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
-		
-		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
-		assertEquals(storedFromSearch, stored);
-		assertEquals(Quantities.getQuantity(0, item.getUnit()), stored.getAmount());
-		
-		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
-		assertFalse(storedHistory.isEmpty());
-		UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
-		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-	}
-	
-	@Test
-	public void applySubtractAmountFailUniqueMulti() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.UNIQUE_MULTI, entity);
-		
-		UniqueStored initialStored = UniqueStored.builder()
-										 .item(item.getId())
-										 .storageBlock(item.getStorageBlocks().getFirst())
-										 .build();
-		this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			initialStored,
-			entity
-		);
-		
-		ItemStoredTransaction preApplyTransaction = SubAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.fromBlock(item.getStorageBlocks().getFirst())
-														.fromStored(initialStored.getId())
-														.build();
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("Cannot subtract an amount from a unique item.", e.getMessage());
-	}
-	
-	@Test
-	public void applySubtractAmountFailUniqueSingle() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.UNIQUE_SINGLE, entity);
-		
-		UniqueStored initialStored = UniqueStored.builder()
-										 .item(item.getId())
-										 .storageBlock(item.getStorageBlocks().getFirst())
-										 .build();
-		this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			initialStored,
-			entity
-		);
-		
-		ItemStoredTransaction preApplyTransaction = SubAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.fromBlock(item.getStorageBlocks().getFirst())
-														.fromStored(initialStored.getId())
-														.build();
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("Cannot subtract an amount from a unique item.", e.getMessage());
-	}
-	
-	@Test
-	public void applySubtractAmountFailBulkSubMoreThanHeld() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.BULK, entity);
-		
-		AmountStored initialStored = AmountStored.builder()
-										 .amount(Quantities.getQuantity(2, item.getUnit()))
-										 .item(item.getId())
-										 .storageBlock(item.getStorageBlocks().getFirst())
-										 .build();
-		this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			initialStored,
-			entity
-		);
-		
-		ItemStoredTransaction preApplyTransaction = SubAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.fromBlock(item.getStorageBlocks().getFirst())
-														.fromStored(initialStored.getId())
-														.build();
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("Resulting amount less than zero. (subtracting 5 units from 2 units resulting in -3 units)", e.getMessage());
-	}
-	
-	@Test
-	public void applySubtractAmountFailAmtListSubMoreThanHeld() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
-		
-		AmountStored initialStored = AmountStored.builder()
-										 .amount(Quantities.getQuantity(2, item.getUnit()))
-										 .item(item.getId())
-										 .storageBlock(item.getStorageBlocks().getFirst())
-										 .build();
-		this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			initialStored,
-			entity
-		);
-		
-		ItemStoredTransaction preApplyTransaction = SubAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.fromBlock(item.getStorageBlocks().getFirst())
-														.fromStored(initialStored.getId())
-														.build();
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("Resulting amount less than zero. (subtracting 5 units from 2 units resulting in -3 units)", e.getMessage());
-	}
-	
-	@Test
-	public void applySubtractAmountFailBulkMismatchedBlock() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.BULK, entity);
-		
-		StorageBlock newBlock = StorageBlock.builder().label(FAKER.location().building()).build();
-		this.storageBlockService.add(DEFAULT_TEST_DB_NAME, newBlock, entity);
-		item.getStorageBlocks().add(newBlock.getId());
-		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
-		
-		AmountStored initialStored = AmountStored.builder()
-										 .amount(Quantities.getQuantity(5, item.getUnit()))
-										 .item(item.getId())
-										 .storageBlock(item.getStorageBlocks().getFirst())
-										 .build();
-		this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			initialStored,
-			entity
-		);
-		AmountStored secondStored = AmountStored.builder()
-										.amount(Quantities.getQuantity(5, item.getUnit()))
-										.item(item.getId())
-										.storageBlock(newBlock.getId())
-										.build();
-		this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			secondStored,
-			entity
-		);
-		
-		ItemStoredTransaction preApplyTransaction = SubAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.fromBlock(newBlock.getId())
-														.fromStored(initialStored.getId())
-														.build();
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("Stored id in transaction not the id of stored found.", e.getMessage());
-	}
-	
-	@Test
-	public void applySubtractAmountFailBulkMismatchedStored() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.BULK, entity);
-		
-		StorageBlock newBlock = StorageBlock.builder().label(FAKER.location().building()).build();
-		this.storageBlockService.add(DEFAULT_TEST_DB_NAME, newBlock, entity);
-		item.getStorageBlocks().add(newBlock.getId());
-		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
-		
-		AmountStored initialStored = AmountStored.builder()
-										 .amount(Quantities.getQuantity(5, item.getUnit()))
-										 .item(item.getId())
-										 .storageBlock(item.getStorageBlocks().getFirst())
-										 .build();
-		this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			initialStored,
-			entity
-		);
-		AmountStored secondStored = AmountStored.builder()
-										.amount(Quantities.getQuantity(5, item.getUnit()))
-										.item(item.getId())
-										.storageBlock(newBlock.getId())
-										.build();
-		this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			secondStored,
-			entity
-		);
-		
-		ItemStoredTransaction preApplyTransaction = SubAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.fromBlock(item.getStorageBlocks().getFirst())
-														.fromStored(secondStored.getId())
-														.build();
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("Stored id in transaction not the id of stored found.", e.getMessage());
-	}
-	
-	@Test
-	public void applySubtractAmountFailListMismatchedBlock() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
-		
-		StorageBlock newBlock = StorageBlock.builder().label(FAKER.location().building()).build();
-		this.storageBlockService.add(DEFAULT_TEST_DB_NAME, newBlock, entity);
-		item.getStorageBlocks().add(newBlock.getId());
-		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
-		
-		AmountStored initialStored = AmountStored.builder()
-										 .amount(Quantities.getQuantity(5, item.getUnit()))
-										 .item(item.getId())
-										 .storageBlock(item.getStorageBlocks().getFirst())
-										 .build();
-		this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			initialStored,
-			entity
-		);
-		AmountStored secondStored = AmountStored.builder()
-										.amount(Quantities.getQuantity(5, item.getUnit()))
-										.item(item.getId())
-										.storageBlock(newBlock.getId())
-										.build();
-		this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			secondStored,
-			entity
-		);
-		
-		ItemStoredTransaction preApplyTransaction = SubAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.fromBlock(newBlock.getId())
-														.fromStored(initialStored.getId())
-														.build();
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("Stored retrieved not in specified block.", e.getMessage());
-	}
-	
-	@Test
-	public void applySubtractAmountFailListMismatchedStored() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
-		
-		StorageBlock newBlock = StorageBlock.builder().label(FAKER.location().building()).build();
-		this.storageBlockService.add(DEFAULT_TEST_DB_NAME, newBlock, entity);
-		item.getStorageBlocks().add(newBlock.getId());
-		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
-		
-		AmountStored initialStored = AmountStored.builder()
-										 .amount(Quantities.getQuantity(5, item.getUnit()))
-										 .item(item.getId())
-										 .storageBlock(item.getStorageBlocks().getFirst())
-										 .build();
-		this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			initialStored,
-			entity
-		);
-		AmountStored secondStored = AmountStored.builder()
-										.amount(Quantities.getQuantity(5, item.getUnit()))
-										.item(item.getId())
-										.storageBlock(newBlock.getId())
-										.build();
-		this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			secondStored,
-			entity
-		);
-		
-		ItemStoredTransaction preApplyTransaction = SubAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.fromBlock(item.getStorageBlocks().getFirst())
-														.fromStored(secondStored.getId())
-														.build();
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("Stored retrieved not in specified block.", e.getMessage());
-	}
-	
-	@Test
-	public void applySubtractAmountFailNullStored() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
-		
-		AmountStored initialStored = AmountStored.builder()
-										 .amount(Quantities.getQuantity(5, item.getUnit()))
-										 .item(item.getId())
-										 .storageBlock(item.getStorageBlocks().getFirst())
-										 .build();
-		this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			initialStored,
-			entity
-		);
-		
-		ItemStoredTransaction preApplyTransaction = SubAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.fromBlock(item.getStorageBlocks().getFirst())
-														.build();
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("Must specify the stored item we are subtracting from.", e.getMessage());
-	}
-	
-	//TODO:: any more?
-	//</editor-fold>
-	//<editor-fold desc="Apply- Subtract Whole">
-	//TODO:: Success - bulk
-	//TODO:: Success - amt list
-	//TODO:: Success - unique list
-	//TODO:: Success - unique single
-	//TODO:: fail - mismatched item/stored/block
-	//TODO:: any more?
-	//</editor-fold>
-	//<editor-fold desc="Apply- Transfer Amount">
-	
-	@Test
-	public void applyTransferAmountSuccessBulkNotInBlock() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.BULK, entity);
-		ObjectId firstBlock = item.getStorageBlocks().getFirst();
-		ObjectId secondBlock = this.storageBlockService.add(
-			DEFAULT_TEST_DB_NAME,
-			StorageBlock.builder().label(FAKER.location().building()).build(),
-			entity
-		).getId();
-		item.getStorageBlocks().add(secondBlock);
-		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
-		
-		ObjectId initialStoredId = this.storedService.add(
-			DEFAULT_TEST_DB_NAME, AmountStored.builder()
-									  .item(item.getId())
-									  .storageBlock(firstBlock)
-									  .amount(Quantities.getQuantity(5, item.getUnit()))
-									  .build(),
-			entity
-		).getId();
-		
-		ItemStoredTransaction preApplyTransaction = TransferAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.fromBlock(firstBlock)
-														.toBlock(secondBlock)
-														.build();
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(2, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		assertEquals(2, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(5, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 2);
-		//'first' and 'second' are flipped here
-		AmountStored firstStoredFromSearch = (AmountStored) storedSearchResult.getResults().get(0);
-		AmountStored secondStoredFromSearch = (AmountStored) storedSearchResult.getResults().get(1);
-		
-		{
-			AmountStored firstStored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().getFirst());
-			assertEquals(firstStoredFromSearch, firstStored);
-			assertEquals(Quantities.getQuantity(5, item.getUnit()), firstStored.getAmount());
-			
-			SearchResult<ObjectHistoryEvent>
-				storedHistory =
-				this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(firstStored.getId()));
-			assertFalse(storedHistory.isEmpty());
-			UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
-			assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-			assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-		}
-		{
-			AmountStored secondStored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().getLast());
-			assertEquals(secondStoredFromSearch, secondStored);
-			assertEquals(Quantities.getQuantity(0, item.getUnit()), secondStored.getAmount());
-			
-			SearchResult<ObjectHistoryEvent>
-				storedHistory =
-				this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(secondStored.getId()));
-			assertFalse(storedHistory.isEmpty());
-			UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
-			assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-			assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-		}
-	}
-	
-	@Test
-	public void applyTransferAmountSuccessBulkInBlock() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.BULK, entity);
-		ObjectId firstBlock = item.getStorageBlocks().getFirst();
-		ObjectId secondBlock = this.storageBlockService.add(
-			DEFAULT_TEST_DB_NAME,
-			StorageBlock.builder().label(FAKER.location().building()).build(),
-			entity
-		).getId();
-		item.getStorageBlocks().add(secondBlock);
-		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
-		
-		ObjectId initialStoredId = this.storedService.add(
-			DEFAULT_TEST_DB_NAME, AmountStored.builder()
-									  .item(item.getId())
-									  .storageBlock(firstBlock)
-									  .amount(Quantities.getQuantity(5, item.getUnit()))
-									  .build(),
-			entity
-		).getId();
-		ObjectId destinationStoredId = this.storedService.add(
-			DEFAULT_TEST_DB_NAME, AmountStored.builder()
-									  .item(item.getId())
-									  .storageBlock(secondBlock)
-									  .amount(Quantities.getQuantity(0, item.getUnit()))
-									  .build(),
-			entity
-		).getId();
-		
-		ItemStoredTransaction preApplyTransaction = TransferAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.fromBlock(firstBlock)
-														.toBlock(secondBlock)
-														.build();
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(2, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		assertEquals(2, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(5, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 2);
-		//'first' and 'second' are flipped here
-		AmountStored firstStoredFromSearch = (AmountStored) storedSearchResult.getResults().get(0);
-		AmountStored secondStoredFromSearch = (AmountStored) storedSearchResult.getResults().get(1);
-		
-		{
-			AmountStored firstStored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().getFirst());
-			assertEquals(firstStoredFromSearch, firstStored);
-			assertEquals(Quantities.getQuantity(5, item.getUnit()), firstStored.getAmount());
-			
-			SearchResult<ObjectHistoryEvent>
-				storedHistory =
-				this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(firstStored.getId()));
-			assertFalse(storedHistory.isEmpty());
-			UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
-			assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-			assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-		}
-		{
-			AmountStored secondStored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().getLast());
-			assertEquals(secondStoredFromSearch, secondStored);
-			assertEquals(Quantities.getQuantity(0, item.getUnit()), secondStored.getAmount());
-			
-			SearchResult<ObjectHistoryEvent>
-				storedHistory =
-				this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(secondStored.getId()));
-			assertFalse(storedHistory.isEmpty());
-			UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
-			assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-			assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-		}
-	}
-	
-	@Test
-	public void applyTransferAmountSuccessBulkFromBlockToStored() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.BULK, entity);
-		ObjectId firstBlock = item.getStorageBlocks().getFirst();
-		ObjectId secondBlock = this.storageBlockService.add(
-			DEFAULT_TEST_DB_NAME,
-			StorageBlock.builder().label(FAKER.location().building()).build(),
-			entity
-		).getId();
-		item.getStorageBlocks().add(secondBlock);
-		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
-		
-		ObjectId initialStoredId = this.storedService.add(
-			DEFAULT_TEST_DB_NAME, AmountStored.builder()
-									  .item(item.getId())
-									  .storageBlock(firstBlock)
-									  .amount(Quantities.getQuantity(5, item.getUnit()))
-									  .build(),
-			entity
-		).getId();
-		ObjectId destinationStoredId = this.storedService.add(
-			DEFAULT_TEST_DB_NAME, AmountStored.builder()
-									  .item(item.getId())
-									  .storageBlock(secondBlock)
-									  .amount(Quantities.getQuantity(0, item.getUnit()))
-									  .build(),
-			entity
-		).getId();
-		
-		ItemStoredTransaction preApplyTransaction = TransferAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.fromBlock(firstBlock)
-														.toBlock(secondBlock)
-														.toStored(destinationStoredId)
-														.build();
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(2, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		assertEquals(2, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(5, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 2);
-		//'first' and 'second' are flipped here
-		AmountStored firstStoredFromSearch = (AmountStored) storedSearchResult.getResults().get(0);
-		AmountStored secondStoredFromSearch = (AmountStored) storedSearchResult.getResults().get(1);
-		
-		{
-			AmountStored firstStored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().getFirst());
-			assertEquals(firstStoredFromSearch, firstStored);
-			assertEquals(Quantities.getQuantity(5, item.getUnit()), firstStored.getAmount());
-			
-			SearchResult<ObjectHistoryEvent>
-				storedHistory =
-				this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(firstStored.getId()));
-			assertFalse(storedHistory.isEmpty());
-			UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
-			assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-			assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-		}
-		{
-			AmountStored secondStored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().getLast());
-			assertEquals(secondStoredFromSearch, secondStored);
-			assertEquals(Quantities.getQuantity(0, item.getUnit()), secondStored.getAmount());
-			
-			SearchResult<ObjectHistoryEvent>
-				storedHistory =
-				this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(secondStored.getId()));
-			assertFalse(storedHistory.isEmpty());
-			UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
-			assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-			assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-		}
-	}
-	
-	@Test
-	public void applyTransferAmountSuccessBulkFromStoredToBlock() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.BULK, entity);
-		ObjectId firstBlock = item.getStorageBlocks().getFirst();
-		ObjectId secondBlock = this.storageBlockService.add(
-			DEFAULT_TEST_DB_NAME,
-			StorageBlock.builder().label(FAKER.location().building()).build(),
-			entity
-		).getId();
-		item.getStorageBlocks().add(secondBlock);
-		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
-		
-		ObjectId initialStoredId = this.storedService.add(
-			DEFAULT_TEST_DB_NAME, AmountStored.builder()
-									  .item(item.getId())
-									  .storageBlock(firstBlock)
-									  .amount(Quantities.getQuantity(5, item.getUnit()))
-									  .build(),
-			entity
-		).getId();
-		ObjectId destinationStoredId = this.storedService.add(
-			DEFAULT_TEST_DB_NAME, AmountStored.builder()
-									  .item(item.getId())
-									  .storageBlock(secondBlock)
-									  .amount(Quantities.getQuantity(0, item.getUnit()))
-									  .build(),
-			entity
-		).getId();
-		
-		ItemStoredTransaction preApplyTransaction = TransferAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.fromBlock(firstBlock)
-														.fromStored(initialStoredId)
-														.toBlock(secondBlock)
-														.build();
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(2, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		assertEquals(2, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(5, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 2);
-		//'first' and 'second' are flipped here
-		AmountStored firstStoredFromSearch = (AmountStored) storedSearchResult.getResults().get(0);
-		AmountStored secondStoredFromSearch = (AmountStored) storedSearchResult.getResults().get(1);
-		
-		{
-			AmountStored firstStored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().getFirst());
-			assertEquals(firstStoredFromSearch, firstStored);
-			assertEquals(Quantities.getQuantity(5, item.getUnit()), firstStored.getAmount());
-			
-			SearchResult<ObjectHistoryEvent>
-				storedHistory =
-				this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(firstStored.getId()));
-			assertFalse(storedHistory.isEmpty());
-			UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
-			assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-			assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-		}
-		{
-			AmountStored secondStored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().getLast());
-			assertEquals(secondStoredFromSearch, secondStored);
-			assertEquals(Quantities.getQuantity(0, item.getUnit()), secondStored.getAmount());
-			
-			SearchResult<ObjectHistoryEvent>
-				storedHistory =
-				this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(secondStored.getId()));
-			assertFalse(storedHistory.isEmpty());
-			UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
-			assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-			assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-		}
-	}
-	
-	@Test
-	public void applyTransferAmountSuccessList() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
-		ObjectId firstBlock = item.getStorageBlocks().getFirst();
-		ObjectId secondBlock = this.storageBlockService.add(
-			DEFAULT_TEST_DB_NAME,
-			StorageBlock.builder().label(FAKER.location().building()).build(),
-			entity
-		).getId();
-		item.getStorageBlocks().add(secondBlock);
-		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
-		
-		ObjectId initialStoredId = this.storedService.add(
-			DEFAULT_TEST_DB_NAME, AmountStored.builder()
-									  .item(item.getId())
-									  .storageBlock(firstBlock)
-									  .amount(Quantities.getQuantity(5, item.getUnit()))
-									  .build(),
-			entity
-		).getId();
-		ObjectId destinationStoredId = this.storedService.add(
-			DEFAULT_TEST_DB_NAME, AmountStored.builder()
-									  .item(item.getId())
-									  .storageBlock(secondBlock)
-									  .amount(Quantities.getQuantity(0, item.getUnit()))
-									  .build(),
-			entity
-		).getId();
-		
-		ItemStoredTransaction preApplyTransaction = TransferAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.fromBlock(firstBlock)
-														.fromStored(initialStoredId)
-														.toBlock(secondBlock)
-														.toStored(destinationStoredId)
-														.build();
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(2, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		assertEquals(2, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(5, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 2);
-		//'first' and 'second' are flipped here
-		AmountStored firstStoredFromSearch = (AmountStored) storedSearchResult.getResults().get(0);
-		AmountStored secondStoredFromSearch = (AmountStored) storedSearchResult.getResults().get(1);
-		
-		{
-			AmountStored firstStored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().getFirst());
-			assertEquals(firstStoredFromSearch, firstStored);
-			assertEquals(Quantities.getQuantity(5, item.getUnit()), firstStored.getAmount());
-			
-			SearchResult<ObjectHistoryEvent>
-				storedHistory =
-				this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(firstStored.getId()));
-			assertFalse(storedHistory.isEmpty());
-			UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
-			assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-			assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-		}
-		{
-			AmountStored secondStored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().getLast());
-			assertEquals(secondStoredFromSearch, secondStored);
-			assertEquals(Quantities.getQuantity(0, item.getUnit()), secondStored.getAmount());
-			
-			SearchResult<ObjectHistoryEvent>
-				storedHistory =
-				this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(secondStored.getId()));
-			assertFalse(storedHistory.isEmpty());
-			UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
-			assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-			assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-		}
-	}
-	
-	@Test
-	public void applyTransferAmountSuccessListToNonExistent() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
-		ObjectId firstBlock = item.getStorageBlocks().getFirst();
-		ObjectId secondBlock = this.storageBlockService.add(
-			DEFAULT_TEST_DB_NAME,
-			StorageBlock.builder().label(FAKER.location().building()).build(),
-			entity
-		).getId();
-		item.getStorageBlocks().add(secondBlock);
-		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
-		
-		ObjectId initialStoredId = this.storedService.add(
-			DEFAULT_TEST_DB_NAME, AmountStored.builder()
-									  .item(item.getId())
-									  .storageBlock(firstBlock)
-									  .amount(Quantities.getQuantity(5, item.getUnit()))
-									  .build(),
-			entity
-		).getId();
-		
-		ItemStoredTransaction preApplyTransaction = TransferAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.fromBlock(firstBlock)
-														.fromStored(initialStoredId)
-														.toBlock(secondBlock)
-														.build();
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(2, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		assertEquals(2, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(5, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 2);
-		//'first' and 'second' are flipped here
-		AmountStored firstStoredFromSearch = (AmountStored) storedSearchResult.getResults().get(0);
-		AmountStored secondStoredFromSearch = (AmountStored) storedSearchResult.getResults().get(1);
-		
-		{
-			AmountStored firstStored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().getFirst());
-			assertEquals(firstStoredFromSearch, firstStored);
-			assertEquals(Quantities.getQuantity(5, item.getUnit()), firstStored.getAmount());
-			
-			SearchResult<ObjectHistoryEvent>
-				storedHistory =
-				this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(firstStored.getId()));
-			assertFalse(storedHistory.isEmpty());
-			UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
-			assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-			assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-		}
-		{
-			AmountStored secondStored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().getLast());
-			assertEquals(secondStoredFromSearch, secondStored);
-			assertEquals(Quantities.getQuantity(0, item.getUnit()), secondStored.getAmount());
-			
-			SearchResult<ObjectHistoryEvent>
-				storedHistory =
-				this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(secondStored.getId()));
-			assertFalse(storedHistory.isEmpty());
-			UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
-			assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-			assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-		}
-	}
-	
-	
-	@Test
-	public void applyTransferAmountFailUniqueMulti() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.UNIQUE_MULTI, entity);
-		ObjectId firstBlock = item.getStorageBlocks().getFirst();
-		ObjectId secondBlock = this.storageBlockService.add(
-			DEFAULT_TEST_DB_NAME,
-			StorageBlock.builder().label(FAKER.location().building()).build(),
-			entity
-		).getId();
-		
-		ItemStoredTransaction preApplyTransaction = TransferAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.fromBlock(firstBlock)
-														.toBlock(secondBlock)
-														.build();
-		
-		
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("Cannot subtract an amount from a unique item.", e.getMessage());
-	}
-	
-	@Test
-	public void applyTransferAmountFailUniqueSingle() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.UNIQUE_SINGLE, entity);
-		ObjectId firstBlock = item.getStorageBlocks().getFirst();
-		ObjectId secondBlock = this.storageBlockService.add(
-			DEFAULT_TEST_DB_NAME,
-			StorageBlock.builder().label(FAKER.location().building()).build(),
-			entity
-		).getId();
-		
-		ItemStoredTransaction preApplyTransaction = TransferAmountTransaction.builder()
-														.amount(Quantities.getQuantity(5, item.getUnit()))
-														.fromBlock(firstBlock)
-														.toBlock(secondBlock)
-														.build();
-		
-		
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("Cannot subtract an amount from a unique item.", e.getMessage());
-	}
-	
-	@Test
-	public void applyTransferAmountFailBulkNotEnoughToTransfer() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.BULK, entity);
-		ObjectId firstBlock = item.getStorageBlocks().getFirst();
-		ObjectId secondBlock = this.storageBlockService.add(
-			DEFAULT_TEST_DB_NAME,
-			StorageBlock.builder().label(FAKER.location().building()).build(),
-			entity
-		).getId();
-		item.getStorageBlocks().add(secondBlock);
-		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
-		
-		ObjectId initialStoredId = this.storedService.add(
-			DEFAULT_TEST_DB_NAME, AmountStored.builder()
-									  .item(item.getId())
-									  .storageBlock(firstBlock)
-									  .amount(Quantities.getQuantity(5, item.getUnit()))
-									  .build(),
-			entity
-		).getId();
-		
-		ItemStoredTransaction preApplyTransaction = TransferAmountTransaction.builder()
-														.amount(Quantities.getQuantity(6, item.getUnit()))
-														.fromBlock(firstBlock)
-														.toBlock(secondBlock)
-														.build();
-		
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("Resulting amount less than zero. (subtracting 6 units from 5 units resulting in -1 units)", e.getMessage());
-	}
-	
-	@Test
-	public void applyTransferAmountFailAmtListNotEnoughToTransfer() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
-		ObjectId firstBlock = item.getStorageBlocks().getFirst();
-		ObjectId secondBlock = this.storageBlockService.add(
-			DEFAULT_TEST_DB_NAME,
-			StorageBlock.builder().label(FAKER.location().building()).build(),
-			entity
-		).getId();
-		item.getStorageBlocks().add(secondBlock);
-		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
-		
-		ObjectId initialStoredId = this.storedService.add(
-			DEFAULT_TEST_DB_NAME, AmountStored.builder()
-									  .item(item.getId())
-									  .storageBlock(firstBlock)
-									  .amount(Quantities.getQuantity(5, item.getUnit()))
-									  .build(),
-			entity
-		).getId();
-		
-		ItemStoredTransaction preApplyTransaction = TransferAmountTransaction.builder()
-														.amount(Quantities.getQuantity(6, item.getUnit()))
-														.fromBlock(firstBlock)
-														.fromStored(initialStoredId)
-														.toBlock(secondBlock)
-														.build();
-		
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("Resulting amount less than zero. (subtracting 6 units from 5 units resulting in -1 units)", e.getMessage());
-	}
-	
-	@Test
-	public void applyTransferAmountFailBulkMismatchedStoredId() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.BULK, entity);
-		ObjectId firstBlock = item.getStorageBlocks().getFirst();
-		ObjectId secondBlock = this.storageBlockService.add(
-			DEFAULT_TEST_DB_NAME,
-			StorageBlock.builder().label(FAKER.location().building()).build(),
-			entity
-		).getId();
-		item.getStorageBlocks().add(secondBlock);
-		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
-		
-		ObjectId initialStoredId = this.storedService.add(
-			DEFAULT_TEST_DB_NAME, AmountStored.builder()
-									  .item(item.getId())
-									  .storageBlock(firstBlock)
-									  .amount(Quantities.getQuantity(5, item.getUnit()))
-									  .build(),
-			entity
-		).getId();
-		ObjectId destinationStoredId = this.storedService.add(
-			DEFAULT_TEST_DB_NAME, AmountStored.builder()
-									  .item(item.getId())
-									  .storageBlock(secondBlock)
-									  .amount(Quantities.getQuantity(0, item.getUnit()))
-									  .build(),
-			entity
-		).getId();
-		
-		ItemStoredTransaction preApplyTransaction = TransferAmountTransaction.builder()
-														.amount(Quantities.getQuantity(6, item.getUnit()))
-														.fromBlock(firstBlock)
-														.fromStored(destinationStoredId)
-														.toBlock(secondBlock)
-														.build();
-		
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("From Stored retrieved not in specified block.", e.getMessage());
-	}
-	
-	@Test
-	public void applyTransferAmountFailBulkMismatchedBlockTo() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.BULK, entity);
-		ObjectId firstBlock = item.getStorageBlocks().getFirst();
-		ObjectId secondBlock = this.storageBlockService.add(
-			DEFAULT_TEST_DB_NAME,
-			StorageBlock.builder().label(FAKER.location().building()).build(),
-			entity
-		).getId();
-		item.getStorageBlocks().add(secondBlock);
-		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
-		
-		ObjectId initialStoredId = this.storedService.add(
-			DEFAULT_TEST_DB_NAME, AmountStored.builder()
-									  .item(item.getId())
-									  .storageBlock(firstBlock)
-									  .amount(Quantities.getQuantity(5, item.getUnit()))
-									  .build(),
-			entity
-		).getId();
-		ObjectId destinationStoredId = this.storedService.add(
-			DEFAULT_TEST_DB_NAME, AmountStored.builder()
-									  .item(item.getId())
-									  .storageBlock(secondBlock)
-									  .amount(Quantities.getQuantity(0, item.getUnit()))
-									  .build(),
-			entity
-		).getId();
-		
-		ItemStoredTransaction preApplyTransaction = TransferAmountTransaction.builder()
-														.amount(Quantities.getQuantity(6, item.getUnit()))
-														.fromBlock(firstBlock)
-														.toBlock(secondBlock)
-														.toStored(initialStoredId)
-														.build();
-		
-		IllegalArgumentException
-			e =
-			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("To Stored retrieved not in specified block.", e.getMessage());
-	}
-	
-	//TODO:: any more?
-	//</editor-fold>
-	//<editor-fold desc="Apply- Transfer Whole">
-	
-	@Test
-	public void applyTransferWholeSuccessBulk() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.BULK, entity);
-		ObjectId firstBlock = item.getStorageBlocks().getFirst();
-		ObjectId secondBlock = this.storageBlockService.add(
-			DEFAULT_TEST_DB_NAME,
-			StorageBlock.builder().label(FAKER.location().building()).build(),
-			entity
-		).getId();
-		item.getStorageBlocks().add(secondBlock);
-		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
-		
-		ObjectId initialStoredId = this.storedService.add(
-			DEFAULT_TEST_DB_NAME, AmountStored.builder()
-									  .item(item.getId())
-									  .storageBlock(firstBlock)
-									  .amount(Quantities.getQuantity(5, item.getUnit()))
-									  .build(),
-			entity
-		).getId();
-		
-		ItemStoredTransaction preApplyTransaction = TransferWholeTransaction.builder()
-														.fromBlock(firstBlock)
-														.toBlock(secondBlock)
-														.build();
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(1, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(5, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 1);
-		AmountStored firstStoredFromSearch = (AmountStored) storedSearchResult.getResults().get(0);
-		
-		{
-			AmountStored firstStored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().getFirst());
-			assertEquals(firstStoredFromSearch, firstStored);
-			assertEquals(Quantities.getQuantity(5, item.getUnit()), firstStored.getAmount());
-			
-			SearchResult<ObjectHistoryEvent>
-				storedHistory =
-				this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(firstStored.getId()));
-			assertFalse(storedHistory.isEmpty());
-			UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
-			assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-			assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-		}
-	}
-	
-	@Test
-	public void applyTransferWholeSuccessAmtList() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
-		ObjectId firstBlock = item.getStorageBlocks().getFirst();
-		ObjectId secondBlock = this.storageBlockService.add(
-			DEFAULT_TEST_DB_NAME,
-			StorageBlock.builder().label(FAKER.location().building()).build(),
-			entity
-		).getId();
-		item.getStorageBlocks().add(secondBlock);
-		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
-		
-		ObjectId initialStoredId = this.storedService.add(
-			DEFAULT_TEST_DB_NAME, AmountStored.builder()
-									  .item(item.getId())
-									  .storageBlock(firstBlock)
-									  .amount(Quantities.getQuantity(5, item.getUnit()))
-									  .build(),
-			entity
-		).getId();
-		
-		ItemStoredTransaction preApplyTransaction = TransferWholeTransaction.builder()
-														.fromBlock(firstBlock)
-														.storedToTransfer(initialStoredId)
-														.toBlock(secondBlock)
-														.build();
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(1, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(5, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 1);
-		AmountStored firstStoredFromSearch = (AmountStored) storedSearchResult.getResults().get(0);
-		
-		{
-			AmountStored firstStored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().getFirst());
-			assertEquals(firstStoredFromSearch, firstStored);
-			assertEquals(Quantities.getQuantity(5, item.getUnit()), firstStored.getAmount());
-			
-			SearchResult<ObjectHistoryEvent>
-				storedHistory =
-				this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(firstStored.getId()));
-			assertFalse(storedHistory.isEmpty());
-			UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
-			assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-			assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-		}
-	}
-	
-	@Test
-	public void applyTransferWholeSuccessUniqueMulti() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.UNIQUE_MULTI, entity);
-		ObjectId firstBlock = item.getStorageBlocks().getFirst();
-		ObjectId secondBlock = this.storageBlockService.add(
-			DEFAULT_TEST_DB_NAME,
-			StorageBlock.builder().label(FAKER.location().building()).build(),
-			entity
-		).getId();
-		item.getStorageBlocks().add(secondBlock);
-		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
-		
-		ObjectId initialStoredId = this.storedService.add(
-			DEFAULT_TEST_DB_NAME, UniqueStored.builder()
-									  .item(item.getId())
-									  .storageBlock(firstBlock)
-									  .build(),
-			entity
-		).getId();
-		
-		ItemStoredTransaction preApplyTransaction = TransferWholeTransaction.builder()
-														.fromBlock(firstBlock)
-														.storedToTransfer(initialStoredId)
-														.toBlock(secondBlock)
-														.build();
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(1, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(1, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 1);
-		UniqueStored firstStoredFromSearch = (UniqueStored) storedSearchResult.getResults().get(0);
-		
-		{
-			UniqueStored firstStored = (UniqueStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().getFirst());
-			assertEquals(firstStoredFromSearch, firstStored);
-			
-			SearchResult<ObjectHistoryEvent>
-				storedHistory =
-				this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(firstStored.getId()));
-			assertFalse(storedHistory.isEmpty());
-			UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
-			assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-			assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-		}
-	}
-	
-	
-	@Test
-	public void applyTransferWholeSuccessUniqueSingle() throws Exception {
-		InteractingEntity entity = this.getTestUserService().getTestUser();
-		InventoryItem item = setupItem(StorageType.UNIQUE_SINGLE, entity);
-		ObjectId firstBlock = item.getStorageBlocks().getFirst();
-		ObjectId secondBlock = this.storageBlockService.add(
-			DEFAULT_TEST_DB_NAME,
-			StorageBlock.builder().label(FAKER.location().building()).build(),
-			entity
-		).getId();
-		item.getStorageBlocks().add(secondBlock);
-		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
-		
-		ObjectId initialStoredId = this.storedService.add(
-			DEFAULT_TEST_DB_NAME, UniqueStored.builder()
-									  .item(item.getId())
-									  .storageBlock(firstBlock)
-									  .build(),
-			entity
-		).getId();
-		
-		ItemStoredTransaction preApplyTransaction = TransferWholeTransaction.builder()
-														.fromBlock(firstBlock)
-														.storedToTransfer(initialStoredId)
-														.toBlock(secondBlock)
-														.build();
-		
-		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-		
-		assertEquals(entity.getId(), appliedTransaction.getEntity());
-		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
-		assertEquals(1, appliedTransaction.getAffectedStored().size());
-		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
-		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
-		
-		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
-		assertEquals(Quantities.getQuantity(1, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
-		//TODO:: storage block stats
-		
-		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
-		assertEquals(storedSearchResult.getNumResults(), 1);
-		UniqueStored firstStoredFromSearch = (UniqueStored) storedSearchResult.getResults().get(0);
-		
-		{
-			UniqueStored firstStored = (UniqueStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().getFirst());
-			assertEquals(firstStoredFromSearch, firstStored);
-			
-			SearchResult<ObjectHistoryEvent>
-				storedHistory =
-				this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(firstStored.getId()));
-			assertFalse(storedHistory.isEmpty());
-			UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
-			assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
-			assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
-		}
-	}
-	
-	
-	//TODO:: any more?
-	//</editor-fold>
-	//<editor-fold desc="Post transaction processing">
-	//TODO:: fix these, inconsistent and flaky
-	//	@Test
-	//	public void applyTransactionPostProcessNoChange() throws Exception {
-	//		InteractingEntity entity = this.getTestUserService().getTestUser();
-	//		InventoryItem item = setupItem(StorageType.BULK, entity);
-	//
-	//		ItemStoredTransaction preApplyTransaction = AddAmountTransaction.builder()
-	//			.amount(Quantities.getQuantity(5, item.getUnit()))
-	//			.toBlock(item.getStorageBlocks().getFirst())
-	//			.build();
-	//
-	//		this.clearQueues();
-	//		ObjectId appliedTransactionId = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-	//		AppliedTransaction appliedTransaction = this.appliedTransactionService.get(DEFAULT_TEST_DB_NAME, appliedTransactionId);
-	//
-	//		List<EventNotificationWrapper> messages = this.assertMessages(EventType.CREATE, EventType.UPDATE);
-	//		//TODO:: verify messages
-	//	}
-	//
-	//	@Test
-	//	public void applyTransactionPostProcessStoredLowStock() throws Exception {
-	//		InteractingEntity entity = this.getTestUserService().getTestUser();
-	//		InventoryItem item = setupItem(StorageType.BULK, entity);
-	//
-	//		AmountStored originalStored = AmountStored.builder()
-	//			.item(item.getId())
-	//			.storageBlock(item.getStorageBlocks().getFirst())
-	//			.amount(Quantities.getQuantity(5, item.getUnit()))
-	//			.lowStockThreshold(Quantities.getQuantity(20, item.getUnit()))
-	//			.build();
-	//		this.storedService.add(DEFAULT_TEST_DB_NAME, originalStored, entity);
-	//
-	//		ItemStoredTransaction preApplyTransaction = AddAmountTransaction.builder()
-	//			.amount(Quantities.getQuantity(5, item.getUnit()))
-	//			.toBlock(item.getStorageBlocks().getFirst())
-	//			.build();
-	//
-	//		this.clearQueues();
-	//		ObjectId appliedTransactionId = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
-	//		AppliedTransaction appliedTransaction = this.appliedTransactionService.get(DEFAULT_TEST_DB_NAME, appliedTransactionId);
-	//
-	//		List<EventNotificationWrapper> messages = this.assertMessages(EventType.UPDATE, EventType.UPDATE, EventType.UPDATE, EventType.ITEM_LOW_STOCK);
-	//		//TODO:: assert events, notification state
-	//	}
-	
-	
-	//TODO:: low stock (stored)
-	//TODO:: low stock (item)
-	//TODO:: expiry warn alert
-	//TODO:: expired alert
-	//</editor-fold>
-}
\ No newline at end of file
diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/AddAmountAppliedTransactionTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/AddAmountAppliedTransactionTest.java
new file mode 100644
index 000000000..87a642982
--- /dev/null
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/AddAmountAppliedTransactionTest.java
@@ -0,0 +1,341 @@
+package tech.ebp.oqm.core.api.service.mongo.transactions.transactionApplier;
+
+import io.quarkus.test.common.QuarkusTestResource;
+import io.quarkus.test.junit.QuarkusTest;
+import io.quarkus.test.kafka.KafkaCompanionResource;
+import jakarta.validation.ValidationException;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.kafka.common.errors.UnknownTopicOrPartitionException;
+import org.bson.types.ObjectId;
+import org.junit.jupiter.api.Test;
+import tech.ebp.oqm.core.api.model.object.history.ObjectHistoryEvent;
+import tech.ebp.oqm.core.api.model.object.history.details.ItemTransactionDetail;
+import tech.ebp.oqm.core.api.model.object.history.events.UpdateEvent;
+import tech.ebp.oqm.core.api.model.object.interactingEntity.InteractingEntity;
+import tech.ebp.oqm.core.api.model.object.storage.items.InventoryItem;
+import tech.ebp.oqm.core.api.model.object.storage.items.StorageType;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.AmountStored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.Stored;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.AppliedTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.ItemStoredTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.add.AddAmountTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.storageBlock.StorageBlock;
+import tech.ebp.oqm.core.api.model.rest.search.HistorySearch;
+import tech.ebp.oqm.core.api.model.rest.search.StoredSearch;
+import tech.ebp.oqm.core.api.service.mongo.search.SearchResult;
+import tech.units.indriya.quantity.Quantities;
+
+import java.time.ZonedDateTime;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static tech.ebp.oqm.core.api.model.object.history.details.HistoryDetailType.ITEM_TRANSACTION;
+import static tech.ebp.oqm.core.api.testResources.TestConstants.DEFAULT_TEST_DB_NAME;
+
+@Slf4j
+@QuarkusTest
+@QuarkusTestResource(value = KafkaCompanionResource.class, restrictToAnnotatedClass = true)
+public class AddAmountAppliedTransactionTest extends AppliedTransactionServiceTest {
+	
+	@Test
+	public void applyAddAmountSuccessBulkNotInBlock() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.BULK, entity);
+		
+		
+		ItemStoredTransaction preApplyTransaction = AddAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.toBlock(item.getStorageBlocks().getFirst())
+														.build();
+		
+		try {
+			this.clearQueues();
+		} catch(UnknownTopicOrPartitionException e) {
+			log.warn("Failed to clear queues", e);
+		}
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(1, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		
+		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(5, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 1);
+		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
+		
+		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
+		assertEquals(storedFromSearch, stored);
+		assertEquals(Quantities.getQuantity(5, item.getUnit()), stored.getAmount());
+		
+		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
+		assertFalse(storedHistory.isEmpty());
+		UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
+		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+		
+		//TODO:: this, #1080
+		//		List<EventNotificationWrapper> messages = this.assertMessages(
+		//			EventType.CREATE,
+		//			EventType.UPDATE
+		//		);
+		//TODO:: verify messages
+	}
+	
+	@Test
+	public void applyAddAmountSuccessBulkAlreadyInBlock() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.BULK, entity);
+		
+		AmountStored originalStored = AmountStored.builder()
+										  .item(item.getId())
+										  .storageBlock(item.getStorageBlocks().getFirst())
+										  .amount(Quantities.getQuantity(5, item.getUnit()))
+										  .build();
+		this.storedService.add(DEFAULT_TEST_DB_NAME, originalStored, entity);
+		
+		
+		ItemStoredTransaction preApplyTransaction = AddAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.toBlock(item.getStorageBlocks().getFirst())
+														.build();
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(1, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(10, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 1);
+		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
+		
+		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
+		assertEquals(originalStored.getId(), stored.getId());
+		assertEquals(storedFromSearch, stored);
+		assertEquals(Quantities.getQuantity(10, item.getUnit()), stored.getAmount());
+		
+		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
+		assertFalse(storedHistory.isEmpty());
+		UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
+		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+	}
+	
+	@Test
+	public void applyAddAmountSuccessAmtListNewEntry() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
+		
+		ItemStoredTransaction preApplyTransaction = AddAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.toBlock(item.getStorageBlocks().getFirst())
+														.build();
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(1, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(5, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 1);
+		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
+		
+		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
+		assertEquals(storedFromSearch, stored);
+		assertEquals(Quantities.getQuantity(5, item.getUnit()), stored.getAmount());
+		
+		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
+		assertFalse(storedHistory.isEmpty());
+		UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
+		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+	}
+	
+	@Test
+	public void applyAddAmountSuccessAmtListExistingStored() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
+		
+		AmountStored originalStored = AmountStored.builder()
+										  .item(item.getId())
+										  .storageBlock(item.getStorageBlocks().getFirst())
+										  .amount(Quantities.getQuantity(5, item.getUnit()))
+										  .build();
+		this.storedService.add(DEFAULT_TEST_DB_NAME, originalStored, entity);
+		
+		
+		ItemStoredTransaction preApplyTransaction = AddAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.toBlock(item.getStorageBlocks().getFirst())
+														.toStored(originalStored.getId())
+														.build();
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(1, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(10, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 1);
+		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
+		
+		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
+		assertEquals(originalStored.getId(), stored.getId());
+		assertEquals(storedFromSearch, stored);
+		assertEquals(Quantities.getQuantity(10, item.getUnit()), stored.getAmount());
+		
+		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
+		assertFalse(storedHistory.isEmpty());
+		UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
+		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+	}
+	
+	@Test
+	public void applyAddAmountFailUniqueMulti() {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.UNIQUE_MULTI, entity);
+		
+		ItemStoredTransaction preApplyTransaction = AddAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.toBlock(item.getStorageBlocks().getFirst())
+														.build();
+		
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("Cannot add an amount to a unique item.", e.getMessage());
+	}
+	
+	@Test
+	public void applyAddAmountFailUniqueSingle() {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.UNIQUE_SINGLE, entity);
+		
+		ItemStoredTransaction preApplyTransaction = AddAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.toBlock(item.getStorageBlocks().getFirst())
+														.build();
+		
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("Cannot add an amount to a unique item.", e.getMessage());
+	}
+	
+	@Test
+	public void applyAddAmountFailBulkBlockNotInInventory() {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.BULK, entity);
+		
+		ObjectId badBlockId = new ObjectId();
+		ItemStoredTransaction preApplyTransaction = AddAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.toBlock(badBlockId)
+														.build();
+		
+		ValidationException e = assertThrows(ValidationException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("Storage block " + badBlockId + " not used to hold this item (" + item.getId().toHexString() + ").", e.getMessage());
+	}
+	
+	@Test
+	public void applyAddAmountFailBulkStoredNotInBlock() {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.BULK, entity);
+		
+		ObjectId badStoredId = new ObjectId();
+		ItemStoredTransaction preApplyTransaction = AddAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.toStored(badStoredId)
+														.toBlock(item.getStorageBlocks().getFirst())
+														.build();
+		
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("To Stored given does not match stored found in block.", e.getMessage());
+	}
+	
+	@Test
+	public void applyAddAmountFailAmtListBadStored() {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
+		
+		ObjectId badStoredId = new ObjectId();
+		ItemStoredTransaction preApplyTransaction = AddAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.toStored(badStoredId)
+														.toBlock(item.getStorageBlocks().getFirst())
+														.build();
+		
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("Could not find Stored with id " + badStoredId, e.getMessage());
+	}
+	
+	@Test
+	public void applyAddAmountFailAmtListBadStoredNotInBlock() {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
+		
+		ObjectId origBlock = item.getStorageBlocks().getFirst();
+		ObjectId otherBlockId = this.storageBlockService.add(DEFAULT_TEST_DB_NAME, StorageBlock.builder().label(FAKER.location().building()).build(), entity).getId();
+		
+		item.getStorageBlocks().add(otherBlockId);
+		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
+		
+		AmountStored originalStored = AmountStored.builder()
+										  .item(item.getId())
+										  .storageBlock(origBlock)
+										  .amount(Quantities.getQuantity(5, item.getUnit()))
+										  .build();
+		this.storedService.add(DEFAULT_TEST_DB_NAME, originalStored, entity);
+		
+		ItemStoredTransaction preApplyTransaction = AddAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.toStored(originalStored.getId())
+														.toBlock(otherBlockId)
+														.build();
+		
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("To Stored given does not exist in block.", e.getMessage());
+	}
+	
+	//TODO:: any more?
+}
diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/AddWholeAppliedTransactionTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/AddWholeAppliedTransactionTest.java
new file mode 100644
index 000000000..0dcf5125d
--- /dev/null
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/AddWholeAppliedTransactionTest.java
@@ -0,0 +1,293 @@
+package tech.ebp.oqm.core.api.service.mongo.transactions.transactionApplier;
+
+import io.quarkus.test.common.QuarkusTestResource;
+import io.quarkus.test.junit.QuarkusTest;
+import io.quarkus.test.kafka.KafkaCompanionResource;
+import jakarta.validation.ValidationException;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.kafka.common.errors.UnknownTopicOrPartitionException;
+import org.bson.types.ObjectId;
+import org.junit.jupiter.api.Test;
+import tech.ebp.oqm.core.api.model.object.history.ObjectHistoryEvent;
+import tech.ebp.oqm.core.api.model.object.history.details.ItemTransactionDetail;
+import tech.ebp.oqm.core.api.model.object.history.events.CreateEvent;
+import tech.ebp.oqm.core.api.model.object.history.events.UpdateEvent;
+import tech.ebp.oqm.core.api.model.object.interactingEntity.InteractingEntity;
+import tech.ebp.oqm.core.api.model.object.storage.items.InventoryItem;
+import tech.ebp.oqm.core.api.model.object.storage.items.StorageType;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.AmountStored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.Stored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.UniqueStored;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.AppliedTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.ItemStoredTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.add.AddAmountTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.add.AddWholeTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.storageBlock.StorageBlock;
+import tech.ebp.oqm.core.api.model.rest.search.HistorySearch;
+import tech.ebp.oqm.core.api.model.rest.search.StoredSearch;
+import tech.ebp.oqm.core.api.service.mongo.search.SearchResult;
+import tech.units.indriya.quantity.Quantities;
+
+import java.time.ZonedDateTime;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static tech.ebp.oqm.core.api.model.object.history.details.HistoryDetailType.ITEM_TRANSACTION;
+import static tech.ebp.oqm.core.api.testResources.TestConstants.DEFAULT_TEST_DB_NAME;
+
+@Slf4j
+@QuarkusTest
+@QuarkusTestResource(value = KafkaCompanionResource.class, restrictToAnnotatedClass = true)
+public class AddWholeAppliedTransactionTest extends AppliedTransactionServiceTest {
+	
+	@Test
+	public void applyAddWholeSuccessAmtList() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
+		
+		ItemStoredTransaction preApplyTransaction = AddWholeTransaction.builder()
+														.toAdd(
+															AmountStored.builder()
+																.item(item.getId())
+																.amount(Quantities.getQuantity(5, item.getUnit()))
+																.storageBlock(item.getStorageBlocks().getFirst())
+																.build()
+														)
+														.toBlock(item.getStorageBlocks().getFirst())
+														.build();
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(1, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(5, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 1);
+		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
+		
+		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
+		assertEquals(storedFromSearch, stored);
+		assertEquals(Quantities.getQuantity(5, item.getUnit()), stored.getAmount());
+		
+		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
+		assertFalse(storedHistory.isEmpty());
+		CreateEvent event = (CreateEvent) storedHistory.getResults().getFirst();
+		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+	}
+	
+	@Test
+	public void applyAddWholeSuccessUniqueMulti() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.UNIQUE_MULTI, entity);
+		
+		ItemStoredTransaction preApplyTransaction = AddWholeTransaction.builder()
+														.toAdd(
+															UniqueStored.builder()
+																.item(item.getId())
+																.storageBlock(item.getStorageBlocks().getFirst())
+																.build()
+														)
+														.toBlock(item.getStorageBlocks().getFirst())
+														.build();
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(1, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(1, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 1);
+		UniqueStored storedFromSearch = (UniqueStored) storedSearchResult.getResults().getFirst();
+		
+		UniqueStored stored = (UniqueStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
+		assertEquals(storedFromSearch, stored);
+		
+		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
+		assertFalse(storedHistory.isEmpty());
+		CreateEvent event = (CreateEvent) storedHistory.getResults().getFirst();
+		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+	}
+	
+	@Test
+	public void applyAddWholeSuccessUniqueSingle() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.UNIQUE_SINGLE, entity);
+		
+		ItemStoredTransaction preApplyTransaction = AddWholeTransaction.builder()
+														.toAdd(
+															UniqueStored.builder()
+																.item(item.getId())
+																.storageBlock(item.getStorageBlocks().getFirst())
+																.build()
+														)
+														.toBlock(item.getStorageBlocks().getFirst())
+														.build();
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(1, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(1, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 1);
+		UniqueStored storedFromSearch = (UniqueStored) storedSearchResult.getResults().getFirst();
+		
+		UniqueStored stored = (UniqueStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
+		assertEquals(storedFromSearch, stored);
+		
+		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
+		assertFalse(storedHistory.isEmpty());
+		CreateEvent event = (CreateEvent) storedHistory.getResults().getFirst();
+		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+	}
+	
+	@Test
+	public void applyAddWholeFailBulk() {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.BULK, entity);
+		
+		ItemStoredTransaction preApplyTransaction = AddWholeTransaction.builder()
+														.toAdd(
+															AmountStored.builder()
+																.item(item.getId())
+																.amount(Quantities.getQuantity(5, item.getUnit()))
+																.storageBlock(item.getStorageBlocks().getFirst())
+																.build()
+														)
+														.toBlock(item.getStorageBlocks().getFirst())
+														.build();
+		
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("Cannot add whole item to a bulk storage typed item.", e.getMessage());
+	}
+	
+	@Test
+	public void applyAddWholeFailAnotherUniqueSingle() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.UNIQUE_SINGLE, entity);
+		
+		ItemStoredTransaction preApplyTransaction = AddWholeTransaction.builder()
+														.toAdd(
+															UniqueStored.builder()
+																.item(item.getId())
+																.storageBlock(item.getStorageBlocks().getFirst())
+																.build()
+														)
+														.toBlock(item.getStorageBlocks().getFirst())
+														.build();
+		
+		this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		ValidationException e = assertThrows(ValidationException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("Cannot add more than one stored held for type UNIQUE_SINGLE", e.getMessage());
+	}
+	
+	@Test
+	public void applyAddWholeFailMismatchedBlock() {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.UNIQUE_SINGLE, entity);
+		
+		ItemStoredTransaction preApplyTransaction = AddWholeTransaction.builder()
+														.toAdd(
+															UniqueStored.builder()
+																.item(item.getId())
+																.storageBlock(new ObjectId())
+																.build()
+														)
+														.toBlock(item.getStorageBlocks().getFirst())
+														.build();
+		
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("To Block given does not match block marked in stored.", e.getMessage());
+		
+		ItemStoredTransaction preApplyTransaction2 = AddWholeTransaction.builder()
+														 .toAdd(
+															 UniqueStored.builder()
+																 .item(item.getId())
+																 .storageBlock(item.getStorageBlocks().getFirst())
+																 .build()
+														 )
+														 .toBlock(new ObjectId())
+														 .build();
+		
+		e = assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction2, entity));
+		assertEquals("To Block given does not match block marked in stored.", e.getMessage());
+	}
+	
+	@Test
+	public void applyAddWholeFailBlockNotInItem() {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.UNIQUE_SINGLE, entity);
+		
+		ItemStoredTransaction preApplyTransaction = AddWholeTransaction.builder()
+														.toAdd(
+															UniqueStored.builder()
+																.item(item.getId())
+																.storageBlock(new ObjectId())
+																.build()
+														)
+														.toBlock(item.getStorageBlocks().getFirst())
+														.build();
+		
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("To Block given does not match block marked in stored.", e.getMessage());
+	}
+	
+	@Test
+	public void applyAddWholeFailItemMismatched() {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.UNIQUE_SINGLE, entity);
+		
+		ItemStoredTransaction preApplyTransaction = AddWholeTransaction.builder()
+														.toAdd(
+															UniqueStored.builder()
+																.item(new ObjectId())
+																.storageBlock(item.getStorageBlocks().getFirst())
+																.build()
+														)
+														.toBlock(item.getStorageBlocks().getFirst())
+														.build();
+		
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("Stored given is not associated with item.", e.getMessage());
+	}
+	
+	//TODO:: any more?
+}
diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/AppliedTransactionServiceTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/AppliedTransactionServiceTest.java
new file mode 100644
index 000000000..0fcf45414
--- /dev/null
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/AppliedTransactionServiceTest.java
@@ -0,0 +1,295 @@
+
+package tech.ebp.oqm.core.api.service.mongo.transactions.transactionApplier;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import io.quarkus.test.common.QuarkusTestResource;
+import io.quarkus.test.junit.QuarkusTest;
+import io.quarkus.test.kafka.InjectKafkaCompanion;
+import io.quarkus.test.kafka.KafkaCompanionResource;
+import io.smallrye.reactive.messaging.kafka.companion.ConsumerTask;
+import io.smallrye.reactive.messaging.kafka.companion.KafkaCompanion;
+import jakarta.inject.Inject;
+import jakarta.validation.ValidationException;
+import lombok.Getter;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.kafka.common.errors.UnknownTopicOrPartitionException;
+import org.bson.types.ObjectId;
+import org.junit.jupiter.api.Test;
+import tech.ebp.oqm.core.api.model.object.ObjectUtils;
+import tech.ebp.oqm.core.api.model.object.history.EventType;
+import tech.ebp.oqm.core.api.model.object.history.ObjectHistoryEvent;
+import tech.ebp.oqm.core.api.model.object.history.details.ItemTransactionDetail;
+import tech.ebp.oqm.core.api.model.object.history.events.CreateEvent;
+import tech.ebp.oqm.core.api.model.object.history.events.DeleteEvent;
+import tech.ebp.oqm.core.api.model.object.history.events.ReCreateEvent;
+import tech.ebp.oqm.core.api.model.object.history.events.UpdateEvent;
+import tech.ebp.oqm.core.api.model.object.interactingEntity.InteractingEntity;
+import tech.ebp.oqm.core.api.model.object.storage.checkout.CheckoutDetails;
+import tech.ebp.oqm.core.api.model.object.storage.checkout.ItemAmountCheckout;
+import tech.ebp.oqm.core.api.model.object.storage.checkout.ItemCheckout;
+import tech.ebp.oqm.core.api.model.object.storage.checkout.ItemWholeCheckout;
+import tech.ebp.oqm.core.api.model.object.storage.checkout.checkinDetails.ReturnFullCheckinDetails;
+import tech.ebp.oqm.core.api.model.object.storage.checkout.checkinDetails.checkedInBy.CheckedInByOqmEntity;
+import tech.ebp.oqm.core.api.model.object.storage.checkout.checkoutFor.CheckoutForOqmEntity;
+import tech.ebp.oqm.core.api.model.object.storage.items.InventoryItem;
+import tech.ebp.oqm.core.api.model.object.storage.items.StorageType;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.AmountStored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.Stored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.UniqueStored;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.AppliedTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.ItemStoredTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.add.AddAmountTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.add.AddWholeTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.checkin.CheckinFullTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.checkout.CheckoutAmountTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.checkout.CheckoutWholeTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.set.SetAmountTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.subtract.SubAmountTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.transfer.TransferAmountTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.transfer.TransferWholeTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.storageBlock.StorageBlock;
+import tech.ebp.oqm.core.api.model.rest.search.HistorySearch;
+import tech.ebp.oqm.core.api.model.rest.search.ItemCheckoutSearch;
+import tech.ebp.oqm.core.api.model.rest.search.StoredSearch;
+import tech.ebp.oqm.core.api.service.mongo.InventoryItemService;
+import tech.ebp.oqm.core.api.service.mongo.ItemCheckoutService;
+import tech.ebp.oqm.core.api.service.mongo.StorageBlockService;
+import tech.ebp.oqm.core.api.service.mongo.StoredService;
+import tech.ebp.oqm.core.api.service.mongo.search.SearchResult;
+import tech.ebp.oqm.core.api.model.messaging.EventNotificationWrapper;
+import tech.ebp.oqm.core.api.service.mongo.transactions.AppliedTransactionService;
+import tech.ebp.oqm.core.api.service.notification.HistoryEventNotificationService;
+import tech.ebp.oqm.core.api.testResources.data.InventoryItemTestObjectCreator;
+import tech.ebp.oqm.core.api.testResources.data.StorageBlockTestObjectCreator;
+import tech.ebp.oqm.core.api.testResources.testClasses.KafkaTest;
+import tech.ebp.oqm.core.api.testResources.testClasses.MongoObjectServiceTest;
+import tech.units.indriya.quantity.Quantities;
+
+import java.time.ZonedDateTime;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static tech.ebp.oqm.core.api.model.object.history.details.HistoryDetailType.ITEM_TRANSACTION;
+import static tech.ebp.oqm.core.api.testResources.TestConstants.DEFAULT_TEST_DB_NAME;
+
+/**
+ * TODO:: rework to test each class individually, test nominally here
+ */
+@Slf4j
+@QuarkusTest
+@QuarkusTestResource(value = KafkaCompanionResource.class, restrictToAnnotatedClass = true)
+abstract class AppliedTransactionServiceTest extends MongoObjectServiceTest<AppliedTransaction, AppliedTransactionService> implements KafkaTest {
+	
+	@Inject
+	AppliedTransactionService appliedTransactionService;
+	
+	@Inject
+	StorageBlockService storageBlockService;
+	
+	@Inject
+	StorageBlockTestObjectCreator storageBlockTestObjectCreator;
+	
+	@Inject
+	InventoryItemService inventoryItemService;
+	
+	@Inject
+	InventoryItemTestObjectCreator itemTestObjectCreator;
+	
+	@Inject
+	StoredService storedService;
+	
+	@Inject
+	ItemCheckoutService checkoutService;
+	
+	@Getter
+	@InjectKafkaCompanion
+	KafkaCompanion kafkaCompanion;
+	
+	//TODO:: these default tests
+	@Override
+	protected AppliedTransaction getTestObject() {
+		return null;//TODO
+	}
+	//
+	//	@Test
+	//	public void injectTest() {
+	//		assertNotNull(appliedTransactionService);
+	//	}
+	//
+	//	@Test
+	//	public void listTest() {
+	//		this.defaultListTest(this.appliedTransactionService);
+	//	}
+	//
+	//	@Test
+	//	public void countTest() {
+	//		this.defaultCountTest(this.appliedTransactionService);
+	//	}
+	//
+	//	@Test
+	//	public void addTest() {
+	//		this.defaultAddTest(this.appliedTransactionService);
+	//	}
+	//
+	//	@Test
+	//	public void getObjectIdTest() {
+	//		this.defaultGetObjectIdTest(this.appliedTransactionService);
+	//	}
+	//
+	//	@Test
+	//	public void getStringTest() {
+	//		this.defaultGetStringTest(this.appliedTransactionService);
+	//	}
+	//
+	//	@Test
+	//	public void removeAllTest() {
+	//		this.defaultRemoveAllTest(this.appliedTransactionService);
+	//	}
+	
+	
+	protected InventoryItem setupItem(StorageType storageType, InteractingEntity entity) {
+		StorageBlock storageBlock = storageBlockTestObjectCreator.getTestObject();
+		this.storageBlockService.add(DEFAULT_TEST_DB_NAME, storageBlock, entity);
+		InventoryItem item = this.itemTestObjectCreator.getTestObject().setStorageType(storageType);
+		item.getStorageBlocks().add(storageBlock.getId());
+		this.inventoryItemService.add(DEFAULT_TEST_DB_NAME, item, entity);
+		return item;
+	}
+	
+	protected void clearQueues() {
+		this.kafkaCompanion
+			.topics()
+			.delete(HistoryEventNotificationService.ALL_EVENT_TOPIC)
+		//			.clear(HistoryEventNotificationService.ALL_EVENT_TOPIC)
+		;
+	}
+	
+	//TODO:: this with all following tests
+	protected List<EventNotificationWrapper> assertMessages(
+		EventType... expectedEvents
+	) throws JsonProcessingException {
+		//TODO:: get list of all sent messages instead of predicted number
+		//		List<EventNotificationWrapper> eventWrappers = new ArrayList<>();
+		//		boolean awaiting = true;
+		//		do{
+		//			try {
+		//				eventWrappers.add(
+		//					ObjectUtils.OBJECT_MAPPER.readValue(
+		//						this.kafkaCompanion.consumeStrings()
+		//							.fromTopics(HistoryEventNotificationService.ALL_EVENT_TOPIC, 1)
+		//							.awaitCompletion(Duration.of(10, ChronoUnit.SECONDS))
+		//							.getFirstRecord().value(),
+		//
+		//
+		////						this.kafkaCompanion.consumeStrings()
+		////							.fromTopics(HistoryEventNotificationService.ALL_EVENT_TOPIC)
+		////							.awaitNextRecord(Duration.of(10, ChronoUnit.SECONDS))
+		//////							.stream().findFirst().get().value(),
+		//////							.getFirstRecord().value(),
+		//						EventNotificationWrapper.class
+		//					)
+		//				);
+		//				log.info("Got another wrapper");
+		//			} catch (AssertionError e){
+		//				awaiting = false;
+		//			}
+		//		}while(awaiting);
+		
+		
+		try {
+			
+			ConsumerTask<String, String> messagesFromAll = this.kafkaCompanion.consumeStrings().fromTopics(
+				HistoryEventNotificationService.ALL_EVENT_TOPIC
+				, expectedEvents.length
+			);
+			messagesFromAll.awaitCompletion();
+			assertEquals(expectedEvents.length, messagesFromAll.count());
+			
+			List<EventNotificationWrapper> eventWrappers = messagesFromAll.stream()
+															   .map(record->{
+																   try {
+																	   return ObjectUtils.OBJECT_MAPPER.readValue(record.value(), EventNotificationWrapper.class);
+																   } catch(JsonProcessingException e) {
+																	   throw new RuntimeException(e);
+																   }
+															   })
+															   .collect(Collectors.toList());
+			log.info("Found messages for transaction: {}", eventWrappers);
+			
+			assertEquals(expectedEvents.length, eventWrappers.size());
+			
+			for (int i = 0; i < expectedEvents.length; i++) {
+				EventNotificationWrapper curWrapper = eventWrappers.get(i);
+				EventType expectedType = expectedEvents[i];
+				
+				assertEquals(expectedType, curWrapper.getEvent().getType(), "Unexpected type of transaction at index " + i);
+			}
+			
+			return eventWrappers;
+		} catch(UnknownTopicOrPartitionException e) {
+			log.warn("Failed to clear queues", e);
+			throw e;
+		}
+	}
+	
+	//<editor-fold desc="Apply- Checkin Part">
+	//TODO:: When we have this implemented
+	//</editor-fold>
+	//<editor-fold desc="Apply- Checkin Loss">
+	//TODO:: When we have this implemented
+	//</editor-fold>
+	
+	//<editor-fold desc="Post transaction processing">
+	//TODO:: fix these, inconsistent and flaky
+	//	@Test
+	//	public void applyTransactionPostProcessNoChange() throws Exception {
+	//		InteractingEntity entity = this.getTestUserService().getTestUser();
+	//		InventoryItem item = setupItem(StorageType.BULK, entity);
+	//
+	//		ItemStoredTransaction preApplyTransaction = AddAmountTransaction.builder()
+	//			.amount(Quantities.getQuantity(5, item.getUnit()))
+	//			.toBlock(item.getStorageBlocks().getFirst())
+	//			.build();
+	//
+	//		this.clearQueues();
+	//		ObjectId appliedTransactionId = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+	//		AppliedTransaction appliedTransaction = this.appliedTransactionService.get(DEFAULT_TEST_DB_NAME, appliedTransactionId);
+	//
+	//		List<EventNotificationWrapper> messages = this.assertMessages(EventType.CREATE, EventType.UPDATE);
+	//		//TODO:: verify messages
+	//	}
+	//
+	//	@Test
+	//	public void applyTransactionPostProcessStoredLowStock() throws Exception {
+	//		InteractingEntity entity = this.getTestUserService().getTestUser();
+	//		InventoryItem item = setupItem(StorageType.BULK, entity);
+	//
+	//		AmountStored originalStored = AmountStored.builder()
+	//			.item(item.getId())
+	//			.storageBlock(item.getStorageBlocks().getFirst())
+	//			.amount(Quantities.getQuantity(5, item.getUnit()))
+	//			.lowStockThreshold(Quantities.getQuantity(20, item.getUnit()))
+	//			.build();
+	//		this.storedService.add(DEFAULT_TEST_DB_NAME, originalStored, entity);
+	//
+	//		ItemStoredTransaction preApplyTransaction = AddAmountTransaction.builder()
+	//			.amount(Quantities.getQuantity(5, item.getUnit()))
+	//			.toBlock(item.getStorageBlocks().getFirst())
+	//			.build();
+	//
+	//		this.clearQueues();
+	//		ObjectId appliedTransactionId = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+	//		AppliedTransaction appliedTransaction = this.appliedTransactionService.get(DEFAULT_TEST_DB_NAME, appliedTransactionId);
+	//
+	//		List<EventNotificationWrapper> messages = this.assertMessages(EventType.UPDATE, EventType.UPDATE, EventType.UPDATE, EventType.ITEM_LOW_STOCK);
+	//		//TODO:: assert events, notification state
+	//	}
+	
+	
+	//TODO:: low stock (stored)
+	//TODO:: low stock (item)
+	//TODO:: expiry warn alert
+	//TODO:: expired alert
+	//</editor-fold>
+}
\ No newline at end of file
diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/CheckinFullAmountAppliedTransactionTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/CheckinFullAmountAppliedTransactionTest.java
new file mode 100644
index 000000000..fcc00a63b
--- /dev/null
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/CheckinFullAmountAppliedTransactionTest.java
@@ -0,0 +1,426 @@
+package tech.ebp.oqm.core.api.service.mongo.transactions.transactionApplier;
+
+import io.quarkus.test.common.QuarkusTestResource;
+import io.quarkus.test.junit.QuarkusTest;
+import io.quarkus.test.kafka.KafkaCompanionResource;
+import jakarta.validation.ValidationException;
+import lombok.extern.slf4j.Slf4j;
+import org.bson.types.ObjectId;
+import org.junit.jupiter.api.Test;
+import tech.ebp.oqm.core.api.model.object.history.ObjectHistoryEvent;
+import tech.ebp.oqm.core.api.model.object.history.details.ItemTransactionDetail;
+import tech.ebp.oqm.core.api.model.object.history.events.CreateEvent;
+import tech.ebp.oqm.core.api.model.object.history.events.UpdateEvent;
+import tech.ebp.oqm.core.api.model.object.interactingEntity.InteractingEntity;
+import tech.ebp.oqm.core.api.model.object.storage.checkout.CheckoutDetails;
+import tech.ebp.oqm.core.api.model.object.storage.checkout.ItemAmountCheckout;
+import tech.ebp.oqm.core.api.model.object.storage.checkout.ItemCheckout;
+import tech.ebp.oqm.core.api.model.object.storage.checkout.checkinDetails.ReturnFullCheckinDetails;
+import tech.ebp.oqm.core.api.model.object.storage.checkout.checkinDetails.checkedInBy.CheckedInByOqmEntity;
+import tech.ebp.oqm.core.api.model.object.storage.checkout.checkoutFor.CheckoutForOqmEntity;
+import tech.ebp.oqm.core.api.model.object.storage.items.InventoryItem;
+import tech.ebp.oqm.core.api.model.object.storage.items.StorageType;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.AmountStored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.Stored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.UniqueStored;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.AppliedTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.ItemStoredTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.add.AddWholeTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.checkin.CheckinFullTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.checkout.CheckoutAmountTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.storageBlock.StorageBlock;
+import tech.ebp.oqm.core.api.model.rest.search.HistorySearch;
+import tech.ebp.oqm.core.api.model.rest.search.ItemCheckoutSearch;
+import tech.ebp.oqm.core.api.model.rest.search.StoredSearch;
+import tech.ebp.oqm.core.api.service.mongo.search.SearchResult;
+import tech.units.indriya.quantity.Quantities;
+
+import java.time.ZonedDateTime;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static tech.ebp.oqm.core.api.model.object.history.details.HistoryDetailType.ITEM_TRANSACTION;
+import static tech.ebp.oqm.core.api.testResources.TestConstants.DEFAULT_TEST_DB_NAME;
+
+@Slf4j
+@QuarkusTest
+@QuarkusTestResource(value = KafkaCompanionResource.class, restrictToAnnotatedClass = true)
+public class CheckinFullAmountAppliedTransactionTest extends AppliedTransactionServiceTest {
+	@Test
+	public void applyCheckinFullAmountSuccessBulkToBlock() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.BULK, entity);
+		ObjectId blockId = item.getStorageBlocks().getFirst();
+		
+		AmountStored initialStored = AmountStored.builder()
+										 .item(item.getId())
+										 .storageBlock(blockId)
+										 .amount(Quantities.getQuantity(5, item.getUnit()))
+										 .build();
+		this.storedService.add(DEFAULT_TEST_DB_NAME, initialStored, entity);
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(
+			DEFAULT_TEST_DB_NAME, null, item,
+			CheckoutAmountTransaction.builder()
+				.fromStored(initialStored.getId())
+				.amount(Quantities.getQuantity(4, item.getUnit()))
+				.checkoutDetails(CheckoutDetails.builder().checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build()).build())
+				.build(),
+			entity
+		);
+		ObjectId checkoutId =
+			this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setCheckOutTransaction(appliedTransaction.getId()))
+				.getResults()
+				.getFirst()
+				.getId();
+		//		AppliedTransaction checkoutTransactionId = this.appliedTransactionService.get(DEFAULT_TEST_DB_NAME, appliedTransactionId);
+		
+		ReturnFullCheckinDetails
+			details =
+			ReturnFullCheckinDetails.builder().notes(FAKER.lorem().paragraph()).checkedInBy(CheckedInByOqmEntity.builder().entity(entity.getId()).build()).build();
+		ItemStoredTransaction preApplyTransaction = CheckinFullTransaction.builder()
+														.checkoutId(checkoutId)
+														.toBlock(blockId)
+														.details(details)
+														.build();
+		
+		appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(1, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(5, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 1);
+		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
+		
+		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
+		assertEquals(storedFromSearch, stored);
+		assertEquals(Quantities.getQuantity(5, item.getUnit()), stored.getAmount());
+		
+		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
+		assertFalse(storedHistory.isEmpty());
+		UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
+		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+		
+		
+		SearchResult<ItemCheckout>
+			checkoutSearch =
+			this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setStillCheckedOut(false).setItemCheckedOut(item.getId()));
+		assertEquals(checkoutSearch.getNumResults(), 1);
+		ItemAmountCheckout resultingCheckout = (ItemAmountCheckout) checkoutSearch.getResults().getFirst();
+		
+		assertEquals(appliedTransaction.getId(), resultingCheckout.getCheckInTransaction());
+		assertEquals(details, resultingCheckout.getCheckInDetails());
+	}
+	
+	@Test
+	public void applyCheckinFullAmountSuccessBulkToBlockWithoutStored() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.BULK, entity);
+		ObjectId origBlockId = item.getStorageBlocks().getFirst();
+		ObjectId newBlockId = this.storageBlockService.add(DEFAULT_TEST_DB_NAME, StorageBlock.builder().label(FAKER.location().building()).build(), entity).getId();
+		item.getStorageBlocks().add(newBlockId);
+		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
+		
+		AmountStored initialStored = AmountStored.builder()
+										 .item(item.getId())
+										 .storageBlock(origBlockId)
+										 .amount(Quantities.getQuantity(5, item.getUnit()))
+										 .build();
+		this.storedService.add(DEFAULT_TEST_DB_NAME, initialStored, entity);
+		
+		ObjectId checkoutTransactionId = this.appliedTransactionService.apply(
+			DEFAULT_TEST_DB_NAME, null, item,
+			CheckoutAmountTransaction.builder()
+				.fromStored(initialStored.getId())
+				.amount(Quantities.getQuantity(4, item.getUnit()))
+				.checkoutDetails(CheckoutDetails.builder().checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build()).build())
+				.build(),
+			entity
+		).getId();
+		ObjectId
+			checkoutId =
+			this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setCheckOutTransaction(checkoutTransactionId)).getResults().getFirst().getId();
+		//		AppliedTransaction checkoutTransactionId = this.appliedTransactionService.get(DEFAULT_TEST_DB_NAME, appliedTransactionId);
+		
+		ReturnFullCheckinDetails
+			details =
+			ReturnFullCheckinDetails.builder().notes(FAKER.lorem().paragraph()).checkedInBy(CheckedInByOqmEntity.builder().entity(entity.getId()).build()).build();
+		ItemStoredTransaction preApplyTransaction = CheckinFullTransaction.builder()
+														.checkoutId(checkoutId)
+														.toBlock(newBlockId)
+														.details(details)
+														.build();
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(1, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		assertEquals(2, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(5, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 2);
+		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
+		
+		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
+		assertEquals(storedFromSearch, stored);
+		assertEquals(Quantities.getQuantity(4, item.getUnit()), stored.getAmount());
+		
+		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
+		assertFalse(storedHistory.isEmpty());
+		UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
+		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+		
+		
+		SearchResult<ItemCheckout>
+			checkoutSearch =
+			this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setStillCheckedOut(false).setItemCheckedOut(item.getId()));
+		assertEquals(checkoutSearch.getNumResults(), 1);
+		ItemAmountCheckout resultingCheckout = (ItemAmountCheckout) checkoutSearch.getResults().getFirst();
+		
+		assertEquals(appliedTransaction.getId(), resultingCheckout.getCheckInTransaction());
+		assertEquals(details, resultingCheckout.getCheckInDetails());
+	}
+	
+	@Test
+	public void applyCheckinFullAmountSuccessBulkToStored() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.BULK, entity);
+		ObjectId blockId = item.getStorageBlocks().getFirst();
+		
+		AmountStored initialStored = AmountStored.builder()
+										 .item(item.getId())
+										 .storageBlock(blockId)
+										 .amount(Quantities.getQuantity(5, item.getUnit()))
+										 .build();
+		this.storedService.add(DEFAULT_TEST_DB_NAME, initialStored, entity);
+		
+		ObjectId checkoutTransactionId = this.appliedTransactionService.apply(
+			DEFAULT_TEST_DB_NAME, null, item,
+			CheckoutAmountTransaction.builder()
+				.fromStored(initialStored.getId())
+				.amount(Quantities.getQuantity(4, item.getUnit()))
+				.checkoutDetails(CheckoutDetails.builder().checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build()).build())
+				.build(),
+			entity
+		).getId();
+		ObjectId
+			checkoutId =
+			this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setCheckOutTransaction(checkoutTransactionId)).getResults().getFirst().getId();
+		//		AppliedTransaction checkoutTransactionId = this.appliedTransactionService.get(DEFAULT_TEST_DB_NAME, appliedTransactionId);
+		
+		ReturnFullCheckinDetails
+			details =
+			ReturnFullCheckinDetails.builder().notes(FAKER.lorem().paragraph()).checkedInBy(CheckedInByOqmEntity.builder().entity(entity.getId()).build()).build();
+		ItemStoredTransaction preApplyTransaction = CheckinFullTransaction.builder()
+														.checkoutId(checkoutId)
+														.toStored(initialStored.getId())
+														.details(details)
+														.build();
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(1, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(5, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 1);
+		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
+		
+		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
+		assertEquals(storedFromSearch, stored);
+		assertEquals(Quantities.getQuantity(5, item.getUnit()), stored.getAmount());
+		
+		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
+		assertFalse(storedHistory.isEmpty());
+		UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
+		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+		
+		
+		SearchResult<ItemCheckout>
+			checkoutSearch =
+			this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setStillCheckedOut(false).setItemCheckedOut(item.getId()));
+		assertEquals(checkoutSearch.getNumResults(), 1);
+		ItemAmountCheckout resultingCheckout = (ItemAmountCheckout) checkoutSearch.getResults().getFirst();
+		
+		assertEquals(appliedTransaction.getId(), resultingCheckout.getCheckInTransaction());
+		assertEquals(details, resultingCheckout.getCheckInDetails());
+	}
+	
+	@Test
+	public void applyCheckinFullAmountSuccessAmtListToStored() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
+		ObjectId blockId = item.getStorageBlocks().getFirst();
+		
+		AmountStored initialStored = AmountStored.builder()
+										 .item(item.getId())
+										 .storageBlock(blockId)
+										 .amount(Quantities.getQuantity(5, item.getUnit()))
+										 .build();
+		this.storedService.add(DEFAULT_TEST_DB_NAME, initialStored, entity);
+		
+		ObjectId checkoutTransactionId = this.appliedTransactionService.apply(
+			DEFAULT_TEST_DB_NAME, null, item,
+			CheckoutAmountTransaction.builder()
+				.fromStored(initialStored.getId())
+				.amount(Quantities.getQuantity(4, item.getUnit()))
+				.checkoutDetails(CheckoutDetails.builder().checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build()).build())
+				.build(),
+			entity
+		).getId();
+		ObjectId
+			checkoutId =
+			this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setCheckOutTransaction(checkoutTransactionId)).getResults().getFirst().getId();
+		//		AppliedTransaction checkoutTransactionId = this.appliedTransactionService.get(DEFAULT_TEST_DB_NAME, appliedTransactionId);
+		
+		ReturnFullCheckinDetails details =
+			ReturnFullCheckinDetails.builder().notes(FAKER.lorem().paragraph()).checkedInBy(CheckedInByOqmEntity.builder().entity(entity.getId()).build()).build();
+		ItemStoredTransaction preApplyTransaction = CheckinFullTransaction.builder()
+														.checkoutId(checkoutId)
+														.toStored(initialStored.getId())
+														.details(details)
+														.build();
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(1, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(5, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 1);
+		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
+		
+		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
+		assertEquals(storedFromSearch, stored);
+		assertEquals(Quantities.getQuantity(5, item.getUnit()), stored.getAmount());
+		
+		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
+		assertFalse(storedHistory.isEmpty());
+		UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
+		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+		
+		
+		SearchResult<ItemCheckout>
+			checkoutSearch =
+			this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setStillCheckedOut(false).setItemCheckedOut(item.getId()));
+		assertEquals(checkoutSearch.getNumResults(), 1);
+		ItemAmountCheckout resultingCheckout = (ItemAmountCheckout) checkoutSearch.getResults().getFirst();
+		
+		assertEquals(appliedTransaction.getId(), resultingCheckout.getCheckInTransaction());
+		assertEquals(details, resultingCheckout.getCheckInDetails());
+	}
+	
+	@Test
+	public void applyCheckinFullAmountSuccessAmtListToBlock() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
+		ObjectId blockId = item.getStorageBlocks().getFirst();
+		
+		AmountStored initialStored = AmountStored.builder()
+										 .item(item.getId())
+										 .storageBlock(blockId)
+										 .amount(Quantities.getQuantity(5, item.getUnit()))
+										 .build();
+		this.storedService.add(DEFAULT_TEST_DB_NAME, initialStored, entity);
+		
+		ObjectId checkoutTransactionId = this.appliedTransactionService.apply(
+			DEFAULT_TEST_DB_NAME, null, item,
+			CheckoutAmountTransaction.builder()
+				.fromStored(initialStored.getId())
+				.amount(Quantities.getQuantity(4, item.getUnit()))
+				.checkoutDetails(CheckoutDetails.builder().checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build()).build())
+				.build(),
+			entity
+		).getId();
+		ObjectId
+			checkoutId =
+			this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setCheckOutTransaction(checkoutTransactionId)).getResults().getFirst().getId();
+		//		AppliedTransaction checkoutTransactionId = this.appliedTransactionService.get(DEFAULT_TEST_DB_NAME, appliedTransactionId);
+		
+		ReturnFullCheckinDetails
+			details =
+			ReturnFullCheckinDetails.builder().notes(FAKER.lorem().paragraph()).checkedInBy(CheckedInByOqmEntity.builder().entity(entity.getId()).build()).build();
+		ItemStoredTransaction preApplyTransaction = CheckinFullTransaction.builder()
+														.checkoutId(checkoutId)
+														.toBlock(blockId)
+														.details(details)
+														.build();
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(1, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		assertEquals(2, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(5, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 2);
+		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
+		
+		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
+		assertEquals(storedFromSearch, stored);
+		assertEquals(Quantities.getQuantity(4, item.getUnit()), stored.getAmount());
+		
+		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
+		assertFalse(storedHistory.isEmpty());
+		UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
+		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+		
+		
+		SearchResult<ItemCheckout>
+			checkoutSearch =
+			this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setStillCheckedOut(false).setItemCheckedOut(item.getId()));
+		assertEquals(checkoutSearch.getNumResults(), 1);
+		ItemAmountCheckout resultingCheckout = (ItemAmountCheckout) checkoutSearch.getResults().getFirst();
+		
+		assertEquals(appliedTransaction.getId(), resultingCheckout.getCheckInTransaction());
+		assertEquals(details, resultingCheckout.getCheckInDetails());
+	}
+	
+	//TODO:: more?
+}
diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/CheckinWholeAppliedTransactionTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/CheckinWholeAppliedTransactionTest.java
new file mode 100644
index 000000000..7d52b1b1e
--- /dev/null
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/CheckinWholeAppliedTransactionTest.java
@@ -0,0 +1,274 @@
+package tech.ebp.oqm.core.api.service.mongo.transactions.transactionApplier;
+
+import io.quarkus.test.common.QuarkusTestResource;
+import io.quarkus.test.junit.QuarkusTest;
+import io.quarkus.test.kafka.KafkaCompanionResource;
+import lombok.extern.slf4j.Slf4j;
+import org.bson.types.ObjectId;
+import org.junit.jupiter.api.Test;
+import tech.ebp.oqm.core.api.model.object.history.ObjectHistoryEvent;
+import tech.ebp.oqm.core.api.model.object.history.details.ItemTransactionDetail;
+import tech.ebp.oqm.core.api.model.object.history.events.ReCreateEvent;
+import tech.ebp.oqm.core.api.model.object.history.events.UpdateEvent;
+import tech.ebp.oqm.core.api.model.object.interactingEntity.InteractingEntity;
+import tech.ebp.oqm.core.api.model.object.storage.checkout.CheckoutDetails;
+import tech.ebp.oqm.core.api.model.object.storage.checkout.ItemAmountCheckout;
+import tech.ebp.oqm.core.api.model.object.storage.checkout.ItemCheckout;
+import tech.ebp.oqm.core.api.model.object.storage.checkout.ItemWholeCheckout;
+import tech.ebp.oqm.core.api.model.object.storage.checkout.checkinDetails.ReturnFullCheckinDetails;
+import tech.ebp.oqm.core.api.model.object.storage.checkout.checkinDetails.checkedInBy.CheckedInByOqmEntity;
+import tech.ebp.oqm.core.api.model.object.storage.checkout.checkoutFor.CheckoutForOqmEntity;
+import tech.ebp.oqm.core.api.model.object.storage.items.InventoryItem;
+import tech.ebp.oqm.core.api.model.object.storage.items.StorageType;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.AmountStored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.Stored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.UniqueStored;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.AppliedTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.ItemStoredTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.checkin.CheckinFullTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.checkout.CheckoutAmountTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.checkout.CheckoutWholeTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.storageBlock.StorageBlock;
+import tech.ebp.oqm.core.api.model.rest.search.HistorySearch;
+import tech.ebp.oqm.core.api.model.rest.search.ItemCheckoutSearch;
+import tech.ebp.oqm.core.api.model.rest.search.StoredSearch;
+import tech.ebp.oqm.core.api.service.mongo.search.SearchResult;
+import tech.units.indriya.quantity.Quantities;
+
+import java.time.ZonedDateTime;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static tech.ebp.oqm.core.api.model.object.history.details.HistoryDetailType.ITEM_TRANSACTION;
+import static tech.ebp.oqm.core.api.testResources.TestConstants.DEFAULT_TEST_DB_NAME;
+
+@Slf4j
+@QuarkusTest
+@QuarkusTestResource(value = KafkaCompanionResource.class, restrictToAnnotatedClass = true)
+public class CheckinWholeAppliedTransactionTest extends AppliedTransactionServiceTest {
+	
+	
+	@Test
+	public void applyCheckinFullWholeSuccessBulk() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.BULK, entity);
+		ObjectId blockId = item.getStorageBlocks().getFirst();
+		
+		AmountStored initialStored = AmountStored.builder()
+										 .item(item.getId())
+										 .storageBlock(blockId)
+										 .amount(Quantities.getQuantity(5, item.getUnit()))
+										 .build();
+		this.storedService.add(DEFAULT_TEST_DB_NAME, initialStored, entity);
+		
+		ObjectId checkoutTransactionId = this.appliedTransactionService.apply(
+			DEFAULT_TEST_DB_NAME, null, item,
+			CheckoutWholeTransaction.builder()
+				.toCheckout(initialStored.getId())
+				.checkoutDetails(CheckoutDetails.builder().checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build()).build())
+				.build(),
+			entity
+		).getId();
+		ObjectId
+			checkoutId =
+			this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setCheckOutTransaction(checkoutTransactionId)).getResults().getFirst().getId();
+		//		AppliedTransaction checkoutTransactionId = this.appliedTransactionService.get(DEFAULT_TEST_DB_NAME, appliedTransactionId);
+		
+		ReturnFullCheckinDetails
+			details =
+			ReturnFullCheckinDetails.builder().notes(FAKER.lorem().paragraph()).checkedInBy(CheckedInByOqmEntity.builder().entity(entity.getId()).build()).build();
+		ItemStoredTransaction preApplyTransaction = CheckinFullTransaction.builder()
+														.checkoutId(checkoutId)
+														.toBlock(blockId)
+														.details(details)
+														.build();
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(1, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(5, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 1);
+		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
+		
+		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
+		assertEquals(storedFromSearch, stored);
+		assertEquals(Quantities.getQuantity(5, item.getUnit()), stored.getAmount());
+		
+		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
+		assertFalse(storedHistory.isEmpty());
+		ReCreateEvent event = (ReCreateEvent) storedHistory.getResults().getFirst();
+		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+		
+		
+		SearchResult<ItemCheckout>
+			checkoutSearch =
+			this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setStillCheckedOut(false).setItemCheckedOut(item.getId()));
+		assertEquals(checkoutSearch.getNumResults(), 1);
+		ItemWholeCheckout resultingCheckout = (ItemWholeCheckout) checkoutSearch.getResults().getFirst();
+		
+		assertEquals(appliedTransaction.getId(), resultingCheckout.getCheckInTransaction());
+		assertEquals(details, resultingCheckout.getCheckInDetails());
+	}
+	
+	@Test
+	public void applyCheckinFullWholeSuccessUniqueMulti() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.UNIQUE_MULTI, entity);
+		ObjectId blockId = item.getStorageBlocks().getFirst();
+		
+		UniqueStored initialStored = UniqueStored.builder()
+										 .item(item.getId())
+										 .storageBlock(blockId)
+										 .build();
+		this.storedService.add(DEFAULT_TEST_DB_NAME, initialStored, entity);
+		
+		ObjectId checkoutTransactionId = this.appliedTransactionService.apply(
+			DEFAULT_TEST_DB_NAME, null, item,
+			CheckoutWholeTransaction.builder()
+				.toCheckout(initialStored.getId())
+				.checkoutDetails(CheckoutDetails.builder().checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build()).build())
+				.build(),
+			entity
+		).getId();
+		ObjectId
+			checkoutId =
+			this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setCheckOutTransaction(checkoutTransactionId)).getResults().getFirst().getId();
+		//		AppliedTransaction checkoutTransactionId = this.appliedTransactionService.get(DEFAULT_TEST_DB_NAME, appliedTransactionId);
+		
+		ReturnFullCheckinDetails
+			details =
+			ReturnFullCheckinDetails.builder().notes(FAKER.lorem().paragraph()).checkedInBy(CheckedInByOqmEntity.builder().entity(entity.getId()).build()).build();
+		ItemStoredTransaction preApplyTransaction = CheckinFullTransaction.builder()
+														.checkoutId(checkoutId)
+														.toBlock(blockId)
+														.details(details)
+														.build();
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(1, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(1, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 1);
+		UniqueStored storedFromSearch = (UniqueStored) storedSearchResult.getResults().getFirst();
+		
+		UniqueStored stored = (UniqueStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
+		assertEquals(storedFromSearch, stored);
+		
+		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
+		assertFalse(storedHistory.isEmpty());
+		ReCreateEvent event = (ReCreateEvent) storedHistory.getResults().getFirst();
+		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+		
+		
+		SearchResult<ItemCheckout>
+			checkoutSearch =
+			this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setStillCheckedOut(false).setItemCheckedOut(item.getId()));
+		assertEquals(checkoutSearch.getNumResults(), 1);
+		ItemWholeCheckout resultingCheckout = (ItemWholeCheckout) checkoutSearch.getResults().getFirst();
+		
+		assertEquals(appliedTransaction.getId(), resultingCheckout.getCheckInTransaction());
+		assertEquals(details, resultingCheckout.getCheckInDetails());
+	}
+	
+	@Test
+	public void applyCheckinFullWholeSuccessUniqueSingle() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.UNIQUE_SINGLE, entity);
+		ObjectId blockId = item.getStorageBlocks().getFirst();
+		
+		UniqueStored initialStored = UniqueStored.builder()
+										 .item(item.getId())
+										 .storageBlock(blockId)
+										 .build();
+		this.storedService.add(DEFAULT_TEST_DB_NAME, initialStored, entity);
+		
+		ObjectId checkoutTransactionId = this.appliedTransactionService.apply(
+			DEFAULT_TEST_DB_NAME, null, item,
+			CheckoutWholeTransaction.builder()
+				.toCheckout(initialStored.getId())
+				.checkoutDetails(CheckoutDetails.builder().checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build()).build())
+				.build(),
+			entity
+		).getId();
+		ObjectId
+			checkoutId =
+			this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setCheckOutTransaction(checkoutTransactionId)).getResults().getFirst().getId();
+		//		AppliedTransaction checkoutTransactionId = this.appliedTransactionService.get(DEFAULT_TEST_DB_NAME, appliedTransactionId);
+		
+		ReturnFullCheckinDetails
+			details =
+			ReturnFullCheckinDetails.builder().notes(FAKER.lorem().paragraph()).checkedInBy(CheckedInByOqmEntity.builder().entity(entity.getId()).build()).build();
+		ItemStoredTransaction preApplyTransaction = CheckinFullTransaction.builder()
+														.checkoutId(checkoutId)
+														.toBlock(blockId)
+														.details(details)
+														.build();
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(1, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(1, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 1);
+		UniqueStored storedFromSearch = (UniqueStored) storedSearchResult.getResults().getFirst();
+		
+		UniqueStored stored = (UniqueStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
+		assertEquals(storedFromSearch, stored);
+		
+		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
+		assertFalse(storedHistory.isEmpty());
+		ReCreateEvent event = (ReCreateEvent) storedHistory.getResults().getFirst();
+		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+		
+		
+		SearchResult<ItemCheckout>
+			checkoutSearch =
+			this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setStillCheckedOut(false).setItemCheckedOut(item.getId()));
+		assertEquals(checkoutSearch.getNumResults(), 1);
+		ItemWholeCheckout resultingCheckout = (ItemWholeCheckout) checkoutSearch.getResults().getFirst();
+		
+		assertEquals(appliedTransaction.getId(), resultingCheckout.getCheckInTransaction());
+		assertEquals(details, resultingCheckout.getCheckInDetails());
+	}
+	
+	
+	//TODO:: fail - amount list - amount - to stored (not existing)
+	//TODO:: Fail - amount - No 'to' given
+	//TODO:: Fail - amount - 'to block' given for list
+	//TODO:: fail - whole - no to block given
+	//TODO:: fail - mismatched item/stored/block
+	//TODO:: any more?
+}
diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/CheckoutAmountAppliedTransactionTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/CheckoutAmountAppliedTransactionTest.java
new file mode 100644
index 000000000..3fcd5bf47
--- /dev/null
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/CheckoutAmountAppliedTransactionTest.java
@@ -0,0 +1,486 @@
+package tech.ebp.oqm.core.api.service.mongo.transactions.transactionApplier;
+
+import io.quarkus.test.common.QuarkusTestResource;
+import io.quarkus.test.junit.QuarkusTest;
+import io.quarkus.test.kafka.KafkaCompanionResource;
+import lombok.extern.slf4j.Slf4j;
+import org.bson.types.ObjectId;
+import org.junit.jupiter.api.Test;
+import tech.ebp.oqm.core.api.model.object.history.ObjectHistoryEvent;
+import tech.ebp.oqm.core.api.model.object.history.details.ItemTransactionDetail;
+import tech.ebp.oqm.core.api.model.object.history.events.UpdateEvent;
+import tech.ebp.oqm.core.api.model.object.interactingEntity.InteractingEntity;
+import tech.ebp.oqm.core.api.model.object.storage.checkout.CheckoutDetails;
+import tech.ebp.oqm.core.api.model.object.storage.checkout.ItemAmountCheckout;
+import tech.ebp.oqm.core.api.model.object.storage.checkout.ItemCheckout;
+import tech.ebp.oqm.core.api.model.object.storage.checkout.checkinDetails.ReturnFullCheckinDetails;
+import tech.ebp.oqm.core.api.model.object.storage.checkout.checkinDetails.checkedInBy.CheckedInByOqmEntity;
+import tech.ebp.oqm.core.api.model.object.storage.checkout.checkoutFor.CheckoutForOqmEntity;
+import tech.ebp.oqm.core.api.model.object.storage.items.InventoryItem;
+import tech.ebp.oqm.core.api.model.object.storage.items.StorageType;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.AmountStored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.Stored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.UniqueStored;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.AppliedTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.ItemStoredTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.checkin.CheckinFullTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.checkout.CheckoutAmountTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.storageBlock.StorageBlock;
+import tech.ebp.oqm.core.api.model.rest.search.HistorySearch;
+import tech.ebp.oqm.core.api.model.rest.search.ItemCheckoutSearch;
+import tech.ebp.oqm.core.api.model.rest.search.StoredSearch;
+import tech.ebp.oqm.core.api.service.mongo.search.SearchResult;
+import tech.units.indriya.quantity.Quantities;
+
+import java.time.ZonedDateTime;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static tech.ebp.oqm.core.api.model.object.history.details.HistoryDetailType.ITEM_TRANSACTION;
+import static tech.ebp.oqm.core.api.testResources.TestConstants.DEFAULT_TEST_DB_NAME;
+
+@Slf4j
+@QuarkusTest
+@QuarkusTestResource(value = KafkaCompanionResource.class, restrictToAnnotatedClass = true)
+public class CheckoutAmountAppliedTransactionTest extends AppliedTransactionServiceTest {
+	
+	@Test
+	public void applyCheckoutAmountSuccessBulkFromBlock() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.BULK, entity);
+		ObjectId blockId = item.getStorageBlocks().getFirst();
+		
+		ObjectId initialStoredId = this.storedService.add(
+			DEFAULT_TEST_DB_NAME,
+			AmountStored.builder()
+				.item(item.getId())
+				.storageBlock(blockId)
+				.amount(Quantities.getQuantity(6, item.getUnit()))
+				.build(),
+			entity
+		).getId();
+		
+		CheckoutDetails details = CheckoutDetails.builder()
+									  .checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build())
+									  .build();
+		ItemStoredTransaction preApplyTransaction = CheckoutAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.fromBlock(blockId)
+														.checkoutDetails(details)
+														.build();
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(1, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(1, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 1);
+		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
+		
+		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
+		assertEquals(storedFromSearch, stored);
+		assertEquals(Quantities.getQuantity(1, item.getUnit()), stored.getAmount());
+		
+		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
+		assertFalse(storedHistory.isEmpty());
+		UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
+		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+		
+		SearchResult<ItemCheckout> checkoutSearch = this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setItemCheckedOut(item.getId()));
+		assertEquals(checkoutSearch.getNumResults(), 1);
+		ItemAmountCheckout resultingCheckout = (ItemAmountCheckout) checkoutSearch.getResults().getFirst();
+		
+		assertEquals(initialStoredId, resultingCheckout.getFromStored());
+		assertEquals(details, resultingCheckout.getCheckoutDetails());
+		assertEquals(appliedTransaction.getId(), resultingCheckout.getCheckOutTransaction());
+		assertEquals(Quantities.getQuantity(5, item.getUnit()), resultingCheckout.getCheckedOut());
+	}
+	
+	@Test
+	public void applyCheckoutAmountSuccessBulkFromStored() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.BULK, entity);
+		ObjectId blockId = item.getStorageBlocks().getFirst();
+		
+		ObjectId initialStoredId = this.storedService.add(
+			DEFAULT_TEST_DB_NAME,
+			AmountStored.builder()
+				.item(item.getId())
+				.storageBlock(blockId)
+				.amount(Quantities.getQuantity(6, item.getUnit()))
+				.build(),
+			entity
+		).getId();
+		
+		CheckoutDetails details = CheckoutDetails.builder()
+									  .checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build())
+									  .build();
+		ItemStoredTransaction preApplyTransaction = CheckoutAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.fromStored(initialStoredId)
+														.checkoutDetails(details)
+														.build();
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(1, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(1, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 1);
+		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
+		
+		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
+		assertEquals(storedFromSearch, stored);
+		assertEquals(Quantities.getQuantity(1, item.getUnit()), stored.getAmount());
+		
+		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
+		assertFalse(storedHistory.isEmpty());
+		UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
+		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+		
+		SearchResult<ItemCheckout> checkoutSearch = this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setItemCheckedOut(item.getId()));
+		assertEquals(checkoutSearch.getNumResults(), 1);
+		ItemAmountCheckout resultingCheckout = (ItemAmountCheckout) checkoutSearch.getResults().getFirst();
+		
+		assertEquals(initialStoredId, resultingCheckout.getFromStored());
+		assertEquals(details, resultingCheckout.getCheckoutDetails());
+		assertEquals(appliedTransaction.getId(), resultingCheckout.getCheckOutTransaction());
+		assertEquals(Quantities.getQuantity(5, item.getUnit()), resultingCheckout.getCheckedOut());
+	}
+	
+	@Test
+	public void applyCheckoutAmountSuccessAmtList() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
+		ObjectId blockId = item.getStorageBlocks().getFirst();
+		
+		ObjectId initialStoredId = this.storedService.add(
+			DEFAULT_TEST_DB_NAME,
+			AmountStored.builder()
+				.item(item.getId())
+				.storageBlock(blockId)
+				.amount(Quantities.getQuantity(6, item.getUnit()))
+				.build(),
+			entity
+		).getId();
+		
+		CheckoutDetails details = CheckoutDetails.builder()
+									  .checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build())
+									  .build();
+		ItemStoredTransaction preApplyTransaction = CheckoutAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.fromStored(initialStoredId)
+														.checkoutDetails(details)
+														.build();
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(1, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(1, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 1);
+		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
+		
+		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
+		assertEquals(storedFromSearch, stored);
+		assertEquals(Quantities.getQuantity(1, item.getUnit()), stored.getAmount());
+		
+		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
+		assertFalse(storedHistory.isEmpty());
+		UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
+		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+		
+		SearchResult<ItemCheckout> checkoutSearch = this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setItemCheckedOut(item.getId()));
+		assertEquals(checkoutSearch.getNumResults(), 1);
+		ItemAmountCheckout resultingCheckout = (ItemAmountCheckout) checkoutSearch.getResults().getFirst();
+		
+		assertEquals(initialStoredId, resultingCheckout.getFromStored());
+		assertEquals(details, resultingCheckout.getCheckoutDetails());
+		assertEquals(appliedTransaction.getId(), resultingCheckout.getCheckOutTransaction());
+		assertEquals(Quantities.getQuantity(5, item.getUnit()), resultingCheckout.getCheckedOut());
+	}
+	
+	@Test
+	public void applyCheckoutAmountFailBulkFromNothing() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.BULK, entity);
+		ObjectId blockId = item.getStorageBlocks().getFirst();
+		
+		ObjectId initialStoredId = this.storedService.add(
+			DEFAULT_TEST_DB_NAME,
+			AmountStored.builder()
+				.item(item.getId())
+				.storageBlock(blockId)
+				.amount(Quantities.getQuantity(6, item.getUnit()))
+				.build(),
+			entity
+		).getId();
+		
+		CheckoutDetails details = CheckoutDetails.builder()
+									  .checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build())
+									  .build();
+		ItemStoredTransaction preApplyTransaction = CheckoutAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.checkoutDetails(details)
+														.build();
+		
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("No stored or block given to checkout from.", e.getMessage());
+	}
+	
+	@Test
+	public void applyCheckoutAmountFailAmtListFromNothing() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
+		ObjectId blockId = item.getStorageBlocks().getFirst();
+		
+		ObjectId initialStoredId = this.storedService.add(
+			DEFAULT_TEST_DB_NAME,
+			AmountStored.builder()
+				.item(item.getId())
+				.storageBlock(blockId)
+				.amount(Quantities.getQuantity(6, item.getUnit()))
+				.build(),
+			entity
+		).getId();
+		
+		CheckoutDetails details = CheckoutDetails.builder()
+									  .checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build())
+									  .build();
+		ItemStoredTransaction preApplyTransaction = CheckoutAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.checkoutDetails(details)
+														.build();
+		
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("No stored given to checkout from.", e.getMessage());
+	}
+	
+	@Test
+	public void applyCheckoutAmountFailAmtListFromNoStored() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
+		ObjectId blockId = item.getStorageBlocks().getFirst();
+		
+		ObjectId initialStoredId = this.storedService.add(
+			DEFAULT_TEST_DB_NAME,
+			AmountStored.builder()
+				.item(item.getId())
+				.storageBlock(blockId)
+				.amount(Quantities.getQuantity(6, item.getUnit()))
+				.build(),
+			entity
+		).getId();
+		
+		CheckoutDetails details = CheckoutDetails.builder()
+									  .checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build())
+									  .build();
+		ItemStoredTransaction preApplyTransaction = CheckoutAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.fromBlock(blockId)
+														.checkoutDetails(details)
+														.build();
+		
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("No stored given to checkout from.", e.getMessage());
+	}
+	
+	@Test
+	public void applyCheckoutAmountFailAmtListBadBlock() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
+		ObjectId blockId = item.getStorageBlocks().getFirst();
+		
+		ObjectId initialStoredId = this.storedService.add(
+			DEFAULT_TEST_DB_NAME,
+			AmountStored.builder()
+				.item(item.getId())
+				.storageBlock(blockId)
+				.amount(Quantities.getQuantity(6, item.getUnit()))
+				.build(),
+			entity
+		).getId();
+		
+		CheckoutDetails details = CheckoutDetails.builder()
+									  .checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build())
+									  .build();
+		ItemStoredTransaction preApplyTransaction = CheckoutAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.fromBlock(new ObjectId())
+														.fromStored(initialStoredId)
+														.checkoutDetails(details)
+														.build();
+		
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("From Storage block given mismatched stored's block.", e.getMessage());
+	}
+	
+	@Test
+	public void applyCheckoutAmountFailBulkNotEnoughToCheckout() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.BULK, entity);
+		ObjectId blockId = item.getStorageBlocks().getFirst();
+		
+		ObjectId initialStoredId = this.storedService.add(
+			DEFAULT_TEST_DB_NAME,
+			AmountStored.builder()
+				.item(item.getId())
+				.storageBlock(blockId)
+				.amount(Quantities.getQuantity(6, item.getUnit()))
+				.build(),
+			entity
+		).getId();
+		
+		CheckoutDetails details = CheckoutDetails.builder()
+									  .checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build())
+									  .build();
+		ItemStoredTransaction preApplyTransaction = CheckoutAmountTransaction.builder()
+														.amount(Quantities.getQuantity(7, item.getUnit()))
+														.fromBlock(blockId)
+														.fromStored(initialStoredId)
+														.checkoutDetails(details)
+														.build();
+		
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("Resulting amount less than zero. (subtracting 7 units from 6 units resulting in -1 units)", e.getMessage());
+	}
+	
+	@Test
+	public void applyCheckoutAmountFailAmtListNotEnoughToCheckout() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
+		ObjectId blockId = item.getStorageBlocks().getFirst();
+		
+		ObjectId initialStoredId = this.storedService.add(
+			DEFAULT_TEST_DB_NAME,
+			AmountStored.builder()
+				.item(item.getId())
+				.storageBlock(blockId)
+				.amount(Quantities.getQuantity(6, item.getUnit()))
+				.build(),
+			entity
+		).getId();
+		
+		CheckoutDetails details = CheckoutDetails.builder()
+									  .checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build())
+									  .build();
+		ItemStoredTransaction preApplyTransaction = CheckoutAmountTransaction.builder()
+														.amount(Quantities.getQuantity(7, item.getUnit()))
+														.fromBlock(blockId)
+														.fromStored(initialStoredId)
+														.checkoutDetails(details)
+														.build();
+		
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("Resulting amount less than zero. (subtracting 7 units from 6 units resulting in -1 units)", e.getMessage());
+	}
+	
+	@Test
+	public void applyCheckoutAmountFailUniqueSingle() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.UNIQUE_SINGLE, entity);
+		ObjectId blockId = item.getStorageBlocks().getFirst();
+		
+		ObjectId initialStoredId = this.storedService.add(
+			DEFAULT_TEST_DB_NAME,
+			UniqueStored.builder()
+				.item(item.getId())
+				.storageBlock(blockId)
+				.build(),
+			entity
+		).getId();
+		
+		CheckoutDetails details = CheckoutDetails.builder()
+									  .checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build())
+									  .build();
+		ItemStoredTransaction preApplyTransaction = CheckoutAmountTransaction.builder()
+														.amount(Quantities.getQuantity(7, item.getUnit()))
+														.fromBlock(blockId)
+														.fromStored(initialStoredId)
+														.checkoutDetails(details)
+														.build();
+		
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("Cannot checkout an amount from a unique type.", e.getMessage());
+	}
+	
+	@Test
+	public void applyCheckoutAmountFailUniqueMulti() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.UNIQUE_MULTI, entity);
+		ObjectId blockId = item.getStorageBlocks().getFirst();
+		
+		ObjectId initialStoredId = this.storedService.add(
+			DEFAULT_TEST_DB_NAME,
+			UniqueStored.builder()
+				.item(item.getId())
+				.storageBlock(blockId)
+				.build(),
+			entity
+		).getId();
+		
+		CheckoutDetails details = CheckoutDetails.builder()
+									  .checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build())
+									  .build();
+		ItemStoredTransaction preApplyTransaction = CheckoutAmountTransaction.builder()
+														.amount(Quantities.getQuantity(7, item.getUnit()))
+														.fromBlock(blockId)
+														.fromStored(initialStoredId)
+														.checkoutDetails(details)
+														.build();
+		
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("Cannot checkout an amount from a unique type.", e.getMessage());
+	}
+	
+	//TODO:: fail - mismatched item/stored/block
+	//TODO:: any more?
+}
diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/CheckoutWholeAppliedTransactionTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/CheckoutWholeAppliedTransactionTest.java
new file mode 100644
index 000000000..b20b1eb62
--- /dev/null
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/CheckoutWholeAppliedTransactionTest.java
@@ -0,0 +1,272 @@
+package tech.ebp.oqm.core.api.service.mongo.transactions.transactionApplier;
+
+import io.quarkus.test.common.QuarkusTestResource;
+import io.quarkus.test.junit.QuarkusTest;
+import io.quarkus.test.kafka.KafkaCompanionResource;
+import lombok.extern.slf4j.Slf4j;
+import org.bson.types.ObjectId;
+import org.junit.jupiter.api.Test;
+import tech.ebp.oqm.core.api.model.object.history.ObjectHistoryEvent;
+import tech.ebp.oqm.core.api.model.object.history.details.ItemTransactionDetail;
+import tech.ebp.oqm.core.api.model.object.history.events.DeleteEvent;
+import tech.ebp.oqm.core.api.model.object.history.events.UpdateEvent;
+import tech.ebp.oqm.core.api.model.object.interactingEntity.InteractingEntity;
+import tech.ebp.oqm.core.api.model.object.storage.checkout.CheckoutDetails;
+import tech.ebp.oqm.core.api.model.object.storage.checkout.ItemAmountCheckout;
+import tech.ebp.oqm.core.api.model.object.storage.checkout.ItemCheckout;
+import tech.ebp.oqm.core.api.model.object.storage.checkout.ItemWholeCheckout;
+import tech.ebp.oqm.core.api.model.object.storage.checkout.checkoutFor.CheckoutForOqmEntity;
+import tech.ebp.oqm.core.api.model.object.storage.items.InventoryItem;
+import tech.ebp.oqm.core.api.model.object.storage.items.StorageType;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.AmountStored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.Stored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.UniqueStored;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.AppliedTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.ItemStoredTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.checkout.CheckoutAmountTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.checkout.CheckoutWholeTransaction;
+import tech.ebp.oqm.core.api.model.rest.search.HistorySearch;
+import tech.ebp.oqm.core.api.model.rest.search.ItemCheckoutSearch;
+import tech.ebp.oqm.core.api.model.rest.search.StoredSearch;
+import tech.ebp.oqm.core.api.service.mongo.search.SearchResult;
+import tech.units.indriya.quantity.Quantities;
+
+import java.time.ZonedDateTime;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static tech.ebp.oqm.core.api.model.object.history.details.HistoryDetailType.ITEM_TRANSACTION;
+import static tech.ebp.oqm.core.api.testResources.TestConstants.DEFAULT_TEST_DB_NAME;
+
+@Slf4j
+@QuarkusTest
+@QuarkusTestResource(value = KafkaCompanionResource.class, restrictToAnnotatedClass = true)
+public class CheckoutWholeAppliedTransactionTest extends AppliedTransactionServiceTest {
+	
+	@Test
+	public void applyCheckoutWholeSuccessBulk() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.BULK, entity);
+		ObjectId blockId = item.getStorageBlocks().getFirst();
+		
+		AmountStored initialStored = AmountStored.builder()
+										 .item(item.getId())
+										 .storageBlock(blockId)
+										 .amount(Quantities.getQuantity(6, item.getUnit()))
+										 .build();
+		ObjectId initialStoredId = this.storedService.add(
+			DEFAULT_TEST_DB_NAME,
+			initialStored,
+			entity
+		).getId();
+		
+		CheckoutDetails details = CheckoutDetails.builder()
+									  .checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build())
+									  .build();
+		ItemStoredTransaction preApplyTransaction = CheckoutWholeTransaction.builder()
+														.toCheckout(initialStoredId)
+														.checkoutDetails(details)
+														.build();
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(1, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		assertEquals(0, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(0, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 0);
+		
+		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(initialStoredId));
+		assertFalse(storedHistory.isEmpty());
+		DeleteEvent event = (DeleteEvent) storedHistory.getResults().getFirst();
+		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+		
+		SearchResult<ItemCheckout> checkoutSearch = this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setItemCheckedOut(item.getId()));
+		assertEquals(checkoutSearch.getNumResults(), 1);
+		ItemWholeCheckout resultingCheckout = (ItemWholeCheckout) checkoutSearch.getResults().getFirst();
+		
+		assertEquals(details, resultingCheckout.getCheckoutDetails());
+		assertEquals(appliedTransaction.getId(), resultingCheckout.getCheckOutTransaction());
+		assertEquals(initialStored, resultingCheckout.getCheckedOut());
+	}
+	
+	@Test
+	public void applyCheckoutWholeSuccessAmtList() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
+		ObjectId blockId = item.getStorageBlocks().getFirst();
+		
+		AmountStored initialStored = AmountStored.builder()
+										 .item(item.getId())
+										 .storageBlock(blockId)
+										 .amount(Quantities.getQuantity(6, item.getUnit()))
+										 .build();
+		ObjectId initialStoredId = this.storedService.add(
+			DEFAULT_TEST_DB_NAME,
+			initialStored,
+			entity
+		).getId();
+		
+		CheckoutDetails details = CheckoutDetails.builder()
+									  .checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build())
+									  .build();
+		ItemStoredTransaction preApplyTransaction = CheckoutWholeTransaction.builder()
+														.toCheckout(initialStoredId)
+														.checkoutDetails(details)
+														.build();
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(1, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		assertEquals(0, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(0, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 0);
+		
+		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(initialStoredId));
+		assertFalse(storedHistory.isEmpty());
+		DeleteEvent event = (DeleteEvent) storedHistory.getResults().getFirst();
+		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+		
+		SearchResult<ItemCheckout> checkoutSearch = this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setItemCheckedOut(item.getId()));
+		assertEquals(checkoutSearch.getNumResults(), 1);
+		ItemWholeCheckout resultingCheckout = (ItemWholeCheckout) checkoutSearch.getResults().getFirst();
+		
+		assertEquals(details, resultingCheckout.getCheckoutDetails());
+		assertEquals(appliedTransaction.getId(), resultingCheckout.getCheckOutTransaction());
+		assertEquals(initialStored, resultingCheckout.getCheckedOut());
+	}
+	
+	@Test
+	public void applyCheckoutWholeSuccessUniqueMulti() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.UNIQUE_MULTI, entity);
+		ObjectId blockId = item.getStorageBlocks().getFirst();
+		
+		UniqueStored initialStored = UniqueStored.builder()
+										 .item(item.getId())
+										 .storageBlock(blockId)
+										 .build();
+		ObjectId initialStoredId = this.storedService.add(
+			DEFAULT_TEST_DB_NAME,
+			initialStored,
+			entity
+		).getId();
+		
+		CheckoutDetails details = CheckoutDetails.builder()
+									  .checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build())
+									  .build();
+		ItemStoredTransaction preApplyTransaction = CheckoutWholeTransaction.builder()
+														.toCheckout(initialStoredId)
+														.checkoutDetails(details)
+														.build();
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(1, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		assertEquals(0, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(0, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 0);
+		
+		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(initialStoredId));
+		assertFalse(storedHistory.isEmpty());
+		DeleteEvent event = (DeleteEvent) storedHistory.getResults().getFirst();
+		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+		
+		SearchResult<ItemCheckout> checkoutSearch = this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setItemCheckedOut(item.getId()));
+		assertEquals(checkoutSearch.getNumResults(), 1);
+		ItemWholeCheckout resultingCheckout = (ItemWholeCheckout) checkoutSearch.getResults().getFirst();
+		
+		assertEquals(details, resultingCheckout.getCheckoutDetails());
+		assertEquals(appliedTransaction.getId(), resultingCheckout.getCheckOutTransaction());
+		assertEquals(initialStored, resultingCheckout.getCheckedOut());
+	}
+	
+	@Test
+	public void applyCheckoutWholeSuccessUniqueSingle() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.UNIQUE_SINGLE, entity);
+		ObjectId blockId = item.getStorageBlocks().getFirst();
+		
+		UniqueStored initialStored = UniqueStored.builder()
+										 .item(item.getId())
+										 .storageBlock(blockId)
+										 .build();
+		ObjectId initialStoredId = this.storedService.add(
+			DEFAULT_TEST_DB_NAME,
+			initialStored,
+			entity
+		).getId();
+		
+		CheckoutDetails details = CheckoutDetails.builder()
+									  .checkedOutFor(CheckoutForOqmEntity.builder().entity(entity.getId()).build())
+									  .build();
+		ItemStoredTransaction preApplyTransaction = CheckoutWholeTransaction.builder()
+														.toCheckout(initialStoredId)
+														.checkoutDetails(details)
+														.build();
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(1, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		assertEquals(0, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(0, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 0);
+		
+		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(initialStoredId));
+		assertFalse(storedHistory.isEmpty());
+		DeleteEvent event = (DeleteEvent) storedHistory.getResults().getFirst();
+		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+		
+		SearchResult<ItemCheckout> checkoutSearch = this.checkoutService.search(DEFAULT_TEST_DB_NAME, new ItemCheckoutSearch().setItemCheckedOut(item.getId()));
+		assertEquals(checkoutSearch.getNumResults(), 1);
+		ItemWholeCheckout resultingCheckout = (ItemWholeCheckout) checkoutSearch.getResults().getFirst();
+		
+		assertEquals(details, resultingCheckout.getCheckoutDetails());
+		assertEquals(appliedTransaction.getId(), resultingCheckout.getCheckOutTransaction());
+		assertEquals(initialStored, resultingCheckout.getCheckedOut());
+	}
+	
+	//TODO:: fail - mismatched item/stored/block
+	//TODO:: any more?
+}
diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/SetAmountAppliedTransactionTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/SetAmountAppliedTransactionTest.java
new file mode 100644
index 000000000..46f3006d4
--- /dev/null
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/SetAmountAppliedTransactionTest.java
@@ -0,0 +1,311 @@
+package tech.ebp.oqm.core.api.service.mongo.transactions.transactionApplier;
+
+import io.quarkus.test.common.QuarkusTestResource;
+import io.quarkus.test.junit.QuarkusTest;
+import io.quarkus.test.kafka.KafkaCompanionResource;
+import jakarta.validation.ValidationException;
+import lombok.extern.slf4j.Slf4j;
+import org.bson.types.ObjectId;
+import org.junit.jupiter.api.Test;
+import tech.ebp.oqm.core.api.model.object.history.ObjectHistoryEvent;
+import tech.ebp.oqm.core.api.model.object.history.details.ItemTransactionDetail;
+import tech.ebp.oqm.core.api.model.object.history.events.DeleteEvent;
+import tech.ebp.oqm.core.api.model.object.history.events.UpdateEvent;
+import tech.ebp.oqm.core.api.model.object.interactingEntity.InteractingEntity;
+import tech.ebp.oqm.core.api.model.object.storage.checkout.CheckoutDetails;
+import tech.ebp.oqm.core.api.model.object.storage.checkout.ItemCheckout;
+import tech.ebp.oqm.core.api.model.object.storage.checkout.ItemWholeCheckout;
+import tech.ebp.oqm.core.api.model.object.storage.checkout.checkoutFor.CheckoutForOqmEntity;
+import tech.ebp.oqm.core.api.model.object.storage.items.InventoryItem;
+import tech.ebp.oqm.core.api.model.object.storage.items.StorageType;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.AmountStored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.Stored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.UniqueStored;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.AppliedTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.ItemStoredTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.checkout.CheckoutWholeTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.set.SetAmountTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.storageBlock.StorageBlock;
+import tech.ebp.oqm.core.api.model.rest.search.HistorySearch;
+import tech.ebp.oqm.core.api.model.rest.search.ItemCheckoutSearch;
+import tech.ebp.oqm.core.api.model.rest.search.StoredSearch;
+import tech.ebp.oqm.core.api.service.mongo.search.SearchResult;
+import tech.units.indriya.quantity.Quantities;
+
+import java.time.ZonedDateTime;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static tech.ebp.oqm.core.api.model.object.history.details.HistoryDetailType.ITEM_TRANSACTION;
+import static tech.ebp.oqm.core.api.testResources.TestConstants.DEFAULT_TEST_DB_NAME;
+
+@Slf4j
+@QuarkusTest
+@QuarkusTestResource(value = KafkaCompanionResource.class, restrictToAnnotatedClass = true)
+public class SetAmountAppliedTransactionTest extends AppliedTransactionServiceTest {
+	@Test
+	public void applySetAmountSuccessBulkNotInBlock() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.BULK, entity);
+		
+		ItemStoredTransaction preApplyTransaction = SetAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.block(item.getStorageBlocks().getFirst())
+														.build();
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(1, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(5, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 1);
+		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
+		
+		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
+		assertEquals(storedFromSearch, stored);
+		assertEquals(Quantities.getQuantity(5, item.getUnit()), stored.getAmount());
+		
+		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
+		assertFalse(storedHistory.isEmpty());
+		UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
+		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+	}
+	
+	
+	@Test
+	public void applySetAmountSuccessBulkAlreadyInBlock() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.BULK, entity);
+		
+		AmountStored originalStored = AmountStored.builder()
+										  .item(item.getId())
+										  .storageBlock(item.getStorageBlocks().getFirst())
+										  .amount(Quantities.getQuantity(5, item.getUnit()))
+										  .build();
+		this.storedService.add(DEFAULT_TEST_DB_NAME, originalStored, entity);
+		
+		
+		ItemStoredTransaction preApplyTransaction = SetAmountTransaction.builder()
+														.amount(Quantities.getQuantity(6, item.getUnit()))
+														.block(item.getStorageBlocks().getFirst())
+														.build();
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(1, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(6, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 1);
+		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
+		
+		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
+		assertEquals(originalStored.getId(), stored.getId());
+		assertEquals(storedFromSearch, stored);
+		assertEquals(Quantities.getQuantity(6, item.getUnit()), stored.getAmount());
+		
+		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
+		assertFalse(storedHistory.isEmpty());
+		UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
+		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+	}
+	
+	
+	@Test
+	public void applySetAmountSuccessAmtListExistingStored() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
+		
+		AmountStored originalStored = AmountStored.builder()
+										  .item(item.getId())
+										  .storageBlock(item.getStorageBlocks().getFirst())
+										  .amount(Quantities.getQuantity(5, item.getUnit()))
+										  .build();
+		this.storedService.add(DEFAULT_TEST_DB_NAME, originalStored, entity);
+		
+		
+		ItemStoredTransaction preApplyTransaction = SetAmountTransaction.builder()
+														.amount(Quantities.getQuantity(6, item.getUnit()))
+														.block(item.getStorageBlocks().getFirst())
+														.stored(originalStored.getId())
+														.build();
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(1, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(6, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 1);
+		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
+		
+		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
+		assertEquals(originalStored.getId(), stored.getId());
+		assertEquals(storedFromSearch, stored);
+		assertEquals(Quantities.getQuantity(6, item.getUnit()), stored.getAmount());
+		
+		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
+		assertFalse(storedHistory.isEmpty());
+		UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
+		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+	}
+	
+	@Test
+	public void applySetAmountFailUniqueMulti() {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.UNIQUE_MULTI, entity);
+		
+		ItemStoredTransaction preApplyTransaction = SetAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.block(item.getStorageBlocks().getFirst())
+														.build();
+		
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("Cannot add an amount to a unique item.", e.getMessage());
+	}
+	
+	@Test
+	public void applySetAmountFailUniqueSingle() {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.UNIQUE_SINGLE, entity);
+		
+		ItemStoredTransaction preApplyTransaction = SetAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.block(item.getStorageBlocks().getFirst())
+														.build();
+		
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("Cannot add an amount to a unique item.", e.getMessage());
+	}
+	
+	@Test
+	public void applySetAmountFailBulkBlockNotInInventory() {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.BULK, entity);
+		
+		ObjectId badBlockId = new ObjectId();
+		ItemStoredTransaction preApplyTransaction = SetAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.block(badBlockId)
+														.build();
+		
+		ValidationException e = assertThrows(ValidationException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("Storage block " + badBlockId + " not used to hold this item (" + item.getId() + ").", e.getMessage());
+	}
+	
+	@Test
+	public void applySetAmountFailBulkStoredNotInBlock() {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.BULK, entity);
+		
+		ObjectId badStoredId = new ObjectId();
+		ItemStoredTransaction preApplyTransaction = SetAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.stored(badStoredId)
+														.block(item.getStorageBlocks().getFirst())
+														.build();
+		
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("To Stored given does not match stored found in block.", e.getMessage());
+	}
+	
+	@Test
+	public void applySetAmountFailAmtListBadStored() {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
+		
+		ObjectId badStoredId = new ObjectId();
+		ItemStoredTransaction preApplyTransaction = SetAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.stored(badStoredId)
+														.block(item.getStorageBlocks().getFirst())
+														.build();
+		
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("Could not find Stored with id " + badStoredId, e.getMessage());
+	}
+	
+	@Test
+	public void applySetAmountFailAmtListBadStoredNotInBlock() {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
+		
+		ObjectId origBlock = item.getStorageBlocks().getFirst();
+		ObjectId otherBlockId = this.storageBlockService.add(DEFAULT_TEST_DB_NAME, StorageBlock.builder().label(FAKER.location().building()).build(), entity).getId();
+		
+		item.getStorageBlocks().add(otherBlockId);
+		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
+		
+		AmountStored originalStored = AmountStored.builder()
+										  .item(item.getId())
+										  .storageBlock(origBlock)
+										  .amount(Quantities.getQuantity(5, item.getUnit()))
+										  .build();
+		this.storedService.add(DEFAULT_TEST_DB_NAME, originalStored, entity);
+		
+		ItemStoredTransaction preApplyTransaction = SetAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.stored(originalStored.getId())
+														.block(otherBlockId)
+														.build();
+		
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("To Stored given does not exist in block.", e.getMessage());
+	}
+	
+	@Test
+	public void applySetAmountFailAmtListNewEntry() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
+		
+		ItemStoredTransaction preApplyTransaction = SetAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.block(item.getStorageBlocks().getFirst())
+														.build();
+		
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("Must specify a stored to set the amount of.", e.getMessage());
+	}
+	
+	//TODO:: any more?
+}
diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/SubtractAmountAppliedTransactionTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/SubtractAmountAppliedTransactionTest.java
new file mode 100644
index 000000000..2cdc525f6
--- /dev/null
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/SubtractAmountAppliedTransactionTest.java
@@ -0,0 +1,491 @@
+package tech.ebp.oqm.core.api.service.mongo.transactions.transactionApplier;
+
+import io.quarkus.test.common.QuarkusTestResource;
+import io.quarkus.test.junit.QuarkusTest;
+import io.quarkus.test.kafka.KafkaCompanionResource;
+import jakarta.validation.ValidationException;
+import lombok.extern.slf4j.Slf4j;
+import org.bson.types.ObjectId;
+import org.junit.jupiter.api.Test;
+import tech.ebp.oqm.core.api.model.object.history.ObjectHistoryEvent;
+import tech.ebp.oqm.core.api.model.object.history.details.ItemTransactionDetail;
+import tech.ebp.oqm.core.api.model.object.history.events.UpdateEvent;
+import tech.ebp.oqm.core.api.model.object.interactingEntity.InteractingEntity;
+import tech.ebp.oqm.core.api.model.object.storage.items.InventoryItem;
+import tech.ebp.oqm.core.api.model.object.storage.items.StorageType;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.AmountStored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.Stored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.UniqueStored;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.AppliedTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.ItemStoredTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.set.SetAmountTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.subtract.SubAmountTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.storageBlock.StorageBlock;
+import tech.ebp.oqm.core.api.model.rest.search.HistorySearch;
+import tech.ebp.oqm.core.api.model.rest.search.StoredSearch;
+import tech.ebp.oqm.core.api.service.mongo.search.SearchResult;
+import tech.units.indriya.quantity.Quantities;
+
+import java.time.ZonedDateTime;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static tech.ebp.oqm.core.api.model.object.history.details.HistoryDetailType.ITEM_TRANSACTION;
+import static tech.ebp.oqm.core.api.testResources.TestConstants.DEFAULT_TEST_DB_NAME;
+
+@Slf4j
+@QuarkusTest
+@QuarkusTestResource(value = KafkaCompanionResource.class, restrictToAnnotatedClass = true)
+public class SubtractAmountAppliedTransactionTest extends AppliedTransactionServiceTest {
+	@Test
+	public void applySubtractAmountSuccessBulkBlock() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.BULK, entity);
+		
+		this.storedService.add(
+			DEFAULT_TEST_DB_NAME,
+			AmountStored.builder()
+				.amount(Quantities.getQuantity(5, item.getUnit()))
+				.item(item.getId())
+				.storageBlock(item.getStorageBlocks().getFirst())
+				.build(),
+			entity
+		);
+		
+		ItemStoredTransaction preApplyTransaction = SubAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.fromBlock(item.getStorageBlocks().getFirst())
+														.build();
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(1, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(0, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 1);
+		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
+		
+		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
+		assertEquals(storedFromSearch, stored);
+		assertEquals(Quantities.getQuantity(0, item.getUnit()), stored.getAmount());
+		
+		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
+		assertFalse(storedHistory.isEmpty());
+		UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
+		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+	}
+	
+	@Test
+	public void applySubtractAmountSuccessBulkStored() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.BULK, entity);
+		
+		AmountStored initialStored = AmountStored.builder()
+										 .amount(Quantities.getQuantity(5, item.getUnit()))
+										 .item(item.getId())
+										 .storageBlock(item.getStorageBlocks().getFirst())
+										 .build();
+		this.storedService.add(
+			DEFAULT_TEST_DB_NAME,
+			initialStored,
+			entity
+		);
+		
+		ItemStoredTransaction preApplyTransaction = SubAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.fromBlock(item.getStorageBlocks().getFirst())
+														.fromStored(initialStored.getId())
+														.build();
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(1, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(0, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 1);
+		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
+		
+		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
+		assertEquals(storedFromSearch, stored);
+		assertEquals(Quantities.getQuantity(0, item.getUnit()), stored.getAmount());
+		
+		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
+		assertFalse(storedHistory.isEmpty());
+		UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
+		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+	}
+	
+	@Test
+	public void applySubtractAmountSuccessList() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
+		
+		AmountStored initialStored = AmountStored.builder()
+										 .amount(Quantities.getQuantity(5, item.getUnit()))
+										 .item(item.getId())
+										 .storageBlock(item.getStorageBlocks().getFirst())
+										 .build();
+		this.storedService.add(
+			DEFAULT_TEST_DB_NAME,
+			initialStored,
+			entity
+		);
+		
+		ItemStoredTransaction preApplyTransaction = SubAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.fromBlock(item.getStorageBlocks().getFirst())
+														.fromStored(initialStored.getId())
+														.build();
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(1, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(0, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 1);
+		AmountStored storedFromSearch = (AmountStored) storedSearchResult.getResults().getFirst();
+		
+		AmountStored stored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().stream().findFirst().get());
+		assertEquals(storedFromSearch, stored);
+		assertEquals(Quantities.getQuantity(0, item.getUnit()), stored.getAmount());
+		
+		SearchResult<ObjectHistoryEvent> storedHistory = this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(stored.getId()));
+		assertFalse(storedHistory.isEmpty());
+		UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
+		assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+		assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+	}
+	
+	@Test
+	public void applySubtractAmountFailUniqueMulti() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.UNIQUE_MULTI, entity);
+		
+		UniqueStored initialStored = UniqueStored.builder()
+										 .item(item.getId())
+										 .storageBlock(item.getStorageBlocks().getFirst())
+										 .build();
+		this.storedService.add(
+			DEFAULT_TEST_DB_NAME,
+			initialStored,
+			entity
+		);
+		
+		ItemStoredTransaction preApplyTransaction = SubAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.fromBlock(item.getStorageBlocks().getFirst())
+														.fromStored(initialStored.getId())
+														.build();
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("Cannot subtract an amount from a unique item.", e.getMessage());
+	}
+	
+	@Test
+	public void applySubtractAmountFailUniqueSingle() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.UNIQUE_SINGLE, entity);
+		
+		UniqueStored initialStored = UniqueStored.builder()
+										 .item(item.getId())
+										 .storageBlock(item.getStorageBlocks().getFirst())
+										 .build();
+		this.storedService.add(
+			DEFAULT_TEST_DB_NAME,
+			initialStored,
+			entity
+		);
+		
+		ItemStoredTransaction preApplyTransaction = SubAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.fromBlock(item.getStorageBlocks().getFirst())
+														.fromStored(initialStored.getId())
+														.build();
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("Cannot subtract an amount from a unique item.", e.getMessage());
+	}
+	
+	@Test
+	public void applySubtractAmountFailBulkSubMoreThanHeld() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.BULK, entity);
+		
+		AmountStored initialStored = AmountStored.builder()
+										 .amount(Quantities.getQuantity(2, item.getUnit()))
+										 .item(item.getId())
+										 .storageBlock(item.getStorageBlocks().getFirst())
+										 .build();
+		this.storedService.add(
+			DEFAULT_TEST_DB_NAME,
+			initialStored,
+			entity
+		);
+		
+		ItemStoredTransaction preApplyTransaction = SubAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.fromBlock(item.getStorageBlocks().getFirst())
+														.fromStored(initialStored.getId())
+														.build();
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("Resulting amount less than zero. (subtracting 5 units from 2 units resulting in -3 units)", e.getMessage());
+	}
+	
+	@Test
+	public void applySubtractAmountFailAmtListSubMoreThanHeld() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
+		
+		AmountStored initialStored = AmountStored.builder()
+										 .amount(Quantities.getQuantity(2, item.getUnit()))
+										 .item(item.getId())
+										 .storageBlock(item.getStorageBlocks().getFirst())
+										 .build();
+		this.storedService.add(
+			DEFAULT_TEST_DB_NAME,
+			initialStored,
+			entity
+		);
+		
+		ItemStoredTransaction preApplyTransaction = SubAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.fromBlock(item.getStorageBlocks().getFirst())
+														.fromStored(initialStored.getId())
+														.build();
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("Resulting amount less than zero. (subtracting 5 units from 2 units resulting in -3 units)", e.getMessage());
+	}
+	
+	@Test
+	public void applySubtractAmountFailBulkMismatchedBlock() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.BULK, entity);
+		
+		StorageBlock newBlock = StorageBlock.builder().label(FAKER.location().building()).build();
+		this.storageBlockService.add(DEFAULT_TEST_DB_NAME, newBlock, entity);
+		item.getStorageBlocks().add(newBlock.getId());
+		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
+		
+		AmountStored initialStored = AmountStored.builder()
+										 .amount(Quantities.getQuantity(5, item.getUnit()))
+										 .item(item.getId())
+										 .storageBlock(item.getStorageBlocks().getFirst())
+										 .build();
+		this.storedService.add(
+			DEFAULT_TEST_DB_NAME,
+			initialStored,
+			entity
+		);
+		AmountStored secondStored = AmountStored.builder()
+										.amount(Quantities.getQuantity(5, item.getUnit()))
+										.item(item.getId())
+										.storageBlock(newBlock.getId())
+										.build();
+		this.storedService.add(
+			DEFAULT_TEST_DB_NAME,
+			secondStored,
+			entity
+		);
+		
+		ItemStoredTransaction preApplyTransaction = SubAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.fromBlock(newBlock.getId())
+														.fromStored(initialStored.getId())
+														.build();
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("Stored id in transaction not the id of stored found.", e.getMessage());
+	}
+	
+	@Test
+	public void applySubtractAmountFailBulkMismatchedStored() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.BULK, entity);
+		
+		StorageBlock newBlock = StorageBlock.builder().label(FAKER.location().building()).build();
+		this.storageBlockService.add(DEFAULT_TEST_DB_NAME, newBlock, entity);
+		item.getStorageBlocks().add(newBlock.getId());
+		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
+		
+		AmountStored initialStored = AmountStored.builder()
+										 .amount(Quantities.getQuantity(5, item.getUnit()))
+										 .item(item.getId())
+										 .storageBlock(item.getStorageBlocks().getFirst())
+										 .build();
+		this.storedService.add(
+			DEFAULT_TEST_DB_NAME,
+			initialStored,
+			entity
+		);
+		AmountStored secondStored = AmountStored.builder()
+										.amount(Quantities.getQuantity(5, item.getUnit()))
+										.item(item.getId())
+										.storageBlock(newBlock.getId())
+										.build();
+		this.storedService.add(
+			DEFAULT_TEST_DB_NAME,
+			secondStored,
+			entity
+		);
+		
+		ItemStoredTransaction preApplyTransaction = SubAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.fromBlock(item.getStorageBlocks().getFirst())
+														.fromStored(secondStored.getId())
+														.build();
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("Stored id in transaction not the id of stored found.", e.getMessage());
+	}
+	
+	@Test
+	public void applySubtractAmountFailListMismatchedBlock() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
+		
+		StorageBlock newBlock = StorageBlock.builder().label(FAKER.location().building()).build();
+		this.storageBlockService.add(DEFAULT_TEST_DB_NAME, newBlock, entity);
+		item.getStorageBlocks().add(newBlock.getId());
+		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
+		
+		AmountStored initialStored = AmountStored.builder()
+										 .amount(Quantities.getQuantity(5, item.getUnit()))
+										 .item(item.getId())
+										 .storageBlock(item.getStorageBlocks().getFirst())
+										 .build();
+		this.storedService.add(
+			DEFAULT_TEST_DB_NAME,
+			initialStored,
+			entity
+		);
+		AmountStored secondStored = AmountStored.builder()
+										.amount(Quantities.getQuantity(5, item.getUnit()))
+										.item(item.getId())
+										.storageBlock(newBlock.getId())
+										.build();
+		this.storedService.add(
+			DEFAULT_TEST_DB_NAME,
+			secondStored,
+			entity
+		);
+		
+		ItemStoredTransaction preApplyTransaction = SubAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.fromBlock(newBlock.getId())
+														.fromStored(initialStored.getId())
+														.build();
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("Stored retrieved not in specified block.", e.getMessage());
+	}
+	
+	@Test
+	public void applySubtractAmountFailListMismatchedStored() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
+		
+		StorageBlock newBlock = StorageBlock.builder().label(FAKER.location().building()).build();
+		this.storageBlockService.add(DEFAULT_TEST_DB_NAME, newBlock, entity);
+		item.getStorageBlocks().add(newBlock.getId());
+		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
+		
+		AmountStored initialStored = AmountStored.builder()
+										 .amount(Quantities.getQuantity(5, item.getUnit()))
+										 .item(item.getId())
+										 .storageBlock(item.getStorageBlocks().getFirst())
+										 .build();
+		this.storedService.add(
+			DEFAULT_TEST_DB_NAME,
+			initialStored,
+			entity
+		);
+		AmountStored secondStored = AmountStored.builder()
+										.amount(Quantities.getQuantity(5, item.getUnit()))
+										.item(item.getId())
+										.storageBlock(newBlock.getId())
+										.build();
+		this.storedService.add(
+			DEFAULT_TEST_DB_NAME,
+			secondStored,
+			entity
+		);
+		
+		ItemStoredTransaction preApplyTransaction = SubAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.fromBlock(item.getStorageBlocks().getFirst())
+														.fromStored(secondStored.getId())
+														.build();
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("Stored retrieved not in specified block.", e.getMessage());
+	}
+	
+	@Test
+	public void applySubtractAmountFailNullStored() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
+		
+		AmountStored initialStored = AmountStored.builder()
+										 .amount(Quantities.getQuantity(5, item.getUnit()))
+										 .item(item.getId())
+										 .storageBlock(item.getStorageBlocks().getFirst())
+										 .build();
+		this.storedService.add(
+			DEFAULT_TEST_DB_NAME,
+			initialStored,
+			entity
+		);
+		
+		ItemStoredTransaction preApplyTransaction = SubAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.fromBlock(item.getStorageBlocks().getFirst())
+														.build();
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("Must specify the stored item we are subtracting from.", e.getMessage());
+	}
+	
+	//TODO:: any more?
+}
diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/SubtractWholeAppliedTransactionTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/SubtractWholeAppliedTransactionTest.java
new file mode 100644
index 000000000..3a0a540d5
--- /dev/null
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/SubtractWholeAppliedTransactionTest.java
@@ -0,0 +1,45 @@
+package tech.ebp.oqm.core.api.service.mongo.transactions.transactionApplier;
+
+import io.quarkus.test.common.QuarkusTestResource;
+import io.quarkus.test.junit.QuarkusTest;
+import io.quarkus.test.kafka.KafkaCompanionResource;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.jupiter.api.Test;
+import tech.ebp.oqm.core.api.model.object.history.ObjectHistoryEvent;
+import tech.ebp.oqm.core.api.model.object.history.details.ItemTransactionDetail;
+import tech.ebp.oqm.core.api.model.object.history.events.UpdateEvent;
+import tech.ebp.oqm.core.api.model.object.interactingEntity.InteractingEntity;
+import tech.ebp.oqm.core.api.model.object.storage.items.InventoryItem;
+import tech.ebp.oqm.core.api.model.object.storage.items.StorageType;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.AmountStored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.Stored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.UniqueStored;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.AppliedTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.ItemStoredTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.subtract.SubAmountTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.storageBlock.StorageBlock;
+import tech.ebp.oqm.core.api.model.rest.search.HistorySearch;
+import tech.ebp.oqm.core.api.model.rest.search.StoredSearch;
+import tech.ebp.oqm.core.api.service.mongo.search.SearchResult;
+import tech.units.indriya.quantity.Quantities;
+
+import java.time.ZonedDateTime;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static tech.ebp.oqm.core.api.model.object.history.details.HistoryDetailType.ITEM_TRANSACTION;
+import static tech.ebp.oqm.core.api.testResources.TestConstants.DEFAULT_TEST_DB_NAME;
+
+@Slf4j
+@QuarkusTest
+@QuarkusTestResource(value = KafkaCompanionResource.class, restrictToAnnotatedClass = true)
+public class SubtractWholeAppliedTransactionTest extends AppliedTransactionServiceTest {
+	//TODO:: Success - bulk
+	//TODO:: Success - amt list
+	//TODO:: Success - unique list
+	//TODO:: Success - unique single
+	//TODO:: fail - mismatched item/stored/block
+	//TODO:: any more?
+}
diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/TransferAmountAppliedTransactionTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/TransferAmountAppliedTransactionTest.java
new file mode 100644
index 000000000..21b064134
--- /dev/null
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/TransferAmountAppliedTransactionTest.java
@@ -0,0 +1,726 @@
+package tech.ebp.oqm.core.api.service.mongo.transactions.transactionApplier;
+
+import io.quarkus.test.common.QuarkusTestResource;
+import io.quarkus.test.junit.QuarkusTest;
+import io.quarkus.test.kafka.KafkaCompanionResource;
+import lombok.extern.slf4j.Slf4j;
+import org.bson.types.ObjectId;
+import org.junit.jupiter.api.Test;
+import tech.ebp.oqm.core.api.model.object.history.ObjectHistoryEvent;
+import tech.ebp.oqm.core.api.model.object.history.details.ItemTransactionDetail;
+import tech.ebp.oqm.core.api.model.object.history.events.UpdateEvent;
+import tech.ebp.oqm.core.api.model.object.interactingEntity.InteractingEntity;
+import tech.ebp.oqm.core.api.model.object.storage.items.InventoryItem;
+import tech.ebp.oqm.core.api.model.object.storage.items.StorageType;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.AmountStored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.Stored;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.AppliedTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.ItemStoredTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.transfer.TransferAmountTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.storageBlock.StorageBlock;
+import tech.ebp.oqm.core.api.model.rest.search.HistorySearch;
+import tech.ebp.oqm.core.api.model.rest.search.StoredSearch;
+import tech.ebp.oqm.core.api.service.mongo.search.SearchResult;
+import tech.units.indriya.quantity.Quantities;
+
+import java.time.ZonedDateTime;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static tech.ebp.oqm.core.api.model.object.history.details.HistoryDetailType.ITEM_TRANSACTION;
+import static tech.ebp.oqm.core.api.testResources.TestConstants.DEFAULT_TEST_DB_NAME;
+
+@Slf4j
+@QuarkusTest
+@QuarkusTestResource(value = KafkaCompanionResource.class, restrictToAnnotatedClass = true)
+public class TransferAmountAppliedTransactionTest extends AppliedTransactionServiceTest {
+	
+	@Test
+	public void applyTransferAmountSuccessBulkNotInBlock() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.BULK, entity);
+		ObjectId firstBlock = item.getStorageBlocks().getFirst();
+		ObjectId secondBlock = this.storageBlockService.add(
+			DEFAULT_TEST_DB_NAME,
+			StorageBlock.builder().label(FAKER.location().building()).build(),
+			entity
+		).getId();
+		item.getStorageBlocks().add(secondBlock);
+		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
+		
+		ObjectId initialStoredId = this.storedService.add(
+			DEFAULT_TEST_DB_NAME, AmountStored.builder()
+									  .item(item.getId())
+									  .storageBlock(firstBlock)
+									  .amount(Quantities.getQuantity(5, item.getUnit()))
+									  .build(),
+			entity
+		).getId();
+		
+		ItemStoredTransaction preApplyTransaction = TransferAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.fromBlock(firstBlock)
+														.toBlock(secondBlock)
+														.build();
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(2, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		assertEquals(2, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(5, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 2);
+		//'first' and 'second' are flipped here
+		AmountStored firstStoredFromSearch = (AmountStored) storedSearchResult.getResults().get(0);
+		AmountStored secondStoredFromSearch = (AmountStored) storedSearchResult.getResults().get(1);
+		
+		{
+			AmountStored firstStored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().getFirst());
+			assertEquals(firstStoredFromSearch, firstStored);
+			assertEquals(Quantities.getQuantity(5, item.getUnit()), firstStored.getAmount());
+			
+			SearchResult<ObjectHistoryEvent>
+				storedHistory =
+				this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(firstStored.getId()));
+			assertFalse(storedHistory.isEmpty());
+			UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
+			assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+			assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+		}
+		{
+			AmountStored secondStored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().getLast());
+			assertEquals(secondStoredFromSearch, secondStored);
+			assertEquals(Quantities.getQuantity(0, item.getUnit()), secondStored.getAmount());
+			
+			SearchResult<ObjectHistoryEvent>
+				storedHistory =
+				this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(secondStored.getId()));
+			assertFalse(storedHistory.isEmpty());
+			UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
+			assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+			assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+		}
+	}
+	
+	@Test
+	public void applyTransferAmountSuccessBulkInBlock() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.BULK, entity);
+		ObjectId firstBlock = item.getStorageBlocks().getFirst();
+		ObjectId secondBlock = this.storageBlockService.add(
+			DEFAULT_TEST_DB_NAME,
+			StorageBlock.builder().label(FAKER.location().building()).build(),
+			entity
+		).getId();
+		item.getStorageBlocks().add(secondBlock);
+		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
+		
+		ObjectId initialStoredId = this.storedService.add(
+			DEFAULT_TEST_DB_NAME, AmountStored.builder()
+									  .item(item.getId())
+									  .storageBlock(firstBlock)
+									  .amount(Quantities.getQuantity(5, item.getUnit()))
+									  .build(),
+			entity
+		).getId();
+		ObjectId destinationStoredId = this.storedService.add(
+			DEFAULT_TEST_DB_NAME, AmountStored.builder()
+									  .item(item.getId())
+									  .storageBlock(secondBlock)
+									  .amount(Quantities.getQuantity(0, item.getUnit()))
+									  .build(),
+			entity
+		).getId();
+		
+		ItemStoredTransaction preApplyTransaction = TransferAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.fromBlock(firstBlock)
+														.toBlock(secondBlock)
+														.build();
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(2, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		assertEquals(2, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(5, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 2);
+		//'first' and 'second' are flipped here
+		AmountStored firstStoredFromSearch = (AmountStored) storedSearchResult.getResults().get(0);
+		AmountStored secondStoredFromSearch = (AmountStored) storedSearchResult.getResults().get(1);
+		
+		{
+			AmountStored firstStored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().getFirst());
+			assertEquals(firstStoredFromSearch, firstStored);
+			assertEquals(Quantities.getQuantity(5, item.getUnit()), firstStored.getAmount());
+			
+			SearchResult<ObjectHistoryEvent>
+				storedHistory =
+				this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(firstStored.getId()));
+			assertFalse(storedHistory.isEmpty());
+			UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
+			assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+			assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+		}
+		{
+			AmountStored secondStored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().getLast());
+			assertEquals(secondStoredFromSearch, secondStored);
+			assertEquals(Quantities.getQuantity(0, item.getUnit()), secondStored.getAmount());
+			
+			SearchResult<ObjectHistoryEvent>
+				storedHistory =
+				this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(secondStored.getId()));
+			assertFalse(storedHistory.isEmpty());
+			UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
+			assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+			assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+		}
+	}
+	
+	@Test
+	public void applyTransferAmountSuccessBulkFromBlockToStored() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.BULK, entity);
+		ObjectId firstBlock = item.getStorageBlocks().getFirst();
+		ObjectId secondBlock = this.storageBlockService.add(
+			DEFAULT_TEST_DB_NAME,
+			StorageBlock.builder().label(FAKER.location().building()).build(),
+			entity
+		).getId();
+		item.getStorageBlocks().add(secondBlock);
+		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
+		
+		ObjectId initialStoredId = this.storedService.add(
+			DEFAULT_TEST_DB_NAME, AmountStored.builder()
+									  .item(item.getId())
+									  .storageBlock(firstBlock)
+									  .amount(Quantities.getQuantity(5, item.getUnit()))
+									  .build(),
+			entity
+		).getId();
+		ObjectId destinationStoredId = this.storedService.add(
+			DEFAULT_TEST_DB_NAME, AmountStored.builder()
+									  .item(item.getId())
+									  .storageBlock(secondBlock)
+									  .amount(Quantities.getQuantity(0, item.getUnit()))
+									  .build(),
+			entity
+		).getId();
+		
+		ItemStoredTransaction preApplyTransaction = TransferAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.fromBlock(firstBlock)
+														.toBlock(secondBlock)
+														.toStored(destinationStoredId)
+														.build();
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(2, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		assertEquals(2, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(5, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 2);
+		//'first' and 'second' are flipped here
+		AmountStored firstStoredFromSearch = (AmountStored) storedSearchResult.getResults().get(0);
+		AmountStored secondStoredFromSearch = (AmountStored) storedSearchResult.getResults().get(1);
+		
+		{
+			AmountStored firstStored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().getFirst());
+			assertEquals(firstStoredFromSearch, firstStored);
+			assertEquals(Quantities.getQuantity(5, item.getUnit()), firstStored.getAmount());
+			
+			SearchResult<ObjectHistoryEvent>
+				storedHistory =
+				this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(firstStored.getId()));
+			assertFalse(storedHistory.isEmpty());
+			UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
+			assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+			assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+		}
+		{
+			AmountStored secondStored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().getLast());
+			assertEquals(secondStoredFromSearch, secondStored);
+			assertEquals(Quantities.getQuantity(0, item.getUnit()), secondStored.getAmount());
+			
+			SearchResult<ObjectHistoryEvent>
+				storedHistory =
+				this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(secondStored.getId()));
+			assertFalse(storedHistory.isEmpty());
+			UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
+			assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+			assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+		}
+	}
+	
+	@Test
+	public void applyTransferAmountSuccessBulkFromStoredToBlock() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.BULK, entity);
+		ObjectId firstBlock = item.getStorageBlocks().getFirst();
+		ObjectId secondBlock = this.storageBlockService.add(
+			DEFAULT_TEST_DB_NAME,
+			StorageBlock.builder().label(FAKER.location().building()).build(),
+			entity
+		).getId();
+		item.getStorageBlocks().add(secondBlock);
+		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
+		
+		ObjectId initialStoredId = this.storedService.add(
+			DEFAULT_TEST_DB_NAME, AmountStored.builder()
+									  .item(item.getId())
+									  .storageBlock(firstBlock)
+									  .amount(Quantities.getQuantity(5, item.getUnit()))
+									  .build(),
+			entity
+		).getId();
+		ObjectId destinationStoredId = this.storedService.add(
+			DEFAULT_TEST_DB_NAME, AmountStored.builder()
+									  .item(item.getId())
+									  .storageBlock(secondBlock)
+									  .amount(Quantities.getQuantity(0, item.getUnit()))
+									  .build(),
+			entity
+		).getId();
+		
+		ItemStoredTransaction preApplyTransaction = TransferAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.fromBlock(firstBlock)
+														.fromStored(initialStoredId)
+														.toBlock(secondBlock)
+														.build();
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(2, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		assertEquals(2, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(5, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 2);
+		//'first' and 'second' are flipped here
+		AmountStored firstStoredFromSearch = (AmountStored) storedSearchResult.getResults().get(0);
+		AmountStored secondStoredFromSearch = (AmountStored) storedSearchResult.getResults().get(1);
+		
+		{
+			AmountStored firstStored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().getFirst());
+			assertEquals(firstStoredFromSearch, firstStored);
+			assertEquals(Quantities.getQuantity(5, item.getUnit()), firstStored.getAmount());
+			
+			SearchResult<ObjectHistoryEvent>
+				storedHistory =
+				this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(firstStored.getId()));
+			assertFalse(storedHistory.isEmpty());
+			UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
+			assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+			assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+		}
+		{
+			AmountStored secondStored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().getLast());
+			assertEquals(secondStoredFromSearch, secondStored);
+			assertEquals(Quantities.getQuantity(0, item.getUnit()), secondStored.getAmount());
+			
+			SearchResult<ObjectHistoryEvent>
+				storedHistory =
+				this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(secondStored.getId()));
+			assertFalse(storedHistory.isEmpty());
+			UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
+			assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+			assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+		}
+	}
+	
+	@Test
+	public void applyTransferAmountSuccessList() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
+		ObjectId firstBlock = item.getStorageBlocks().getFirst();
+		ObjectId secondBlock = this.storageBlockService.add(
+			DEFAULT_TEST_DB_NAME,
+			StorageBlock.builder().label(FAKER.location().building()).build(),
+			entity
+		).getId();
+		item.getStorageBlocks().add(secondBlock);
+		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
+		
+		ObjectId initialStoredId = this.storedService.add(
+			DEFAULT_TEST_DB_NAME, AmountStored.builder()
+									  .item(item.getId())
+									  .storageBlock(firstBlock)
+									  .amount(Quantities.getQuantity(5, item.getUnit()))
+									  .build(),
+			entity
+		).getId();
+		ObjectId destinationStoredId = this.storedService.add(
+			DEFAULT_TEST_DB_NAME, AmountStored.builder()
+									  .item(item.getId())
+									  .storageBlock(secondBlock)
+									  .amount(Quantities.getQuantity(0, item.getUnit()))
+									  .build(),
+			entity
+		).getId();
+		
+		ItemStoredTransaction preApplyTransaction = TransferAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.fromBlock(firstBlock)
+														.fromStored(initialStoredId)
+														.toBlock(secondBlock)
+														.toStored(destinationStoredId)
+														.build();
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(2, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		assertEquals(2, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(5, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 2);
+		//'first' and 'second' are flipped here
+		AmountStored firstStoredFromSearch = (AmountStored) storedSearchResult.getResults().get(0);
+		AmountStored secondStoredFromSearch = (AmountStored) storedSearchResult.getResults().get(1);
+		
+		{
+			AmountStored firstStored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().getFirst());
+			assertEquals(firstStoredFromSearch, firstStored);
+			assertEquals(Quantities.getQuantity(5, item.getUnit()), firstStored.getAmount());
+			
+			SearchResult<ObjectHistoryEvent>
+				storedHistory =
+				this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(firstStored.getId()));
+			assertFalse(storedHistory.isEmpty());
+			UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
+			assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+			assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+		}
+		{
+			AmountStored secondStored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().getLast());
+			assertEquals(secondStoredFromSearch, secondStored);
+			assertEquals(Quantities.getQuantity(0, item.getUnit()), secondStored.getAmount());
+			
+			SearchResult<ObjectHistoryEvent>
+				storedHistory =
+				this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(secondStored.getId()));
+			assertFalse(storedHistory.isEmpty());
+			UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
+			assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+			assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+		}
+	}
+	
+	@Test
+	public void applyTransferAmountSuccessListToNonExistent() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
+		ObjectId firstBlock = item.getStorageBlocks().getFirst();
+		ObjectId secondBlock = this.storageBlockService.add(
+			DEFAULT_TEST_DB_NAME,
+			StorageBlock.builder().label(FAKER.location().building()).build(),
+			entity
+		).getId();
+		item.getStorageBlocks().add(secondBlock);
+		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
+		
+		ObjectId initialStoredId = this.storedService.add(
+			DEFAULT_TEST_DB_NAME, AmountStored.builder()
+									  .item(item.getId())
+									  .storageBlock(firstBlock)
+									  .amount(Quantities.getQuantity(5, item.getUnit()))
+									  .build(),
+			entity
+		).getId();
+		
+		ItemStoredTransaction preApplyTransaction = TransferAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.fromBlock(firstBlock)
+														.fromStored(initialStoredId)
+														.toBlock(secondBlock)
+														.build();
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(2, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		assertEquals(2, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(5, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 2);
+		//'first' and 'second' are flipped here
+		AmountStored firstStoredFromSearch = (AmountStored) storedSearchResult.getResults().get(0);
+		AmountStored secondStoredFromSearch = (AmountStored) storedSearchResult.getResults().get(1);
+		
+		{
+			AmountStored firstStored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().getFirst());
+			assertEquals(firstStoredFromSearch, firstStored);
+			assertEquals(Quantities.getQuantity(5, item.getUnit()), firstStored.getAmount());
+			
+			SearchResult<ObjectHistoryEvent>
+				storedHistory =
+				this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(firstStored.getId()));
+			assertFalse(storedHistory.isEmpty());
+			UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
+			assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+			assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+		}
+		{
+			AmountStored secondStored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().getLast());
+			assertEquals(secondStoredFromSearch, secondStored);
+			assertEquals(Quantities.getQuantity(0, item.getUnit()), secondStored.getAmount());
+			
+			SearchResult<ObjectHistoryEvent>
+				storedHistory =
+				this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(secondStored.getId()));
+			assertFalse(storedHistory.isEmpty());
+			UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
+			assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+			assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+		}
+	}
+	
+	
+	@Test
+	public void applyTransferAmountFailUniqueMulti() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.UNIQUE_MULTI, entity);
+		ObjectId firstBlock = item.getStorageBlocks().getFirst();
+		ObjectId secondBlock = this.storageBlockService.add(
+			DEFAULT_TEST_DB_NAME,
+			StorageBlock.builder().label(FAKER.location().building()).build(),
+			entity
+		).getId();
+		
+		ItemStoredTransaction preApplyTransaction = TransferAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.fromBlock(firstBlock)
+														.toBlock(secondBlock)
+														.build();
+		
+		
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("Cannot subtract an amount from a unique item.", e.getMessage());
+	}
+	
+	@Test
+	public void applyTransferAmountFailUniqueSingle() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.UNIQUE_SINGLE, entity);
+		ObjectId firstBlock = item.getStorageBlocks().getFirst();
+		ObjectId secondBlock = this.storageBlockService.add(
+			DEFAULT_TEST_DB_NAME,
+			StorageBlock.builder().label(FAKER.location().building()).build(),
+			entity
+		).getId();
+		
+		ItemStoredTransaction preApplyTransaction = TransferAmountTransaction.builder()
+														.amount(Quantities.getQuantity(5, item.getUnit()))
+														.fromBlock(firstBlock)
+														.toBlock(secondBlock)
+														.build();
+		
+		
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("Cannot subtract an amount from a unique item.", e.getMessage());
+	}
+	
+	@Test
+	public void applyTransferAmountFailBulkNotEnoughToTransfer() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.BULK, entity);
+		ObjectId firstBlock = item.getStorageBlocks().getFirst();
+		ObjectId secondBlock = this.storageBlockService.add(
+			DEFAULT_TEST_DB_NAME,
+			StorageBlock.builder().label(FAKER.location().building()).build(),
+			entity
+		).getId();
+		item.getStorageBlocks().add(secondBlock);
+		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
+		
+		ObjectId initialStoredId = this.storedService.add(
+			DEFAULT_TEST_DB_NAME, AmountStored.builder()
+									  .item(item.getId())
+									  .storageBlock(firstBlock)
+									  .amount(Quantities.getQuantity(5, item.getUnit()))
+									  .build(),
+			entity
+		).getId();
+		
+		ItemStoredTransaction preApplyTransaction = TransferAmountTransaction.builder()
+														.amount(Quantities.getQuantity(6, item.getUnit()))
+														.fromBlock(firstBlock)
+														.toBlock(secondBlock)
+														.build();
+		
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("Resulting amount less than zero. (subtracting 6 units from 5 units resulting in -1 units)", e.getMessage());
+	}
+	
+	@Test
+	public void applyTransferAmountFailAmtListNotEnoughToTransfer() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
+		ObjectId firstBlock = item.getStorageBlocks().getFirst();
+		ObjectId secondBlock = this.storageBlockService.add(
+			DEFAULT_TEST_DB_NAME,
+			StorageBlock.builder().label(FAKER.location().building()).build(),
+			entity
+		).getId();
+		item.getStorageBlocks().add(secondBlock);
+		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
+		
+		ObjectId initialStoredId = this.storedService.add(
+			DEFAULT_TEST_DB_NAME, AmountStored.builder()
+									  .item(item.getId())
+									  .storageBlock(firstBlock)
+									  .amount(Quantities.getQuantity(5, item.getUnit()))
+									  .build(),
+			entity
+		).getId();
+		
+		ItemStoredTransaction preApplyTransaction = TransferAmountTransaction.builder()
+														.amount(Quantities.getQuantity(6, item.getUnit()))
+														.fromBlock(firstBlock)
+														.fromStored(initialStoredId)
+														.toBlock(secondBlock)
+														.build();
+		
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("Resulting amount less than zero. (subtracting 6 units from 5 units resulting in -1 units)", e.getMessage());
+	}
+	
+	@Test
+	public void applyTransferAmountFailBulkMismatchedStoredId() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.BULK, entity);
+		ObjectId firstBlock = item.getStorageBlocks().getFirst();
+		ObjectId secondBlock = this.storageBlockService.add(
+			DEFAULT_TEST_DB_NAME,
+			StorageBlock.builder().label(FAKER.location().building()).build(),
+			entity
+		).getId();
+		item.getStorageBlocks().add(secondBlock);
+		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
+		
+		ObjectId initialStoredId = this.storedService.add(
+			DEFAULT_TEST_DB_NAME, AmountStored.builder()
+									  .item(item.getId())
+									  .storageBlock(firstBlock)
+									  .amount(Quantities.getQuantity(5, item.getUnit()))
+									  .build(),
+			entity
+		).getId();
+		ObjectId destinationStoredId = this.storedService.add(
+			DEFAULT_TEST_DB_NAME, AmountStored.builder()
+									  .item(item.getId())
+									  .storageBlock(secondBlock)
+									  .amount(Quantities.getQuantity(0, item.getUnit()))
+									  .build(),
+			entity
+		).getId();
+		
+		ItemStoredTransaction preApplyTransaction = TransferAmountTransaction.builder()
+														.amount(Quantities.getQuantity(6, item.getUnit()))
+														.fromBlock(firstBlock)
+														.fromStored(destinationStoredId)
+														.toBlock(secondBlock)
+														.build();
+		
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("From Stored retrieved not in specified block.", e.getMessage());
+	}
+	
+	@Test
+	public void applyTransferAmountFailBulkMismatchedBlockTo() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.BULK, entity);
+		ObjectId firstBlock = item.getStorageBlocks().getFirst();
+		ObjectId secondBlock = this.storageBlockService.add(
+			DEFAULT_TEST_DB_NAME,
+			StorageBlock.builder().label(FAKER.location().building()).build(),
+			entity
+		).getId();
+		item.getStorageBlocks().add(secondBlock);
+		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
+		
+		ObjectId initialStoredId = this.storedService.add(
+			DEFAULT_TEST_DB_NAME, AmountStored.builder()
+									  .item(item.getId())
+									  .storageBlock(firstBlock)
+									  .amount(Quantities.getQuantity(5, item.getUnit()))
+									  .build(),
+			entity
+		).getId();
+		ObjectId destinationStoredId = this.storedService.add(
+			DEFAULT_TEST_DB_NAME, AmountStored.builder()
+									  .item(item.getId())
+									  .storageBlock(secondBlock)
+									  .amount(Quantities.getQuantity(0, item.getUnit()))
+									  .build(),
+			entity
+		).getId();
+		
+		ItemStoredTransaction preApplyTransaction = TransferAmountTransaction.builder()
+														.amount(Quantities.getQuantity(6, item.getUnit()))
+														.fromBlock(firstBlock)
+														.toBlock(secondBlock)
+														.toStored(initialStoredId)
+														.build();
+		
+		IllegalArgumentException
+			e =
+			assertThrows(IllegalArgumentException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
+		assertEquals("To Stored retrieved not in specified block.", e.getMessage());
+	}
+	
+	//TODO:: any more?
+}
diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/TransferWholeAppliedTransactionTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/TransferWholeAppliedTransactionTest.java
new file mode 100644
index 000000000..d380a2732
--- /dev/null
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/TransferWholeAppliedTransactionTest.java
@@ -0,0 +1,276 @@
+package tech.ebp.oqm.core.api.service.mongo.transactions.transactionApplier;
+
+import io.quarkus.test.common.QuarkusTestResource;
+import io.quarkus.test.junit.QuarkusTest;
+import io.quarkus.test.kafka.KafkaCompanionResource;
+import lombok.extern.slf4j.Slf4j;
+import org.bson.types.ObjectId;
+import org.junit.jupiter.api.Test;
+import tech.ebp.oqm.core.api.model.object.history.ObjectHistoryEvent;
+import tech.ebp.oqm.core.api.model.object.history.details.ItemTransactionDetail;
+import tech.ebp.oqm.core.api.model.object.history.events.UpdateEvent;
+import tech.ebp.oqm.core.api.model.object.interactingEntity.InteractingEntity;
+import tech.ebp.oqm.core.api.model.object.storage.items.InventoryItem;
+import tech.ebp.oqm.core.api.model.object.storage.items.StorageType;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.AmountStored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.Stored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.UniqueStored;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.AppliedTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.ItemStoredTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.transfer.TransferAmountTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.transfer.TransferWholeTransaction;
+import tech.ebp.oqm.core.api.model.object.storage.storageBlock.StorageBlock;
+import tech.ebp.oqm.core.api.model.rest.search.HistorySearch;
+import tech.ebp.oqm.core.api.model.rest.search.StoredSearch;
+import tech.ebp.oqm.core.api.service.mongo.search.SearchResult;
+import tech.units.indriya.quantity.Quantities;
+
+import java.time.ZonedDateTime;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static tech.ebp.oqm.core.api.model.object.history.details.HistoryDetailType.ITEM_TRANSACTION;
+import static tech.ebp.oqm.core.api.testResources.TestConstants.DEFAULT_TEST_DB_NAME;
+
+@Slf4j
+@QuarkusTest
+@QuarkusTestResource(value = KafkaCompanionResource.class, restrictToAnnotatedClass = true)
+public class TransferWholeAppliedTransactionTest extends AppliedTransactionServiceTest {
+	
+	@Test
+	public void applyTransferWholeSuccessBulk() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.BULK, entity);
+		ObjectId firstBlock = item.getStorageBlocks().getFirst();
+		ObjectId secondBlock = this.storageBlockService.add(
+			DEFAULT_TEST_DB_NAME,
+			StorageBlock.builder().label(FAKER.location().building()).build(),
+			entity
+		).getId();
+		item.getStorageBlocks().add(secondBlock);
+		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
+		
+		ObjectId initialStoredId = this.storedService.add(
+			DEFAULT_TEST_DB_NAME, AmountStored.builder()
+									  .item(item.getId())
+									  .storageBlock(firstBlock)
+									  .amount(Quantities.getQuantity(5, item.getUnit()))
+									  .build(),
+			entity
+		).getId();
+		
+		ItemStoredTransaction preApplyTransaction = TransferWholeTransaction.builder()
+														.fromBlock(firstBlock)
+														.toBlock(secondBlock)
+														.build();
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(1, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(5, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 1);
+		AmountStored firstStoredFromSearch = (AmountStored) storedSearchResult.getResults().get(0);
+		
+		{
+			AmountStored firstStored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().getFirst());
+			assertEquals(firstStoredFromSearch, firstStored);
+			assertEquals(Quantities.getQuantity(5, item.getUnit()), firstStored.getAmount());
+			
+			SearchResult<ObjectHistoryEvent>
+				storedHistory =
+				this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(firstStored.getId()));
+			assertFalse(storedHistory.isEmpty());
+			UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
+			assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+			assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+		}
+	}
+	
+	@Test
+	public void applyTransferWholeSuccessAmtList() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.AMOUNT_LIST, entity);
+		ObjectId firstBlock = item.getStorageBlocks().getFirst();
+		ObjectId secondBlock = this.storageBlockService.add(
+			DEFAULT_TEST_DB_NAME,
+			StorageBlock.builder().label(FAKER.location().building()).build(),
+			entity
+		).getId();
+		item.getStorageBlocks().add(secondBlock);
+		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
+		
+		ObjectId initialStoredId = this.storedService.add(
+			DEFAULT_TEST_DB_NAME, AmountStored.builder()
+									  .item(item.getId())
+									  .storageBlock(firstBlock)
+									  .amount(Quantities.getQuantity(5, item.getUnit()))
+									  .build(),
+			entity
+		).getId();
+		
+		ItemStoredTransaction preApplyTransaction = TransferWholeTransaction.builder()
+														.fromBlock(firstBlock)
+														.storedToTransfer(initialStoredId)
+														.toBlock(secondBlock)
+														.build();
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(1, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(5, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 1);
+		AmountStored firstStoredFromSearch = (AmountStored) storedSearchResult.getResults().get(0);
+		
+		{
+			AmountStored firstStored = (AmountStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().getFirst());
+			assertEquals(firstStoredFromSearch, firstStored);
+			assertEquals(Quantities.getQuantity(5, item.getUnit()), firstStored.getAmount());
+			
+			SearchResult<ObjectHistoryEvent>
+				storedHistory =
+				this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(firstStored.getId()));
+			assertFalse(storedHistory.isEmpty());
+			UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
+			assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+			assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+		}
+	}
+	
+	@Test
+	public void applyTransferWholeSuccessUniqueMulti() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.UNIQUE_MULTI, entity);
+		ObjectId firstBlock = item.getStorageBlocks().getFirst();
+		ObjectId secondBlock = this.storageBlockService.add(
+			DEFAULT_TEST_DB_NAME,
+			StorageBlock.builder().label(FAKER.location().building()).build(),
+			entity
+		).getId();
+		item.getStorageBlocks().add(secondBlock);
+		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
+		
+		ObjectId initialStoredId = this.storedService.add(
+			DEFAULT_TEST_DB_NAME, UniqueStored.builder()
+									  .item(item.getId())
+									  .storageBlock(firstBlock)
+									  .build(),
+			entity
+		).getId();
+		
+		ItemStoredTransaction preApplyTransaction = TransferWholeTransaction.builder()
+														.fromBlock(firstBlock)
+														.storedToTransfer(initialStoredId)
+														.toBlock(secondBlock)
+														.build();
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(1, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(1, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 1);
+		UniqueStored firstStoredFromSearch = (UniqueStored) storedSearchResult.getResults().get(0);
+		
+		{
+			UniqueStored firstStored = (UniqueStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().getFirst());
+			assertEquals(firstStoredFromSearch, firstStored);
+			
+			SearchResult<ObjectHistoryEvent>
+				storedHistory =
+				this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(firstStored.getId()));
+			assertFalse(storedHistory.isEmpty());
+			UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
+			assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+			assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+		}
+	}
+	
+	
+	@Test
+	public void applyTransferWholeSuccessUniqueSingle() throws Exception {
+		InteractingEntity entity = this.getTestUserService().getTestUser();
+		InventoryItem item = setupItem(StorageType.UNIQUE_SINGLE, entity);
+		ObjectId firstBlock = item.getStorageBlocks().getFirst();
+		ObjectId secondBlock = this.storageBlockService.add(
+			DEFAULT_TEST_DB_NAME,
+			StorageBlock.builder().label(FAKER.location().building()).build(),
+			entity
+		).getId();
+		item.getStorageBlocks().add(secondBlock);
+		this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, item, entity);
+		
+		ObjectId initialStoredId = this.storedService.add(
+			DEFAULT_TEST_DB_NAME, UniqueStored.builder()
+									  .item(item.getId())
+									  .storageBlock(firstBlock)
+									  .build(),
+			entity
+		).getId();
+		
+		ItemStoredTransaction preApplyTransaction = TransferWholeTransaction.builder()
+														.fromBlock(firstBlock)
+														.storedToTransfer(initialStoredId)
+														.toBlock(secondBlock)
+														.build();
+		
+		AppliedTransaction appliedTransaction = this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
+		
+		assertEquals(entity.getId(), appliedTransaction.getEntity());
+		assertEquals(item.getId(), appliedTransaction.getInventoryItem());
+		assertEquals(1, appliedTransaction.getAffectedStored().size());
+		assertEquals(preApplyTransaction, appliedTransaction.getTransaction());
+		assertTrue(appliedTransaction.getTimestamp().isBefore(ZonedDateTime.now()));
+		
+		assertEquals(1, appliedTransaction.getPostApplyResults().getStats().getNumStored());
+		assertEquals(Quantities.getQuantity(1, item.getUnit()), appliedTransaction.getPostApplyResults().getStats().getTotal());
+		//TODO:: storage block stats
+		
+		SearchResult<Stored> storedSearchResult = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInventoryItemId(item.getId()));
+		assertEquals(storedSearchResult.getNumResults(), 1);
+		UniqueStored firstStoredFromSearch = (UniqueStored) storedSearchResult.getResults().get(0);
+		
+		{
+			UniqueStored firstStored = (UniqueStored) this.storedService.get(DEFAULT_TEST_DB_NAME, appliedTransaction.getAffectedStored().getFirst());
+			assertEquals(firstStoredFromSearch, firstStored);
+			
+			SearchResult<ObjectHistoryEvent>
+				storedHistory =
+				this.storedService.getHistoryService().search(DEFAULT_TEST_DB_NAME, new HistorySearch().setObjectId(firstStored.getId()));
+			assertFalse(storedHistory.isEmpty());
+			UpdateEvent event = (UpdateEvent) storedHistory.getResults().getFirst();
+			assertTrue(event.getDetails().containsKey(ITEM_TRANSACTION.name()));
+			assertEquals(appliedTransaction.getId(), ((ItemTransactionDetail) event.getDetails().get(ITEM_TRANSACTION.name())).getInventoryItemTransaction());
+		}
+	}
+	
+	
+	//TODO:: any more?
+}

From 7d863fa1ba157ca95c442807ab8a80b831450101 Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Fri, 15 May 2026 13:38:06 -0400
Subject: [PATCH 09/48] Core - API - Added thread-based test for updating
 inventory items to ensure no deadlocking

---
 .../items/InventoryItemsCrudTest.java         | 173 ++++++++++++++++--
 1 file changed, 156 insertions(+), 17 deletions(-)

diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/InventoryItemsCrudTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/InventoryItemsCrudTest.java
index ac162a4d6..46e56e4fe 100644
--- a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/InventoryItemsCrudTest.java
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/InventoryItemsCrudTest.java
@@ -3,28 +3,53 @@
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.node.ObjectNode;
-import io.quarkus.test.common.QuarkusTestResource;
 import io.quarkus.test.common.http.TestHTTPEndpoint;
 import io.quarkus.test.junit.QuarkusTest;
 import io.restassured.http.ContentType;
 import io.restassured.response.ValidatableResponse;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.SneakyThrows;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.time.StopWatch;
 import org.bson.types.ObjectId;
 import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 import tech.ebp.oqm.core.api.model.object.interactingEntity.user.User;
 import tech.ebp.oqm.core.api.model.object.storage.items.InventoryItem;
 import tech.ebp.oqm.core.api.service.mongo.InventoryItemService;
+import tech.ebp.oqm.core.api.service.serviceState.InstanceMutexService;
+import tech.ebp.oqm.core.api.service.serviceState.InstanceMutexServiceTest;
 import tech.ebp.oqm.core.api.testResources.data.InventoryItemTestObjectCreator;
 import tech.ebp.oqm.core.api.testResources.data.TestUserService;
 import tech.ebp.oqm.core.api.testResources.testClasses.RunningServerTest;
 
 import jakarta.inject.Inject;
 
+import java.time.Duration;
+import java.time.LocalDateTime;
+import java.time.temporal.ChronoUnit;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
 import java.util.Map;
+import java.util.Optional;
+import java.util.SortedSet;
+import java.util.TreeSet;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Stream;
 
 import static io.restassured.RestAssured.given;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import static tech.ebp.oqm.core.api.testResources.TestConstants.DEFAULT_TEST_DB_NAME;
 import static tech.ebp.oqm.core.api.testResources.TestRestUtils.setupJwtCall;
 
@@ -59,27 +84,27 @@ public void testItemSearchId() throws JsonProcessingException {
 		String id = OBJECT_MAPPER.readValue(json, InventoryItem.class).getId().toHexString();
 		
 		String resultStr = setupJwtCall(given(), testUser.getAttributes().get(TestUserService.TEST_JWT_ATT_KEY))
-			.body(objectMapper.writeValueAsString(testObjectCreator.getTestObject()))
-			.contentType(ContentType.JSON)
-			.pathParam("oqmDbIdOrName", DEFAULT_TEST_DB_NAME)
-			.params(Map.of("id", id))
-			.get()
-			.then().statusCode(200)
-			.extract().body().asString();
-		
-		ObjectNode resultNode = (ObjectNode) OBJECT_MAPPER.readTree(resultStr);
-		
-		assertEquals(1, resultNode.get("numResults").asInt());
-		
-		resultStr = setupJwtCall(given(), testUser.getAttributes().get(TestUserService.TEST_JWT_ATT_KEY))
 							   .body(objectMapper.writeValueAsString(testObjectCreator.getTestObject()))
 							   .contentType(ContentType.JSON)
 							   .pathParam("oqmDbIdOrName", DEFAULT_TEST_DB_NAME)
-							   .params(Map.of("id", new ObjectId().toHexString()))
+							   .params(Map.of("id", id))
 							   .get()
 							   .then().statusCode(200)
 							   .extract().body().asString();
 		
+		ObjectNode resultNode = (ObjectNode) OBJECT_MAPPER.readTree(resultStr);
+		
+		assertEquals(1, resultNode.get("numResults").asInt());
+		
+		resultStr = setupJwtCall(given(), testUser.getAttributes().get(TestUserService.TEST_JWT_ATT_KEY))
+						.body(objectMapper.writeValueAsString(testObjectCreator.getTestObject()))
+						.contentType(ContentType.JSON)
+						.pathParam("oqmDbIdOrName", DEFAULT_TEST_DB_NAME)
+						.params(Map.of("id", new ObjectId().toHexString()))
+						.get()
+						.then().statusCode(200)
+						.extract().body().asString();
+		
 		resultNode = (ObjectNode) OBJECT_MAPPER.readTree(resultStr);
 		
 		assertEquals(0, resultNode.get("numResults").asInt());
@@ -126,7 +151,6 @@ public void testItemUpdatesUnit() throws JsonProcessingException {
 		//get again
 		response = setupJwtCall(given(), testUser.getAttributes().get(TestUserService.TEST_JWT_ATT_KEY))
 					   .when()
-					   .body(updates)
 					   .accept(ContentType.JSON)
 					   .pathParam("oqmDbIdOrName", DEFAULT_TEST_DB_NAME)
 					   .get(id)
@@ -140,5 +164,120 @@ public void testItemUpdatesUnit() throws JsonProcessingException {
 		assertEquals("mol", result.get("unit").get("string").asText());
 		assertEquals("mol", result.get("stats").get("total").get("unit").get("string").asText());
 	}
-
+	
+	public static Stream<Arguments> getParams() {
+		return Stream.of(
+			Arguments.of(2, 10),
+			Arguments.of(2, 10),
+			Arguments.of(3, 10),
+			Arguments.of(3, 10),
+			Arguments.of(5, 10),
+			Arguments.of(5, 10),
+			
+			Arguments.of(2, 20),
+			Arguments.of(2, 20),
+			Arguments.of(3, 20),
+			Arguments.of(3, 20),
+			Arguments.of(5, 20),
+			Arguments.of(5, 20),
+			
+			Arguments.of(10, 10),
+			Arguments.of(10, 10),
+			Arguments.of(20, 20),
+			Arguments.of(20, 20)
+		);
+	}
+	
+	@ParameterizedTest
+	@MethodSource("getParams")
+	public void basicThreadTest(int numThreads, int numIterations) throws InterruptedException, ExecutionException, JsonProcessingException {
+		User testUser = this.getTestUserService().getTestUser();
+		String json = setupJwtCall(given(), testUser.getAttributes().get(TestUserService.TEST_JWT_ATT_KEY))
+						  .body(objectMapper.writeValueAsString(testObjectCreator.getTestObject()))
+						  .contentType(ContentType.JSON)
+						  .pathParam("oqmDbIdOrName", DEFAULT_TEST_DB_NAME)
+						  .post()
+						  .then().statusCode(200)
+						  .extract().body().asString();
+		
+		log.info("Initial item: {}", json);
+		
+		String id = OBJECT_MAPPER.readValue(json, InventoryItem.class).getId().toHexString();
+		List<Future<Void>> futures = new ArrayList<>(numThreads);
+		ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
+		
+		
+		BasicItemUpdateTestThread.BasicItemUpdateTestThreadBuilder threadBuilder = BasicItemUpdateTestThread.builder()
+																					   .testUser(testUser)
+																					   .inventoryItemId(id)
+																					   .numIterations(numIterations);
+		
+		StopWatch overall = StopWatch.createStarted();
+		for (int i = 1; i <= numThreads; i++) {
+			threadBuilder.threadId("testThread-" + i);
+			
+			futures.add(executor.submit(threadBuilder.build()));
+		}
+		executor.shutdown();
+		while (!executor.awaitTermination(1, TimeUnit.MINUTES)) {
+			log.info("Still waiting on threads...");
+		}
+		overall.stop();
+		
+		
+		//TODO:: check results
+		ObjectNode result = setupJwtCall(given(), testUser.getAttributes().get(TestUserService.TEST_JWT_ATT_KEY))
+								.when()
+								.accept(ContentType.JSON)
+								.pathParam("oqmDbIdOrName", DEFAULT_TEST_DB_NAME)
+								.get(id)
+								.then()
+								.statusCode(200)
+								.extract().as(ObjectNode.class);
+		log.info("Got Result: {}", result);
+		
+	}
+	
+	
+	@Builder
+	@Slf4j
+	@AllArgsConstructor
+	static class BasicItemUpdateTestThread implements Callable<Void> {
+		
+		private String threadId;
+		private String inventoryItemId;
+		private User testUser;
+		
+		private int numIterations;
+		
+		@SneakyThrows
+		@Override
+		public Void call() {
+			log.info("Running test thread {}", this.threadId);
+			
+			ObjectNode updates = OBJECT_MAPPER.createObjectNode();
+			updates.putObject("attributes");
+			
+			for (int i = 1; i <= this.numIterations; i++) {
+				log.info("Thread {} waiting for lock on iteration {}", this.threadId, i);
+				
+				((ObjectNode) updates.get("attributes")).put(this.threadId, i);
+				
+				//initial update
+				ValidatableResponse response = setupJwtCall(given(), testUser.getAttributes().get(TestUserService.TEST_JWT_ATT_KEY))
+												   .when()
+												   .body(updates)
+												   .contentType(ContentType.JSON)
+												   .accept(ContentType.JSON)
+												   .pathParam("oqmDbIdOrName", DEFAULT_TEST_DB_NAME)
+												   .put(this.inventoryItemId)
+												   .then()
+												   .statusCode(200);
+				
+			}
+			log.info("DONE running test thread {}", this.threadId);
+			return null;
+		}
+	}
+	
 }
\ No newline at end of file

From 35710d5eafd7972851790130fb498fd2adc4a5f5 Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Fri, 15 May 2026 13:38:31 -0400
Subject: [PATCH 10/48] Core - API - Added todo/ reference to issue for later
 improvement

---
 .../ebp/oqm/core/api/model/object/AttKeywordMainObject.java    | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/AttKeywordMainObject.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/AttKeywordMainObject.java
index 932ccaeea..1d9879ce8 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/AttKeywordMainObject.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/AttKeywordMainObject.java
@@ -1,5 +1,7 @@
 package tech.ebp.oqm.core.api.model.object;
 
+import com.fasterxml.jackson.annotation.JsonMerge;
+import com.fasterxml.jackson.annotation.OptBoolean;
 import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.NotNull;
 import lombok.AllArgsConstructor;
@@ -39,6 +41,7 @@ public AttKeywordMainObject(ObjectId id, Map<@NotBlank @NotNull String, String>
 	 */
 	@NotNull
 	@NonNull
+//	@JsonMerge TODO:: #1261 figure out how to merge these; without, the whole map gets written on merge. With, partial updates are possible, but can't remove entries.
 	@lombok.Builder.Default
 	@Schema(required = false, description = "Attribute key/value (string) pairs to associate with the object.", examples = {"{}", "{\"key\": \"value\"}"})
 	private Map<@NotBlank @NotNull String, String> attributes = new HashMap<>();

From 16b7be4c1862e92822b2136aa841569a4ca2b7f0 Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Fri, 15 May 2026 16:13:07 -0400
Subject: [PATCH 11/48] Core - API - Incorporated db id in the mutex id of
 inventory items

---
 .../service/mongo/InventoryItemService.java    | 10 ++++++----
 .../api/service/mongo/MongoObjectService.java  |  4 ++--
 .../core/api/service/mongo/StoredService.java  |  4 +++-
 .../AppliedTransactionService.java             |  3 ++-
 .../serviceState/InstanceMutexService.java     | 18 +++++++++++++++---
 5 files changed, 28 insertions(+), 11 deletions(-)

diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/InventoryItemService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/InventoryItemService.java
index 1b7171e72..73e0692f0 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/InventoryItemService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/InventoryItemService.java
@@ -282,15 +282,17 @@ public InvItemCollectionStats getStats(String oqmDbIdOrName) {
 	}
 	
 	@Override
-	protected void handleAdd(InventoryItem object) {
-		super.handleAdd(object);
-		this.instanceMutexService.register(object);
+	protected void handleAdd(String oqmDbIdOrName, InventoryItem object) {
+		super.handleAdd(oqmDbIdOrName, object);
+		this.instanceMutexService.register(oqmDbIdOrName, object);
 	}
 	
 	@Override
 	public InventoryItem update(String oqmDbIdOrName, ClientSession cs, ObjectId id, ObjectNode updateJson, InteractingEntity interactingEntity, HistoryDetail ... details) {
 		try(
-			InstanceMutexService.InstanceMutexResource mutex = this.instanceMutexService.getResource(InstanceMutexService.getMutexIdFor(InventoryItem.class, id), Optional.empty());
+			InstanceMutexService.InstanceMutexResource mutex = this.instanceMutexService.getResource(this.instanceMutexService.getMutexIdFor(oqmDbIdOrName, InventoryItem.class,
+					id),
+																																										  Optional.empty());
 			){
 			return super.update(oqmDbIdOrName, cs, id, updateJson, interactingEntity, details);
 		} catch(IllegalStateException e){
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/MongoObjectService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/MongoObjectService.java
index deb3b1253..d69b674e9 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/MongoObjectService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/MongoObjectService.java
@@ -420,7 +420,7 @@ public T update(String oqmDbIdOrName, @Valid T object) throws DbNotFoundExceptio
 		return this.update(oqmDbIdOrName, null, object, false);
 	}
 	
-	protected void handleAdd(T object){
+	protected void handleAdd(String oqmDbIdOrName, T object){
 		//TODO:: nothing to do for default
 	}
 	
@@ -449,7 +449,7 @@ public T add(String oqmDbIdOrName, ClientSession session, @NonNull @Valid T obje
 		object.setId(result.getInsertedId().asObjectId().getValue());
 		
 		log.info("Added. Id: {}", object.getId());
-		this.handleAdd(object);
+		this.handleAdd(oqmDbIdOrName, object);
 		return object;
 	}
 	
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/StoredService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/StoredService.java
index 474d19637..e4e1b5662 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/StoredService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/StoredService.java
@@ -199,7 +199,9 @@ public Stored update(String oqmDbIdOrName, ClientSession cs, InventoryItem item,
 		HistoryDetail... details) {
 		
 		try(
-			InstanceMutexService.InstanceMutexResource mutex = this.instanceMutexService.getResource(InstanceMutexService.getMutexIdFor(InventoryItem.class, id), Optional.empty());
+			InstanceMutexService.InstanceMutexResource mutex = this.instanceMutexService.getResource(this.instanceMutexService.getMutexIdFor(oqmDbIdOrName, InventoryItem.class,
+					id),
+				Optional.empty());
 		){
 			return super.update(oqmDbIdOrName, cs, id, updateJson, interactingEntity, details);
 		} catch(InterruptedException e) {
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/AppliedTransactionService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/AppliedTransactionService.java
index 35148d648..17a0371bc 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/AppliedTransactionService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/AppliedTransactionService.java
@@ -94,7 +94,8 @@ public <T extends ItemStoredTransaction> AppliedTransaction apply(
 		HistoryDetail... details
 	) throws Exception {
 		try (
-			InstanceMutexService.InstanceMutexResource mutex = this.instanceMutexService.getResource(InstanceMutexService.getMutexIdFor(inventoryItem), Optional.empty());
+			InstanceMutexService.InstanceMutexResource mutex = this.instanceMutexService.getResource(this.instanceMutexService.getMutexIdFor(oqmDbIdOrName, inventoryItem),
+				Optional.empty());
 			MongoSessionWrapper csw = new MongoSessionWrapper(cs, this)
 		) {
 			return csw.runTransaction(()->{
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexService.java
index 938e17100..12bcec640 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexService.java
@@ -21,6 +21,7 @@
 import tech.ebp.oqm.core.api.model.object.MainObject;
 import tech.ebp.oqm.core.api.model.rest.search.InstanceMutexSearch;
 import tech.ebp.oqm.core.api.service.mongo.TopLevelMongoService;
+import tech.ebp.oqm.core.api.service.serviceState.db.OqmDatabaseService;
 
 import java.io.Closeable;
 import java.io.IOException;
@@ -63,7 +64,7 @@
 @Slf4j
 public class InstanceMutexService extends TopLevelMongoService<InstanceMutex, InstanceMutexSearch, CollectionStats> {
 	
-	public static <T extends MainObject> String getMutexIdFor(Class<?> clazz, ObjectId id) {
+	public static String getMutexIdFor(Class<?> clazz, ObjectId id) {
 		return clazz.getSimpleName() + "-" + id;
 	}
 	
@@ -77,6 +78,17 @@ public static <T extends MainObject> String getMutexIdFor(T object) {
 		return getMutexIdFor(object.getClass(), object.getId());
 	}
 	
+	public String getMutexIdFor(String oqmDbNameOrId, Class<?> clazz, ObjectId id) {
+		return this.databaseService.getOqmDatabase(oqmDbNameOrId).getDbId().toHexString() + "-" + getMutexIdFor(clazz, id);
+	}
+	
+	
+	public <T extends MainObject> String getMutexIdFor(String oqmDbIdOrName, T object) {
+		return this.getMutexIdFor(oqmDbIdOrName, object.getClass(), object.getId());
+	}
+	
+	@Inject
+	OqmDatabaseService databaseService;
 	
 	@Inject
 	@Getter(AccessLevel.PRIVATE)
@@ -146,8 +158,8 @@ public void register(String mutexId) {
 		}
 	}
 	
-	public void register(MainObject object) {
-		this.register(InstanceMutexService.getMutexIdFor(object));
+	public void register(String oqmDbIdOrName, MainObject object) {
+		this.register(this.getMutexIdFor(oqmDbIdOrName, object));
 	}
 	
 	/**

From 62415d37553bdd4874cb91b3401ede67f0724d00 Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Fri, 15 May 2026 17:54:01 -0400
Subject: [PATCH 12/48] Core - API - Added startup handler to ensure item
 mutexes are created

---
 .../oqm/core/api/scheduled/MongoDbInit.java   | 58 +++++++++++++++++++
 1 file changed, 58 insertions(+)
 create mode 100644 software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/scheduled/MongoDbInit.java

diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/scheduled/MongoDbInit.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/scheduled/MongoDbInit.java
new file mode 100644
index 000000000..56f9783fa
--- /dev/null
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/scheduled/MongoDbInit.java
@@ -0,0 +1,58 @@
+package tech.ebp.oqm.core.api.scheduled;
+
+import io.quarkus.runtime.StartupEvent;
+import jakarta.enterprise.event.Observes;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
+import lombok.extern.slf4j.Slf4j;
+import tech.ebp.oqm.core.api.service.mongo.InventoryItemService;
+import tech.ebp.oqm.core.api.service.serviceState.InstanceMutexService;
+import tech.ebp.oqm.core.api.service.serviceState.db.DbCacheEntry;
+import tech.ebp.oqm.core.api.service.serviceState.db.OqmDatabaseService;
+
+@Singleton
+@Slf4j
+public class MongoDbInit {
+
+	@Inject
+	InventoryItemService inventoryItemService;
+	
+	@Inject
+	OqmDatabaseService oqmDatabaseService;
+	
+	@Inject
+	InstanceMutexService instanceMutexService;
+	
+	
+	/**
+	 * This was introduced in version 4.4.8 ~ May 15, 2026
+	 *
+	 * It was intended to ensure that all inventory items created before an upgrade have a mutex registered for them.
+	 *
+	 * This can be removed once all inventory items have mutexes.
+	 */
+	private void ensureItemMutexesExist() {
+		log.info("Ensuring inventory item mutexes exist.");
+		
+		for(DbCacheEntry curDb : this.oqmDatabaseService.getDatabases()) {
+			log.info("Ensuring inventory item mutexes exist for database: {}", curDb.getDbName());
+			this.inventoryItemService.iterator(curDb.getDbId().toHexString()).forEachRemaining((item) -> {
+				this.instanceMutexService.register(
+					this.instanceMutexService.getMutexIdFor(curDb.getDbId().toHexString(), item)
+				);
+			});
+			log.info("DONE Ensuring inventory item mutexes exist for database: {}", curDb.getDbName());
+		}
+		
+		log.info("DONE Ensuring inventory item mutexes exist.");
+	}
+	
+	
+	void onStart(
+		@Observes
+		StartupEvent ev
+	) {
+		this.ensureItemMutexesExist();
+		
+	}
+}

From 8b3ddcb9fd97dab2333846d51d311d89afe63920 Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Fri, 15 May 2026 22:35:56 -0400
Subject: [PATCH 13/48] Core - API - Added a bunch of spans, slight change to
 make transaction appliers beans instead of pojos to allow for metrics and
 similar

---
 .../core/api/service/ItemStatsService.java    |  3 ++
 .../AppliedTransactionService.java            | 29 +++++++------------
 .../appliers/AddAmountTransactionApplier.java |  8 ++---
 .../appliers/AddWholeTransactionApplier.java  |  6 ++--
 .../CheckinFullTransactionApplier.java        |  7 ++---
 .../CheckinLossTransactionApplier.java        |  7 ++---
 .../CheckinOutTransactionApplier.java         |  9 ++----
 .../CheckinPartTransactionApplier.java        | 10 +++----
 .../CheckoutAmountTransactionApplier.java     |  6 ++--
 .../CheckoutWholeTransactionApplier.java      |  6 ++--
 .../appliers/SetAmountTransactionApplier.java |  6 ++--
 .../SubtractAmountTransactionApplier.java     |  6 ++--
 .../SubtractWholeTransactionApplier.java      |  6 ++--
 .../appliers/TransactionApplier.java          | 11 ++++---
 .../TransferAmountTransactionApplier.java     |  6 ++--
 .../TransferWholeTransactionApplier.java      |  6 ++--
 .../serviceState/InstanceMutexService.java    |  2 ++
 .../items/InventoryItemsCrudTest.java         | 13 ---------
 18 files changed, 52 insertions(+), 95 deletions(-)

diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/ItemStatsService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/ItemStatsService.java
index 348cf46db..a029bda85 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/ItemStatsService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/ItemStatsService.java
@@ -3,6 +3,7 @@
 import com.mongodb.client.ClientSession;
 import com.mongodb.client.FindIterable;
 import com.mongodb.client.MongoCursor;
+import io.opentelemetry.instrumentation.annotations.WithSpan;
 import jakarta.enterprise.context.ApplicationScoped;
 import jakarta.inject.Inject;
 import jakarta.validation.constraints.NotNull;
@@ -182,6 +183,7 @@ private void addToStats(InventoryItem item, ItemStoredStats itemStoredStats, Sto
 	
 	//</editor-fold>
 	
+	@WithSpan
 	public ItemStoredStats getItemStats(String oqmDbIdOrName, ClientSession cs, InventoryItem item) {
 		log.info("Getting stats for item: {}", item.getId());
 		
@@ -322,6 +324,7 @@ private Optional<StoredExpiryLowStockProcessResult> getStoredExpiryLowStockProce
 	 *
 	 * @return
 	 */
+	@WithSpan
 	public ItemPostTransactionProcessResults postTransactionProcess(
 		String oqmDbIdOrName,
 		ClientSession cs,
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/AppliedTransactionService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/AppliedTransactionService.java
index 17a0371bc..84aa51c5e 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/AppliedTransactionService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/AppliedTransactionService.java
@@ -1,6 +1,7 @@
 package tech.ebp.oqm.core.api.service.mongo.transactions;
 
 import com.mongodb.client.ClientSession;
+import io.quarkus.arc.All;
 import jakarta.annotation.PostConstruct;
 import jakarta.enterprise.context.ApplicationScoped;
 import jakarta.inject.Inject;
@@ -40,17 +41,15 @@
 @ApplicationScoped
 public class AppliedTransactionService extends MongoObjectService<AppliedTransaction, AppliedTransactionSearch, CollectionStats> {
 	
-	@Inject
-	StoredService storedService;
-	
 	@Inject
 	ItemStatsService itemStatsService;
 	
-	@Inject
-	ItemCheckoutService itemCheckoutService;
-	
 	@Getter
-	Map<TransactionType, TransactionApplier> appliers = new HashMap<>();
+	Map<TransactionType, TransactionApplier> applierTypeMap = new HashMap<>();
+	
+	@Inject
+	@All
+	List<TransactionApplier<?>> transactionAppliers;
 	
 	@Inject
 	InstanceMutexService instanceMutexService;
@@ -61,17 +60,9 @@ public AppliedTransactionService() {
 	
 	@PostConstruct
 	void setupAppliers() {
-		appliers.put(ADD_AMOUNT, new AddAmountTransactionApplier(this.storedService));
-		appliers.put(ADD_WHOLE, new AddWholeTransactionApplier(this.storedService));
-		appliers.put(CHECKIN_FULL, new CheckinFullTransactionApplier(this.storedService, this.itemCheckoutService));
-		appliers.put(CHECKIN_PART, new CheckinPartTransactionApplier(this.storedService, this.itemCheckoutService));
-		appliers.put(CHECKOUT_AMOUNT, new CheckoutAmountTransactionApplier(this.storedService, this.itemCheckoutService));
-		appliers.put(CHECKOUT_WHOLE, new CheckoutWholeTransactionApplier(this.storedService, this.itemCheckoutService));
-		appliers.put(SET_AMOUNT, new SetAmountTransactionApplier(this.storedService));
-		appliers.put(SUBTRACT_AMOUNT, new SubtractAmountTransactionApplier(this.storedService));
-		appliers.put(SUBTRACT_WHOLE, new SubtractWholeTransactionApplier(this.storedService));
-		appliers.put(TRANSFER_AMOUNT, new TransferAmountTransactionApplier(this.storedService));
-		appliers.put(TRANSFER_WHOLE, new TransferWholeTransactionApplier(this.storedService));
+		for (TransactionApplier<?> applier : this.transactionAppliers) {
+			this.applierTypeMap.put(applier.getTransactionType(), applier);
+		}
 	}
 	
 	/**
@@ -118,7 +109,7 @@ public <T extends ItemStoredTransaction> AppliedTransaction apply(
 				
 				
 				//noinspection rawtypes
-				TransactionApplier applier = this.getAppliers().get(itemStoredTransaction.getType());
+				TransactionApplier applier = this.getApplierTypeMap().get(itemStoredTransaction.getType());
 				if (applier == null) {
 					throw new IllegalArgumentException("Invalid or unsupported transaction type given.");
 				}
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/AddAmountTransactionApplier.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/AddAmountTransactionApplier.java
index c8e541733..e42cd2f0f 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/AddAmountTransactionApplier.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/AddAmountTransactionApplier.java
@@ -1,6 +1,7 @@
 package tech.ebp.oqm.core.api.service.mongo.transactions.appliers;
 
 import com.mongodb.client.ClientSession;
+import jakarta.enterprise.context.ApplicationScoped;
 import org.bson.types.ObjectId;
 import tech.ebp.oqm.core.api.model.object.history.details.HistoryDetail;
 import tech.ebp.oqm.core.api.model.object.interactingEntity.InteractingEntity;
@@ -19,12 +20,9 @@
  * Applier to handle AddAmountTransactions.
  *
  */
+@ApplicationScoped
 public class AddAmountTransactionApplier extends TransactionApplier<AddAmountTransaction> {
-
-	public AddAmountTransactionApplier(StoredService storedService) {
-		super(storedService);
-	}
-
+	
 	@Override
 	public TransactionType getTransactionType() {
 		return TransactionType.ADD_AMOUNT;
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/AddWholeTransactionApplier.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/AddWholeTransactionApplier.java
index d7d6554fd..c4e681a6c 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/AddWholeTransactionApplier.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/AddWholeTransactionApplier.java
@@ -1,6 +1,7 @@
 package tech.ebp.oqm.core.api.service.mongo.transactions.appliers;
 
 import com.mongodb.client.ClientSession;
+import jakarta.enterprise.context.ApplicationScoped;
 import org.bson.types.ObjectId;
 import tech.ebp.oqm.core.api.model.object.history.details.HistoryDetail;
 import tech.ebp.oqm.core.api.model.object.interactingEntity.InteractingEntity;
@@ -13,12 +14,9 @@
 
 import java.util.Set;
 
+@ApplicationScoped
 public class AddWholeTransactionApplier extends TransactionApplier<AddWholeTransaction> {
 
-	public AddWholeTransactionApplier(StoredService storedService) {
-		super(storedService);
-	}
-
 	@Override
 	public TransactionType getTransactionType() {
 		return TransactionType.ADD_WHOLE;
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckinFullTransactionApplier.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckinFullTransactionApplier.java
index 99f7e9925..1d0cf0101 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckinFullTransactionApplier.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckinFullTransactionApplier.java
@@ -1,6 +1,7 @@
 package tech.ebp.oqm.core.api.service.mongo.transactions.appliers;
 
 import com.mongodb.client.ClientSession;
+import jakarta.enterprise.context.ApplicationScoped;
 import org.bson.types.ObjectId;
 import tech.ebp.oqm.core.api.model.object.history.details.HistoryDetail;
 import tech.ebp.oqm.core.api.model.object.interactingEntity.InteractingEntity;
@@ -19,13 +20,9 @@
 
 import java.util.Set;
 
+@ApplicationScoped
 public class CheckinFullTransactionApplier extends CheckinOutTransactionApplier<CheckinFullTransaction> {
 
-
-	public CheckinFullTransactionApplier(StoredService storedService, ItemCheckoutService itemCheckoutService) {
-		super(storedService, itemCheckoutService);
-	}
-
 	@Override
 	public TransactionType getTransactionType() {
 		return TransactionType.CHECKIN_FULL;
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckinLossTransactionApplier.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckinLossTransactionApplier.java
index 09cafc655..878fb6e66 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckinLossTransactionApplier.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckinLossTransactionApplier.java
@@ -1,6 +1,7 @@
 package tech.ebp.oqm.core.api.service.mongo.transactions.appliers;
 
 import com.mongodb.client.ClientSession;
+import jakarta.enterprise.context.ApplicationScoped;
 import org.apache.commons.lang3.NotImplementedException;
 import org.bson.types.ObjectId;
 import tech.ebp.oqm.core.api.model.object.history.details.HistoryDetail;
@@ -15,13 +16,9 @@
 
 import java.util.Set;
 
+@ApplicationScoped
 public class CheckinLossTransactionApplier extends CheckinOutTransactionApplier<CheckinLossTransaction> {
 
-
-	public CheckinLossTransactionApplier(StoredService storedService, ItemCheckoutService itemCheckoutService) {
-		super(storedService, itemCheckoutService);
-	}
-
 	@Override
 	public TransactionType getTransactionType() {
 		return TransactionType.CHECKIN_LOSS;
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckinOutTransactionApplier.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckinOutTransactionApplier.java
index c7a251737..c182bfb4f 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckinOutTransactionApplier.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckinOutTransactionApplier.java
@@ -1,6 +1,7 @@
 package tech.ebp.oqm.core.api.service.mongo.transactions.appliers;
 
 import com.mongodb.client.ClientSession;
+import jakarta.inject.Inject;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 import tech.ebp.oqm.core.api.model.object.history.details.HistoryDetail;
@@ -20,11 +21,7 @@
  */
 public abstract class CheckinOutTransactionApplier<T extends ItemStoredTransaction> extends TransactionApplier<T> {
 
+	@Inject
 	@Getter
-	private ItemCheckoutService itemCheckoutService;
-
-	public CheckinOutTransactionApplier(StoredService storedService, ItemCheckoutService itemCheckoutService) {
-		super(storedService);
-		this.itemCheckoutService = itemCheckoutService;
-	}
+	ItemCheckoutService itemCheckoutService;
 }
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckinPartTransactionApplier.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckinPartTransactionApplier.java
index e534a7888..c20d2fa77 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckinPartTransactionApplier.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckinPartTransactionApplier.java
@@ -1,6 +1,7 @@
 package tech.ebp.oqm.core.api.service.mongo.transactions.appliers;
 
 import com.mongodb.client.ClientSession;
+import jakarta.enterprise.context.ApplicationScoped;
 import org.apache.commons.lang3.NotImplementedException;
 import org.bson.types.ObjectId;
 import tech.ebp.oqm.core.api.model.object.history.details.HistoryDetail;
@@ -14,16 +15,13 @@
 
 import java.util.Set;
 
+@ApplicationScoped
 public class CheckinPartTransactionApplier extends CheckinOutTransactionApplier<CheckinPartTransaction> {
-
-
-	public CheckinPartTransactionApplier(StoredService storedService, ItemCheckoutService itemCheckoutService) {
-		super(storedService, itemCheckoutService);
-	}
+	
 
 	@Override
 	public TransactionType getTransactionType() {
-		return TransactionType.CHECKIN_FULL;
+		return TransactionType.CHECKIN_PART;
 	}
 
 	@Override
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckoutAmountTransactionApplier.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckoutAmountTransactionApplier.java
index b7c458c6b..35f11b5bd 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckoutAmountTransactionApplier.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckoutAmountTransactionApplier.java
@@ -1,6 +1,7 @@
 package tech.ebp.oqm.core.api.service.mongo.transactions.appliers;
 
 import com.mongodb.client.ClientSession;
+import jakarta.enterprise.context.ApplicationScoped;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.NotImplementedException;
 import org.bson.types.ObjectId;
@@ -22,12 +23,9 @@
 import java.util.Set;
 
 @Slf4j
+@ApplicationScoped
 public class CheckoutAmountTransactionApplier extends CheckinOutTransactionApplier<CheckoutAmountTransaction> {
 	
-	public CheckoutAmountTransactionApplier(StoredService storedService, ItemCheckoutService itemCheckoutService) {
-		super(storedService, itemCheckoutService);
-	}
-	
 	@Override
 	public TransactionType getTransactionType() {
 		return TransactionType.CHECKOUT_AMOUNT;
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckoutWholeTransactionApplier.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckoutWholeTransactionApplier.java
index cf6d29e51..3ba878b7c 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckoutWholeTransactionApplier.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckoutWholeTransactionApplier.java
@@ -1,6 +1,7 @@
 package tech.ebp.oqm.core.api.service.mongo.transactions.appliers;
 
 import com.mongodb.client.ClientSession;
+import jakarta.enterprise.context.ApplicationScoped;
 import org.bson.types.ObjectId;
 import tech.ebp.oqm.core.api.model.object.history.details.HistoryDetail;
 import tech.ebp.oqm.core.api.model.object.interactingEntity.InteractingEntity;
@@ -19,12 +20,9 @@
 import java.util.LinkedHashSet;
 import java.util.Set;
 
+@ApplicationScoped
 public class CheckoutWholeTransactionApplier extends CheckinOutTransactionApplier<CheckoutWholeTransaction> {
 	
-	public CheckoutWholeTransactionApplier(StoredService storedService, ItemCheckoutService itemCheckoutService) {
-		super(storedService, itemCheckoutService);
-	}
-	
 	@Override
 	public TransactionType getTransactionType() {
 		return TransactionType.CHECKOUT_WHOLE;
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/SetAmountTransactionApplier.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/SetAmountTransactionApplier.java
index 71be667db..3f1f2b898 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/SetAmountTransactionApplier.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/SetAmountTransactionApplier.java
@@ -1,6 +1,7 @@
 package tech.ebp.oqm.core.api.service.mongo.transactions.appliers;
 
 import com.mongodb.client.ClientSession;
+import jakarta.enterprise.context.ApplicationScoped;
 import org.bson.types.ObjectId;
 import tech.ebp.oqm.core.api.model.object.history.details.HistoryDetail;
 import tech.ebp.oqm.core.api.model.object.interactingEntity.InteractingEntity;
@@ -15,12 +16,9 @@
 
 import java.util.Set;
 
+@ApplicationScoped
 public class SetAmountTransactionApplier extends TransactionApplier<SetAmountTransaction> {
 
-	public SetAmountTransactionApplier(StoredService storedService) {
-		super(storedService);
-	}
-
 	@Override
 	public TransactionType getTransactionType() {
 		return TransactionType.SET_AMOUNT;
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/SubtractAmountTransactionApplier.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/SubtractAmountTransactionApplier.java
index fe0bef6b9..3de5b5d35 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/SubtractAmountTransactionApplier.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/SubtractAmountTransactionApplier.java
@@ -1,6 +1,7 @@
 package tech.ebp.oqm.core.api.service.mongo.transactions.appliers;
 
 import com.mongodb.client.ClientSession;
+import jakarta.enterprise.context.ApplicationScoped;
 import org.bson.types.ObjectId;
 import tech.ebp.oqm.core.api.model.object.history.details.HistoryDetail;
 import tech.ebp.oqm.core.api.model.object.interactingEntity.InteractingEntity;
@@ -14,12 +15,9 @@
 import javax.measure.Quantity;
 import java.util.Set;
 
+@ApplicationScoped
 public class SubtractAmountTransactionApplier extends TransactionApplier<SubAmountTransaction> {
 
-	public SubtractAmountTransactionApplier(StoredService storedService) {
-		super(storedService);
-	}
-
 	@Override
 	public TransactionType getTransactionType() {
 		return TransactionType.SUBTRACT_AMOUNT;
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/SubtractWholeTransactionApplier.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/SubtractWholeTransactionApplier.java
index d73a7b5f4..9eb22302d 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/SubtractWholeTransactionApplier.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/SubtractWholeTransactionApplier.java
@@ -1,6 +1,7 @@
 package tech.ebp.oqm.core.api.service.mongo.transactions.appliers;
 
 import com.mongodb.client.ClientSession;
+import jakarta.enterprise.context.ApplicationScoped;
 import org.bson.types.ObjectId;
 import tech.ebp.oqm.core.api.model.object.history.details.HistoryDetail;
 import tech.ebp.oqm.core.api.model.object.interactingEntity.InteractingEntity;
@@ -15,12 +16,9 @@
 import java.util.LinkedHashSet;
 import java.util.Set;
 
+@ApplicationScoped
 public class SubtractWholeTransactionApplier extends TransactionApplier<SubWholeTransaction> {
 
-	public SubtractWholeTransactionApplier(StoredService storedService) {
-		super(storedService);
-	}
-
 	@Override
 	public TransactionType getTransactionType() {
 		return TransactionType.SUBTRACT_WHOLE;
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/TransactionApplier.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/TransactionApplier.java
index 1330946f9..caf72a598 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/TransactionApplier.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/TransactionApplier.java
@@ -1,6 +1,8 @@
 package tech.ebp.oqm.core.api.service.mongo.transactions.appliers;
 
 import com.mongodb.client.ClientSession;
+import io.opentelemetry.instrumentation.annotations.WithSpan;
+import jakarta.inject.Inject;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 import org.bson.types.ObjectId;
@@ -18,14 +20,15 @@
  * Abstract applier of transactions.
  * @param <T> The type of transaction being applied.
  */
-@AllArgsConstructor
 public abstract class TransactionApplier<T extends ItemStoredTransaction> {
-
+	
+	@Inject
 	@Getter
-	private StoredService storedService;
+	StoredService storedService;
 
 	public abstract TransactionType getTransactionType();
-
+	
+	@WithSpan
 	public abstract void apply(
 		String oqmDbIdOrName,
 		InventoryItem inventoryItem,
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/TransferAmountTransactionApplier.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/TransferAmountTransactionApplier.java
index a7f7a0707..0200f6e50 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/TransferAmountTransactionApplier.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/TransferAmountTransactionApplier.java
@@ -1,6 +1,7 @@
 package tech.ebp.oqm.core.api.service.mongo.transactions.appliers;
 
 import com.mongodb.client.ClientSession;
+import jakarta.enterprise.context.ApplicationScoped;
 import org.bson.types.ObjectId;
 import tech.ebp.oqm.core.api.model.object.history.details.HistoryDetail;
 import tech.ebp.oqm.core.api.model.object.interactingEntity.InteractingEntity;
@@ -16,12 +17,9 @@
 import javax.measure.Quantity;
 import java.util.Set;
 
+@ApplicationScoped
 public class TransferAmountTransactionApplier extends TransactionApplier<TransferAmountTransaction> {
 	
-	public TransferAmountTransactionApplier(StoredService storedService) {
-		super(storedService);
-	}
-	
 	@Override
 	public TransactionType getTransactionType() {
 		return TransactionType.TRANSFER_AMOUNT;
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/TransferWholeTransactionApplier.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/TransferWholeTransactionApplier.java
index 9808483db..7df795978 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/TransferWholeTransactionApplier.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/TransferWholeTransactionApplier.java
@@ -1,6 +1,7 @@
 package tech.ebp.oqm.core.api.service.mongo.transactions.appliers;
 
 import com.mongodb.client.ClientSession;
+import jakarta.enterprise.context.ApplicationScoped;
 import org.bson.types.ObjectId;
 import tech.ebp.oqm.core.api.model.object.history.details.HistoryDetail;
 import tech.ebp.oqm.core.api.model.object.interactingEntity.InteractingEntity;
@@ -12,12 +13,9 @@
 
 import java.util.Set;
 
+@ApplicationScoped
 public class TransferWholeTransactionApplier extends TransactionApplier<TransferWholeTransaction> {
 
-	public TransferWholeTransactionApplier(StoredService storedService) {
-		super(storedService);
-	}
-
 	@Override
 	public TransactionType getTransactionType() {
 		return TransactionType.TRANSFER_WHOLE;
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexService.java
index 12bcec640..d6a975668 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexService.java
@@ -2,6 +2,7 @@
 
 import com.mongodb.client.model.*;
 import com.mongodb.client.result.UpdateResult;
+import io.opentelemetry.instrumentation.annotations.WithSpan;
 import jakarta.enterprise.context.ApplicationScoped;
 import jakarta.inject.Inject;
 import jakarta.validation.constraints.NotBlank;
@@ -244,6 +245,7 @@ public boolean lock(@NonNull String mutexId) {
 	 * @throws MutexWaitTimeoutException If the lock is not acquired within the timeout period.
 	 * @throws InterruptedException If the thread is interrupted while waiting for the lock.
 	 */
+	@WithSpan
 	public void awaitLock(@NonNull String mutexId, Optional<String> additionalIdentity) throws MutexWaitTimeoutException, InterruptedException {
 		Duration toWait = this.getMutexConfig().await().timeout();
 		LocalDateTime expires = LocalDateTime.now().plus(toWait);
diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/InventoryItemsCrudTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/InventoryItemsCrudTest.java
index 46e56e4fe..930f17a22 100644
--- a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/InventoryItemsCrudTest.java
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/InventoryItemsCrudTest.java
@@ -171,19 +171,6 @@ public static Stream<Arguments> getParams() {
 			Arguments.of(2, 10),
 			Arguments.of(3, 10),
 			Arguments.of(3, 10),
-			Arguments.of(5, 10),
-			Arguments.of(5, 10),
-			
-			Arguments.of(2, 20),
-			Arguments.of(2, 20),
-			Arguments.of(3, 20),
-			Arguments.of(3, 20),
-			Arguments.of(5, 20),
-			Arguments.of(5, 20),
-			
-			Arguments.of(10, 10),
-			Arguments.of(10, 10),
-			Arguments.of(20, 20),
 			Arguments.of(20, 20)
 		);
 	}

From e66734b2521ed28c934a1b9f2427d975cc9ee8ac Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Fri, 15 May 2026 23:15:24 -0400
Subject: [PATCH 14/48] Core - API - Optimizing threaded testing to reduce
 required testing time

---
 .../items/InventoryItemsCrudTest.java         |  3 --
 ...eratedIdentifierGenerationServiceTest.java | 33 ++++++++++---------
 .../InstanceMutexServiceTest.java             | 32 +++++++++---------
 3 files changed, 34 insertions(+), 34 deletions(-)

diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/InventoryItemsCrudTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/InventoryItemsCrudTest.java
index 930f17a22..31f53f425 100644
--- a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/InventoryItemsCrudTest.java
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/InventoryItemsCrudTest.java
@@ -168,9 +168,6 @@ public void testItemUpdatesUnit() throws JsonProcessingException {
 	public static Stream<Arguments> getParams() {
 		return Stream.of(
 			Arguments.of(2, 10),
-			Arguments.of(2, 10),
-			Arguments.of(3, 10),
-			Arguments.of(3, 10),
 			Arguments.of(20, 20)
 		);
 	}
diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/GeneratedIdentifierGenerationServiceTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/GeneratedIdentifierGenerationServiceTest.java
index 33dfec7dd..430360b83 100644
--- a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/GeneratedIdentifierGenerationServiceTest.java
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/GeneratedIdentifierGenerationServiceTest.java
@@ -244,21 +244,24 @@ public void incrementTest() {
 	public static Stream<Arguments> getThreadTestParams() {
 		List<Arguments> output = new ArrayList<>();
 		
-		for (int curNumThreads : List.of(2, 5, 10, 20)) {
-			for (int curNumIterations : List.of(10, 20)) {
-				for (int curNumPerIteration : List.of(1, 2, 5, 10, 20)) {
-					output.add(Arguments.of("{rand}", curNumThreads, curNumIterations, curNumPerIteration));
-				}
-			}
-		}
-		
-		for (int curNumThreads : List.of(2, 10)) {
-			for (int curNumIterations : List.of(10)) {
-				for (int curNumPerIteration : List.of(1, 2, 5, 10, 20)) {
-					output.add(Arguments.of("{inc}", curNumThreads, curNumIterations, curNumPerIteration));
-				}
-			}
-		}
+		output.add(Arguments.of("{inc}", 2, 10, 5));
+		output.add(Arguments.of("{inc}", 10, 10, 20));
+		
+//		for (int curNumThreads : List.of(2, 5, 10, 20)) {
+//			for (int curNumIterations : List.of(10, 20)) {
+//				for (int curNumPerIteration : List.of(1, 2, 5, 10, 20)) {
+//					output.add(Arguments.of("{rand}", curNumThreads, curNumIterations, curNumPerIteration));
+//				}
+//			}
+//		}
+		
+//		for (int curNumThreads : List.of(2, 10)) {
+//			for (int curNumIterations : List.of(10)) {
+//				for (int curNumPerIteration : List.of(1, 2, 5, 10, 20)) {
+//					output.add(Arguments.of("{inc}", curNumThreads, curNumIterations, curNumPerIteration));
+//				}
+//			}
+//		}
 		
 		return output.stream();
 	}
diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexServiceTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexServiceTest.java
index 5c0ae6632..ea3877463 100644
--- a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexServiceTest.java
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexServiceTest.java
@@ -30,22 +30,22 @@ public class InstanceMutexServiceTest extends RunningServerTest {
 	public static Stream<Arguments> getParams() {
 		return Stream.of(
 			Arguments.of(false, 2, 10, Duration.of(250, ChronoUnit.MILLIS)),
-			Arguments.of(true, 2, 10, Duration.of(250, ChronoUnit.MILLIS)),
-			Arguments.of(false, 3, 10, Duration.of(250, ChronoUnit.MILLIS)),
-			Arguments.of(true, 3, 10, Duration.of(250, ChronoUnit.MILLIS)),
-			Arguments.of(false, 5, 10, Duration.of(250, ChronoUnit.MILLIS)),
-			Arguments.of(true, 5, 10, Duration.of(250, ChronoUnit.MILLIS)),
-			
-			Arguments.of(false, 2, 20, Duration.of(250, ChronoUnit.MILLIS)),
-			Arguments.of(true, 2, 20, Duration.of(250, ChronoUnit.MILLIS)),
-			Arguments.of(false, 3, 20, Duration.of(250, ChronoUnit.MILLIS)),
-			Arguments.of(true, 3, 20, Duration.of(250, ChronoUnit.MILLIS)),
-			Arguments.of(false, 5, 20, Duration.of(250, ChronoUnit.MILLIS)),
-			Arguments.of(true, 5, 20, Duration.of(250, ChronoUnit.MILLIS)),
-			
-			Arguments.of(false, 10, 10, Duration.of(250, ChronoUnit.MILLIS)),
-			Arguments.of(true, 10, 10, Duration.of(250, ChronoUnit.MILLIS)),
-			Arguments.of(false, 20, 20, Duration.of(150, ChronoUnit.MILLIS)),
+//			Arguments.of(true, 2, 10, Duration.of(250, ChronoUnit.MILLIS)),
+//			Arguments.of(false, 3, 10, Duration.of(250, ChronoUnit.MILLIS)),
+//			Arguments.of(true, 3, 10, Duration.of(250, ChronoUnit.MILLIS)),
+//			Arguments.of(false, 5, 10, Duration.of(250, ChronoUnit.MILLIS)),
+//			Arguments.of(true, 5, 10, Duration.of(250, ChronoUnit.MILLIS)),
+//
+//			Arguments.of(false, 2, 20, Duration.of(250, ChronoUnit.MILLIS)),
+//			Arguments.of(true, 2, 20, Duration.of(250, ChronoUnit.MILLIS)),
+//			Arguments.of(false, 3, 20, Duration.of(250, ChronoUnit.MILLIS)),
+//			Arguments.of(true, 3, 20, Duration.of(250, ChronoUnit.MILLIS)),
+//			Arguments.of(false, 5, 20, Duration.of(250, ChronoUnit.MILLIS)),
+//			Arguments.of(true, 5, 20, Duration.of(250, ChronoUnit.MILLIS)),
+//
+//			Arguments.of(false, 10, 10, Duration.of(250, ChronoUnit.MILLIS)),
+//			Arguments.of(true, 10, 10, Duration.of(250, ChronoUnit.MILLIS)),
+//			Arguments.of(false, 20, 20, Duration.of(150, ChronoUnit.MILLIS)),
 			Arguments.of(true, 20, 20, Duration.of(150, ChronoUnit.MILLIS))
 		);
 	}

From 7ca4c8124902971533ba9e57ef15de9aed54de1a Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Sat, 16 May 2026 12:16:21 -0400
Subject: [PATCH 15/48] Core - API - Changes from review, added more custom
 exceptions for mutex issues

---
 .../mutex/MutexNotRegisteredException.java    | 12 +++++++
 .../mutex/MutexWaitInterruptedException.java  | 12 +++++++
 .../MutexWaitTimeoutException.java            |  3 +-
 .../service/mongo/InventoryItemService.java   |  4 ---
 .../core/api/service/mongo/StoredService.java |  4 +--
 .../serviceState/InstanceMutexService.java    | 32 +++++++++++--------
 .../items/InventoryItemsCrudTest.java         |  3 ++
 .../InstanceMutexServiceTest.java             |  3 +-
 8 files changed, 49 insertions(+), 24 deletions(-)
 create mode 100644 software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/exception/mutex/MutexNotRegisteredException.java
 create mode 100644 software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/exception/mutex/MutexWaitInterruptedException.java
 rename software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/exception/{ => mutex}/MutexWaitTimeoutException.java (70%)

diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/exception/mutex/MutexNotRegisteredException.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/exception/mutex/MutexNotRegisteredException.java
new file mode 100644
index 000000000..c2a755578
--- /dev/null
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/exception/mutex/MutexNotRegisteredException.java
@@ -0,0 +1,12 @@
+package tech.ebp.oqm.core.api.exception.mutex;
+
+/**
+ * Exception to use when a wait for a mutex lock has timed out.
+ *
+ * TODO:: add mutex specific data
+ */
+public class MutexNotRegisteredException extends IllegalStateException {
+	public MutexNotRegisteredException(String mutexId) {
+		super("Mutex with id " + mutexId + " was not registered when lock attempt made.");
+	}
+}
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/exception/mutex/MutexWaitInterruptedException.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/exception/mutex/MutexWaitInterruptedException.java
new file mode 100644
index 000000000..d27bf66eb
--- /dev/null
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/exception/mutex/MutexWaitInterruptedException.java
@@ -0,0 +1,12 @@
+package tech.ebp.oqm.core.api.exception.mutex;
+
+/**
+ * Exception to use when a wait for a mutex lock has timed out.
+ *
+ * TODO:: add mutex specific data
+ */
+public class MutexWaitInterruptedException extends IllegalStateException {
+	public MutexWaitInterruptedException(InterruptedException e) {
+		super("Mutex wait interrupted.", e);
+	}
+}
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/exception/MutexWaitTimeoutException.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/exception/mutex/MutexWaitTimeoutException.java
similarity index 70%
rename from software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/exception/MutexWaitTimeoutException.java
rename to software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/exception/mutex/MutexWaitTimeoutException.java
index 5987a79c2..a7757f893 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/exception/MutexWaitTimeoutException.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/exception/mutex/MutexWaitTimeoutException.java
@@ -1,4 +1,4 @@
-package tech.ebp.oqm.core.api.exception;
+package tech.ebp.oqm.core.api.exception.mutex;
 
 /**
  * Exception to use when a wait for a mutex lock has timed out.
@@ -7,6 +7,7 @@
  */
 public class MutexWaitTimeoutException extends IllegalStateException {
 	public MutexWaitTimeoutException() {
+		super("Mutex wait timed out. Could not acquire lock before timeout.");
 	}
 
 	public MutexWaitTimeoutException(String s) {
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/InventoryItemService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/InventoryItemService.java
index 73e0692f0..937bfbbe2 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/InventoryItemService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/InventoryItemService.java
@@ -295,10 +295,6 @@ public InventoryItem update(String oqmDbIdOrName, ClientSession cs, ObjectId id,
 																																										  Optional.empty());
 			){
 			return super.update(oqmDbIdOrName, cs, id, updateJson, interactingEntity, details);
-		} catch(IllegalStateException e){
-			throw new DbNotFoundException(InventoryItem.class, id);
-		} catch(InterruptedException e) {
-			throw new RuntimeException("Failed to acquire mutex for item (interrupted wait)" + id.toHexString(), e);
 		}
 	}
 	
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/StoredService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/StoredService.java
index e4e1b5662..1fd16fbb1 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/StoredService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/StoredService.java
@@ -200,12 +200,10 @@ public Stored update(String oqmDbIdOrName, ClientSession cs, InventoryItem item,
 		
 		try(
 			InstanceMutexService.InstanceMutexResource mutex = this.instanceMutexService.getResource(this.instanceMutexService.getMutexIdFor(oqmDbIdOrName, InventoryItem.class,
-					id),
+					item.getId()),
 				Optional.empty());
 		){
 			return super.update(oqmDbIdOrName, cs, id, updateJson, interactingEntity, details);
-		} catch(InterruptedException e) {
-			throw new RuntimeException("Failed to get lock for item; interrupted.", e);
 		}
 	}
 	
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexService.java
index d6a975668..1d7ec17cb 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexService.java
@@ -16,7 +16,9 @@
 import org.bson.conversions.Bson;
 import org.bson.types.ObjectId;
 import tech.ebp.oqm.core.api.config.MutexConfig;
-import tech.ebp.oqm.core.api.exception.MutexWaitTimeoutException;
+import tech.ebp.oqm.core.api.exception.mutex.MutexNotRegisteredException;
+import tech.ebp.oqm.core.api.exception.mutex.MutexWaitInterruptedException;
+import tech.ebp.oqm.core.api.exception.mutex.MutexWaitTimeoutException;
 import tech.ebp.oqm.core.api.model.InstanceMutex;
 import tech.ebp.oqm.core.api.model.collectionStats.CollectionStats;
 import tech.ebp.oqm.core.api.model.object.MainObject;
@@ -25,7 +27,6 @@
 import tech.ebp.oqm.core.api.service.serviceState.db.OqmDatabaseService;
 
 import java.io.Closeable;
-import java.io.IOException;
 import java.time.Duration;
 import java.time.LocalDateTime;
 import java.time.ZonedDateTime;
@@ -175,7 +176,7 @@ public void register(String oqmDbIdOrName, MainObject object) {
 	 *
 	 * @return true when reserved, false when not.
 	 */
-	public boolean lock(@NonNull String mutexId, Optional<String> additionalIdentity) {
+	public boolean lock(@NonNull String mutexId, Optional<String> additionalIdentity) throws MutexNotRegisteredException {
 		String identity = this.getIdentity(additionalIdentity);
 		Bson mutexIdEquals = eq("mutexId", mutexId);
 		
@@ -212,7 +213,7 @@ public boolean lock(@NonNull String mutexId, Optional<String> additionalIdentity
 			log.trace("Locked mutex: {}", lockedMutex);
 			
 			if (lockedMutex == null) {
-				throw new IllegalStateException("Mutex was not registered before usage: " + mutexId);
+				throw new MutexNotRegisteredException(mutexId);
 			} else if (lockedMutex.getTakenAt() != null && ZonedDateTime.now().isAfter(lockedMutex.getTakenAt().plus(this.getMutexConfig().lockExpireDuration()))) {
 				this.getTypedCollection().findOneAndUpdate(mutexIdEquals, Updates.set("taken", false));
 				log.warn("Unlocked mutex that appeared deadlocked: {}", mutexId);
@@ -243,10 +244,11 @@ public boolean lock(@NonNull String mutexId) {
 	 * @param mutexId The id of the mutex to get the lock for
 	 * @param additionalIdentity If an additional identity is required. Only use if need the mutex to offer concurrency within the same instance of the app.
 	 * @throws MutexWaitTimeoutException If the lock is not acquired within the timeout period.
-	 * @throws InterruptedException If the thread is interrupted while waiting for the lock.
+	 * @throws MutexWaitInterruptedException If the thread is interrupted while waiting for the lock.
+	 * @throws MutexNotRegisteredException If the mutex is not registered before usage.
 	 */
 	@WithSpan
-	public void awaitLock(@NonNull String mutexId, Optional<String> additionalIdentity) throws MutexWaitTimeoutException, InterruptedException {
+	public void awaitLock(@NonNull String mutexId, Optional<String> additionalIdentity) throws MutexWaitTimeoutException, MutexWaitInterruptedException, MutexNotRegisteredException {
 		Duration toWait = this.getMutexConfig().await().timeout();
 		LocalDateTime expires = LocalDateTime.now().plus(toWait);
 		long maitTimeMin = this.getMutexConfig().await().loopPauseMin().toMillis();
@@ -264,9 +266,13 @@ public void awaitLock(@NonNull String mutexId, Optional<String> additionalIdenti
 				return;
 			}
 			
-			Thread.sleep(
-				random.nextLong(maitTimeMin, maitTimeMax)
-			);
+			try {
+				long sleepTime = random.nextLong(maitTimeMin, maitTimeMax);
+				log.trace("Mutex was previously locked. Sleeping for {} ms. ", sleepTime);
+				Thread.sleep(sleepTime);
+			} catch(InterruptedException e) {
+				throw new MutexWaitInterruptedException(e);
+			}
 		} while (LocalDateTime.now().isBefore(expires));
 		throw new MutexWaitTimeoutException();
 	}
@@ -328,7 +334,7 @@ public int getCurrentSchemaVersion() {
 	 * @throws MutexWaitTimeoutException If set to start locked and the lock is not acquired within the timeout period.
 	 * @throws InterruptedException If the thread is interrupted while waiting for the lock.
 	 */
-	public InstanceMutexResource getResource(boolean startLocked, String mutexId, Optional<String> additionalId) throws MutexWaitTimeoutException, InterruptedException {
+	public InstanceMutexResource getResource(boolean startLocked, String mutexId, Optional<String> additionalId) throws MutexWaitTimeoutException {
 		InstanceMutexResource resource = InstanceMutexResource.builder()
 											 .mutexService(this)
 											 .mutexId(mutexId)
@@ -349,9 +355,8 @@ public InstanceMutexResource getResource(boolean startLocked, String mutexId, Op
 	 *
 	 * @return The resource to use in a try-with-resources block.
 	 * @throws MutexWaitTimeoutException If the lock is not acquired within the timeout period.
-	 * @throws InterruptedException If the thread is interrupted while waiting for the lock.
 	 */
-	public InstanceMutexResource getResource(String mutexId, Optional<String> additionalId) throws MutexWaitTimeoutException, InterruptedException {
+	public InstanceMutexResource getResource(String mutexId, Optional<String> additionalId) throws MutexWaitTimeoutException {
 		return this.getResource(true, mutexId, additionalId);
 	}
 	
@@ -394,9 +399,8 @@ public boolean lock() {
 		 * Wrapper for {@link #InstanceMutexService#awaitLock(String, Optional)}
 		 *
 		 * @throws MutexWaitTimeoutException If the lock is not acquired within the timeout period.
-		 * @throws InterruptedException If the thread is interrupted while waiting for the lock.
 		 */
-		public void awaitLock() throws MutexWaitTimeoutException, InterruptedException {
+		public void awaitLock() throws MutexWaitTimeoutException {
 			this.mutexService.awaitLock(this.getMutexId(), this.getAdditionalIdentity());
 		}
 		
diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/InventoryItemsCrudTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/InventoryItemsCrudTest.java
index 31f53f425..e3f30c463 100644
--- a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/InventoryItemsCrudTest.java
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/InventoryItemsCrudTest.java
@@ -208,6 +208,9 @@ public void basicThreadTest(int numThreads, int numIterations) throws Interrupte
 		}
 		overall.stop();
 		
+		for (Future<Void> future : futures) {
+			future.get();
+		}
 		
 		//TODO:: check results
 		ObjectNode result = setupJwtCall(given(), testUser.getAttributes().get(TestUserService.TEST_JWT_ATT_KEY))
diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexServiceTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexServiceTest.java
index ea3877463..e8b8f64dc 100644
--- a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexServiceTest.java
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexServiceTest.java
@@ -10,10 +10,9 @@
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
-import tech.ebp.oqm.core.api.exception.MutexWaitTimeoutException;
+import tech.ebp.oqm.core.api.exception.mutex.MutexWaitTimeoutException;
 import tech.ebp.oqm.core.api.testResources.testClasses.RunningServerTest;
 
-import java.io.IOException;
 import java.time.Duration;
 import java.time.LocalDateTime;
 import java.time.temporal.ChronoUnit;

From 1e9395da001ecaab701e3e9ed53875134d51938a Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Sat, 16 May 2026 12:37:46 -0400
Subject: [PATCH 16/48] Core - API - Tweaks to mutex tests

---
 .../items/InventoryItemsCrudTest.java         | 43 +++++++++++--------
 .../InstanceMutexServiceTest.java             |  5 ++-
 2 files changed, 28 insertions(+), 20 deletions(-)

diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/InventoryItemsCrudTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/InventoryItemsCrudTest.java
index e3f30c463..1f299f5cc 100644
--- a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/InventoryItemsCrudTest.java
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/InventoryItemsCrudTest.java
@@ -242,26 +242,33 @@ static class BasicItemUpdateTestThread implements Callable<Void> {
 		public Void call() {
 			log.info("Running test thread {}", this.threadId);
 			
-			ObjectNode updates = OBJECT_MAPPER.createObjectNode();
-			updates.putObject("attributes");
-			
-			for (int i = 1; i <= this.numIterations; i++) {
-				log.info("Thread {} waiting for lock on iteration {}", this.threadId, i);
-				
-				((ObjectNode) updates.get("attributes")).put(this.threadId, i);
 				
-				//initial update
-				ValidatableResponse response = setupJwtCall(given(), testUser.getAttributes().get(TestUserService.TEST_JWT_ATT_KEY))
-												   .when()
-												   .body(updates)
-												   .contentType(ContentType.JSON)
-												   .accept(ContentType.JSON)
-												   .pathParam("oqmDbIdOrName", DEFAULT_TEST_DB_NAME)
-												   .put(this.inventoryItemId)
-												   .then()
-												   .statusCode(200);
+				ObjectNode updates = OBJECT_MAPPER.createObjectNode();
+				updates.putObject("attributes");
 				
-			}
+				for (int i = 1; i <= this.numIterations; i++) {
+					log.info("Thread {} waiting for lock on iteration {}", this.threadId, i);
+					
+					((ObjectNode) updates.get("attributes")).put(this.threadId, i);
+					
+					
+					try {
+					//initial update
+					ValidatableResponse response = setupJwtCall(given(), testUser.getAttributes().get(TestUserService.TEST_JWT_ATT_KEY))
+													   .when()
+													   .body(updates)
+													   .contentType(ContentType.JSON)
+													   .accept(ContentType.JSON)
+													   .pathParam("oqmDbIdOrName", DEFAULT_TEST_DB_NAME)
+													   .put(this.inventoryItemId)
+													   .then()
+													   .statusCode(200);
+					} catch (Throwable e) {
+						log.error("Error in thread {} on iteration {}", this.threadId, i, e);
+						throw new RuntimeException("Error thrown in thread " + this.threadId + " on iteration " + i, e);
+					}
+				}
+			
 			log.info("DONE running test thread {}", this.threadId);
 			return null;
 		}
diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexServiceTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexServiceTest.java
index e8b8f64dc..80aec7f1a 100644
--- a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexServiceTest.java
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/serviceState/InstanceMutexServiceTest.java
@@ -10,6 +10,7 @@
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
+import tech.ebp.oqm.core.api.exception.mutex.MutexNotRegisteredException;
 import tech.ebp.oqm.core.api.exception.mutex.MutexWaitTimeoutException;
 import tech.ebp.oqm.core.api.testResources.testClasses.RunningServerTest;
 
@@ -223,9 +224,9 @@ public void testWithResources() throws InterruptedException {
 	@Test
 	public void testUseBeforeRegister() {
 		assertEquals(
-			"Mutex was not registered before usage: testUseBeforeRegister",
+			"Mutex with id testUseBeforeRegister was not registered when lock attempt made.",
 			assertThrows(
-				IllegalStateException.class, ()->{
+				MutexNotRegisteredException.class, ()->{
 					this.instanceMutexService.lock("testUseBeforeRegister");
 				}
 			).getMessage()

From 581c1e21dc9de3199434bbcdbb00583b0db466fc Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Sat, 16 May 2026 19:18:53 -0400
Subject: [PATCH 17/48] Core - API - Added initial new objects for stored state

---
 .../items/stored/state/StoredInBlock.java     | 37 +++++++++++++++++++
 .../items/stored/state/StoredState.java       | 30 +++++++++++++++
 .../items/stored/state/StoredStateType.java   |  5 +++
 3 files changed, 72 insertions(+)
 create mode 100644 software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/state/StoredInBlock.java
 create mode 100644 software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/state/StoredState.java
 create mode 100644 software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/state/StoredStateType.java

diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/state/StoredInBlock.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/state/StoredInBlock.java
new file mode 100644
index 000000000..6935446c2
--- /dev/null
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/state/StoredInBlock.java
@@ -0,0 +1,37 @@
+package tech.ebp.oqm.core.api.model.object.storage.items.stored.state;
+
+
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.validation.constraints.NotNull;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import lombok.NonNull;
+import lombok.ToString;
+import org.bson.types.ObjectId;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+import tech.ebp.oqm.core.api.model.object.storage.storageBlock.StorageBlock;
+
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
+@Data
+@Builder
+@AllArgsConstructor
+@NoArgsConstructor
+public class StoredInBlock extends StoredState {
+	
+	@Override
+	public StoredStateType getType() {
+		return StoredStateType.STORED;
+	}
+	
+	/**
+	 * The {@link StorageBlock} this stored is stored in.
+	 */
+	@NonNull
+	@NotNull
+	@Schema(required = true, description = "The storage block where this item is stored.")
+	private ObjectId storageBlock;
+}
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/state/StoredState.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/state/StoredState.java
new file mode 100644
index 000000000..b2d463429
--- /dev/null
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/state/StoredState.java
@@ -0,0 +1,30 @@
+package tech.ebp.oqm.core.api.model.object.storage.items.stored.state;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.annotation.JsonSubTypes;
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.experimental.SuperBuilder;
+import org.bson.codecs.pojo.annotations.BsonDiscriminator;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.AmountStored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.UniqueStored;
+
+@Data
+@SuperBuilder(toBuilder = true)
+@JsonTypeInfo(
+	use = JsonTypeInfo.Id.NAME,
+	include = JsonTypeInfo.As.EXISTING_PROPERTY, property = "type"
+)
+@JsonSubTypes({
+	@JsonSubTypes.Type(value = StoredInBlock.class, name = "STORED")
+})
+@JsonInclude(JsonInclude.Include.ALWAYS)
+@Schema(oneOf = {AmountStored.class, UniqueStored.class})
+@BsonDiscriminator
+@NoArgsConstructor
+public abstract class StoredState {
+	
+	public abstract StoredStateType getType();
+}
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/state/StoredStateType.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/state/StoredStateType.java
new file mode 100644
index 000000000..e871ef896
--- /dev/null
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/state/StoredStateType.java
@@ -0,0 +1,5 @@
+package tech.ebp.oqm.core.api.model.object.storage.items.stored.state;
+
+public enum StoredStateType {
+	STORED
+}

From d184c27353a4fd10015b25bb6f777bf3350895f3 Mon Sep 17 00:00:00 2001
From: axgiri <146159445+axgiri@users.noreply.github.com>
Date: Sat, 16 May 2026 21:34:44 +0200
Subject: [PATCH 18/48] basic mongodb indexig added

---
 .../oqm/core/api/scheduled/LifecycleBean.java |  7 ++++-
 .../scheduled/MongoInitializationHandler.java | 28 +++++++++++++++++++
 .../service/mongo/InventoryItemService.java   |  8 ++++++
 .../api/service/mongo/ItemListService.java    | 10 +++++++
 .../service/mongo/MongoDbAwareService.java    | 14 +++++++++-
 .../service/mongo/StorageBlockService.java    |  8 ++++++
 6 files changed, 73 insertions(+), 2 deletions(-)
 create mode 100644 software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/scheduled/MongoInitializationHandler.java

diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/scheduled/LifecycleBean.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/scheduled/LifecycleBean.java
index 35e6a8979..d7070a55b 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/scheduled/LifecycleBean.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/scheduled/LifecycleBean.java
@@ -42,7 +42,10 @@ public class LifecycleBean {
 
 	@Inject
 	ObjectSchemaUpgradeService objectSchemaUpgradeService;
-	
+
+	@Inject
+	MongoInitializationHandler mongoInitializationHandler;
+
 	private ZonedDateTime startDateTime;
 	
 	public static void logConfig(){
@@ -145,6 +148,8 @@ void onStart(
 			log.info("Schema upgrade result: {}", schemaUpgradeResult.get());
 			//TODO:: rescan inv update stats
 		}
+		// initialize indexes
+		this.mongoInitializationHandler.initDb();
 		log.info("Done with initial startup tasks.");
 	}
 	
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/scheduled/MongoInitializationHandler.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/scheduled/MongoInitializationHandler.java
new file mode 100644
index 000000000..4471ef59f
--- /dev/null
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/scheduled/MongoInitializationHandler.java
@@ -0,0 +1,28 @@
+package tech.ebp.oqm.core.api.scheduled;
+
+import jakarta.enterprise.inject.Any;
+import jakarta.enterprise.inject.Instance;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
+import tech.ebp.oqm.core.api.service.mongo.MongoDbAwareService;
+import tech.ebp.oqm.core.api.service.serviceState.db.DbCacheEntry;
+import tech.ebp.oqm.core.api.service.serviceState.db.OqmDatabaseService;
+
+@Singleton
+public class MongoInitializationHandler {
+    @Inject
+    OqmDatabaseService oqmDatabaseService;
+
+    @Inject
+    @Any
+    Instance<MongoDbAwareService<?, ?, ?>> mongoServices;
+
+    void initDb() {
+        for (DbCacheEntry db : oqmDatabaseService.getDatabases()) {
+            String dbName = db.getDbName();
+            for (MongoDbAwareService<?, ?, ?> service : mongoServices) {
+                service.initDb(dbName);
+            }
+        }
+    }
+}
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/InventoryItemService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/InventoryItemService.java
index 937bfbbe2..4b59a192d 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/InventoryItemService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/InventoryItemService.java
@@ -13,6 +13,7 @@
 import lombok.Getter;
 import lombok.NonNull;
 import lombok.extern.slf4j.Slf4j;
+import org.bson.Document;
 import org.bson.types.ObjectId;
 import org.jetbrains.annotations.NotNull;
 import tech.ebp.oqm.core.api.config.CoreApiInteractingEntity;
@@ -447,4 +448,11 @@ public void runPostUpgrade(String oqmDbIdOrName, ClientSession cs, CollectionUpg
 			}
 		}
 	}
+
+	@Override
+	List<Document> getDbIndexes() {
+		return List.of(
+			new Document("name", 1)
+		);
+	}
 }
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/ItemListService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/ItemListService.java
index 729c56f60..71af49cba 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/ItemListService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/ItemListService.java
@@ -4,6 +4,7 @@
 import jakarta.enterprise.context.ApplicationScoped;
 import jakarta.json.JsonObject;
 import lombok.extern.slf4j.Slf4j;
+import org.bson.Document;
 import org.bson.types.ObjectId;
 import tech.ebp.oqm.core.api.model.collectionStats.CollectionStats;
 import tech.ebp.oqm.core.api.model.object.history.events.itemList.ItemListActionAddEvent;
@@ -12,6 +13,8 @@
 import tech.ebp.oqm.core.api.model.object.itemList.ItemListAction;
 import tech.ebp.oqm.core.api.model.rest.search.ItemListSearch;
 
+import java.util.List;
+
 @Slf4j
 @ApplicationScoped
 public class ItemListService extends MongoHistoriedObjectService<ItemList, ItemListSearch, CollectionStats> {
@@ -62,4 +65,11 @@ public ItemList updateAction(String oqmDbIdOrName, ObjectId listId, ObjectId ite
 	public int getCurrentSchemaVersion() {
 		return ItemList.CUR_SCHEMA_VERSION;
 	}
+
+	@Override
+	public List<Document> getDbIndexes() {
+		return List.of(
+			new Document("name", 1)
+		);
+	}
 }
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/MongoDbAwareService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/MongoDbAwareService.java
index 7e39a7a16..15814b654 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/MongoDbAwareService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/MongoDbAwareService.java
@@ -25,6 +25,7 @@
 import tech.ebp.oqm.core.api.service.serviceState.db.OqmDatabaseService;
 
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 
 /**
@@ -172,5 +173,16 @@ protected <X extends CollectionStats.CollectionStatsBuilder<?,?>> X addBaseStats
 	
 	public void runPostUpgrade(String oqmDbIdOrName, ClientSession cs, CollectionUpgradeResult upgradeResult) {
 		//nothing to do.
-	};
+	}
+
+	List<Document> getDbIndexes() {
+		return List.of();
+	}
+
+	public void initDb(String oqmDbIdOrName) {
+		    List<Document> indexes = this.getDbIndexes();
+		    for(Document index : indexes) {
+		        getDocumentCollection(oqmDbIdOrName).createIndex(index);
+		    }
+		}
 }
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/StorageBlockService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/StorageBlockService.java
index 0de704677..74d630588 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/StorageBlockService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/StorageBlockService.java
@@ -5,6 +5,7 @@
 import jakarta.inject.Inject;
 import jakarta.inject.Named;
 import lombok.extern.slf4j.Slf4j;
+import org.bson.Document;
 import org.bson.conversions.Bson;
 import org.bson.types.ObjectId;
 import tech.ebp.oqm.core.api.model.collectionStats.CollectionStats;
@@ -191,4 +192,11 @@ public Map<String, Set<ObjectId>> getReferencingObjects(String oqmDbIdOrName, Cl
 	public int getCurrentSchemaVersion() {
 		return StorageBlock.CUR_SCHEMA_VERSION;
 	}
+
+	@Override
+	List<Document> getDbIndexes() {
+		return List.of(
+			new Document("location", 1)
+		);
+	}
 }

From de3374543bce4970c6575178372f8afd3a34ec6c Mon Sep 17 00:00:00 2001
From: axgiri <146159445+axgiri@users.noreply.github.com>
Date: Sun, 17 May 2026 13:57:21 +0200
Subject: [PATCH 19/48] Refactor MongoDB initialization and indexing logic
 across services

---
 .../oqm/core/api/scheduled/LifecycleBean.java |  5 -
 .../oqm/core/api/scheduled/MongoDbInit.java   | 94 +++++++++++--------
 .../scheduled/MongoInitializationHandler.java | 28 ------
 .../service/mongo/InventoryItemService.java   |  8 +-
 .../api/service/mongo/ItemListService.java    |  7 +-
 .../service/mongo/MongoDbAwareService.java    | 17 ++--
 .../service/mongo/StorageBlockService.java    |  6 +-
 7 files changed, 76 insertions(+), 89 deletions(-)
 delete mode 100644 software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/scheduled/MongoInitializationHandler.java

diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/scheduled/LifecycleBean.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/scheduled/LifecycleBean.java
index d7070a55b..5dcbb2e77 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/scheduled/LifecycleBean.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/scheduled/LifecycleBean.java
@@ -43,9 +43,6 @@ public class LifecycleBean {
 	@Inject
 	ObjectSchemaUpgradeService objectSchemaUpgradeService;
 
-	@Inject
-	MongoInitializationHandler mongoInitializationHandler;
-
 	private ZonedDateTime startDateTime;
 	
 	public static void logConfig(){
@@ -148,8 +145,6 @@ void onStart(
 			log.info("Schema upgrade result: {}", schemaUpgradeResult.get());
 			//TODO:: rescan inv update stats
 		}
-		// initialize indexes
-		this.mongoInitializationHandler.initDb();
 		log.info("Done with initial startup tasks.");
 	}
 	
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/scheduled/MongoDbInit.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/scheduled/MongoDbInit.java
index 56f9783fa..0b4009bc6 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/scheduled/MongoDbInit.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/scheduled/MongoDbInit.java
@@ -2,10 +2,13 @@
 
 import io.quarkus.runtime.StartupEvent;
 import jakarta.enterprise.event.Observes;
+import jakarta.enterprise.inject.Any;
+import jakarta.enterprise.inject.Instance;
 import jakarta.inject.Inject;
 import jakarta.inject.Singleton;
 import lombok.extern.slf4j.Slf4j;
 import tech.ebp.oqm.core.api.service.mongo.InventoryItemService;
+import tech.ebp.oqm.core.api.service.mongo.MongoDbAwareService;
 import tech.ebp.oqm.core.api.service.serviceState.InstanceMutexService;
 import tech.ebp.oqm.core.api.service.serviceState.db.DbCacheEntry;
 import tech.ebp.oqm.core.api.service.serviceState.db.OqmDatabaseService;
@@ -14,45 +17,54 @@
 @Slf4j
 public class MongoDbInit {
 
-	@Inject
-	InventoryItemService inventoryItemService;
-	
-	@Inject
-	OqmDatabaseService oqmDatabaseService;
-	
-	@Inject
-	InstanceMutexService instanceMutexService;
-	
-	
-	/**
-	 * This was introduced in version 4.4.8 ~ May 15, 2026
-	 *
-	 * It was intended to ensure that all inventory items created before an upgrade have a mutex registered for them.
-	 *
-	 * This can be removed once all inventory items have mutexes.
-	 */
-	private void ensureItemMutexesExist() {
-		log.info("Ensuring inventory item mutexes exist.");
-		
-		for(DbCacheEntry curDb : this.oqmDatabaseService.getDatabases()) {
-			log.info("Ensuring inventory item mutexes exist for database: {}", curDb.getDbName());
-			this.inventoryItemService.iterator(curDb.getDbId().toHexString()).forEachRemaining((item) -> {
-				this.instanceMutexService.register(
-					this.instanceMutexService.getMutexIdFor(curDb.getDbId().toHexString(), item)
-				);
-			});
-			log.info("DONE Ensuring inventory item mutexes exist for database: {}", curDb.getDbName());
-		}
-		
-		log.info("DONE Ensuring inventory item mutexes exist.");
-	}
-	
-	
-	void onStart(
-		@Observes
-		StartupEvent ev
-	) {
-		this.ensureItemMutexesExist();
-		
-	}
+    @Inject
+    InventoryItemService inventoryItemService;
+
+    @Inject
+    OqmDatabaseService oqmDatabaseService;
+
+    @Inject
+    InstanceMutexService instanceMutexService;
+
+    @Inject
+    @Any
+    Instance<MongoDbAwareService<?, ?, ?>> mongoServices;
+
+    /**
+     * This was introduced in version 4.4.8 ~ May 15, 2026
+     * <p>
+     * It was intended to ensure that all inventory items created before an upgrade have a mutex registered for them.
+     * <p>
+     * This can be removed once all inventory items have mutexes.
+     */
+    private void ensureItemMutexesExist() {
+        log.info("Ensuring inventory item mutexes exist.");
+
+        for (DbCacheEntry curDb : this.oqmDatabaseService.getDatabases()) {
+            log.info("Ensuring inventory item mutexes exist for database: {}", curDb.getDbName());
+            this.inventoryItemService.iterator(curDb.getDbId().toHexString()).forEachRemaining((item) -> {
+                this.instanceMutexService.register(
+                    this.instanceMutexService.getMutexIdFor(curDb.getDbId().toHexString(), item)
+                );
+            });
+            log.info("DONE Ensuring inventory item mutexes exist for database: {}", curDb.getDbName());
+        }
+
+        log.info("DONE Ensuring inventory item mutexes exist.");
+    }
+
+
+    void onStart(
+        @Observes
+        StartupEvent ev
+    ) {
+        this.ensureItemMutexesExist();
+        this.initDb();
+    }
+
+    void initDb() {
+        for(MongoDbAwareService<?, ?, ?> service : this.mongoServices){
+            service.initDb();
+        }
+    }
 }
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/scheduled/MongoInitializationHandler.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/scheduled/MongoInitializationHandler.java
deleted file mode 100644
index 4471ef59f..000000000
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/scheduled/MongoInitializationHandler.java
+++ /dev/null
@@ -1,28 +0,0 @@
-package tech.ebp.oqm.core.api.scheduled;
-
-import jakarta.enterprise.inject.Any;
-import jakarta.enterprise.inject.Instance;
-import jakarta.inject.Inject;
-import jakarta.inject.Singleton;
-import tech.ebp.oqm.core.api.service.mongo.MongoDbAwareService;
-import tech.ebp.oqm.core.api.service.serviceState.db.DbCacheEntry;
-import tech.ebp.oqm.core.api.service.serviceState.db.OqmDatabaseService;
-
-@Singleton
-public class MongoInitializationHandler {
-    @Inject
-    OqmDatabaseService oqmDatabaseService;
-
-    @Inject
-    @Any
-    Instance<MongoDbAwareService<?, ?, ?>> mongoServices;
-
-    void initDb() {
-        for (DbCacheEntry db : oqmDatabaseService.getDatabases()) {
-            String dbName = db.getDbName();
-            for (MongoDbAwareService<?, ?, ?> service : mongoServices) {
-                service.initDb(dbName);
-            }
-        }
-    }
-}
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/InventoryItemService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/InventoryItemService.java
index 4b59a192d..655797274 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/InventoryItemService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/InventoryItemService.java
@@ -5,6 +5,8 @@
 import com.fasterxml.jackson.databind.node.ObjectNode;
 import com.mongodb.client.ClientSession;
 import com.mongodb.client.FindIterable;
+import com.mongodb.client.model.IndexOptions;
+import com.mongodb.client.model.Indexes;
 import jakarta.enterprise.context.ApplicationScoped;
 import jakarta.inject.Inject;
 import jakarta.inject.Named;
@@ -13,7 +15,7 @@
 import lombok.Getter;
 import lombok.NonNull;
 import lombok.extern.slf4j.Slf4j;
-import org.bson.Document;
+import org.bson.conversions.Bson;
 import org.bson.types.ObjectId;
 import org.jetbrains.annotations.NotNull;
 import tech.ebp.oqm.core.api.config.CoreApiInteractingEntity;
@@ -450,9 +452,9 @@ public void runPostUpgrade(String oqmDbIdOrName, ClientSession cs, CollectionUpg
 	}
 
 	@Override
-	List<Document> getDbIndexes() {
+	List<Bson> getDbIndexes() {
 		return List.of(
-			new Document("name", 1)
+			Indexes.ascending("name")
 		);
 	}
 }
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/ItemListService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/ItemListService.java
index 71af49cba..4dc99848e 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/ItemListService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/ItemListService.java
@@ -1,10 +1,11 @@
 package tech.ebp.oqm.core.api.service.mongo;
 
 import com.mongodb.client.ClientSession;
+import com.mongodb.client.model.Indexes;
 import jakarta.enterprise.context.ApplicationScoped;
 import jakarta.json.JsonObject;
 import lombok.extern.slf4j.Slf4j;
-import org.bson.Document;
+import org.bson.conversions.Bson;
 import org.bson.types.ObjectId;
 import tech.ebp.oqm.core.api.model.collectionStats.CollectionStats;
 import tech.ebp.oqm.core.api.model.object.history.events.itemList.ItemListActionAddEvent;
@@ -67,9 +68,9 @@ public int getCurrentSchemaVersion() {
 	}
 
 	@Override
-	public List<Document> getDbIndexes() {
+	public List<Bson> getDbIndexes() {
 		return List.of(
-			new Document("name", 1)
+			Indexes.ascending("name")
 		);
 	}
 }
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/MongoDbAwareService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/MongoDbAwareService.java
index 15814b654..32f9f7b28 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/MongoDbAwareService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/MongoDbAwareService.java
@@ -10,6 +10,7 @@
 import lombok.NonNull;
 import lombok.extern.slf4j.Slf4j;
 import org.bson.Document;
+import org.bson.conversions.Bson;
 import org.bson.types.ObjectId;
 import tech.ebp.oqm.core.api.model.collectionStats.CollectionStats;
 import tech.ebp.oqm.core.api.model.object.FileAttachmentContaining;
@@ -175,14 +176,18 @@ public void runPostUpgrade(String oqmDbIdOrName, ClientSession cs, CollectionUpg
 		//nothing to do.
 	}
 
-	List<Document> getDbIndexes() {
+	List<Bson> getDbIndexes() {
 		return List.of();
 	}
 
-	public void initDb(String oqmDbIdOrName) {
-		    List<Document> indexes = this.getDbIndexes();
-		    for(Document index : indexes) {
-		        getDocumentCollection(oqmDbIdOrName).createIndex(index);
-		    }
+	public void initDbByIdOrName(String oqmDbIdOrName) {
+		List<Bson> indexes = this.getDbIndexes();
+		for (Bson index : indexes) {
+			getDocumentCollection(oqmDbIdOrName).createIndex(index);
 		}
+	}
+
+	public void initDb(){
+		oqmDatabaseService.getDatabases().forEach(db -> this.initDbByIdOrName(db.getDbName()));
+	}
 }
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/StorageBlockService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/StorageBlockService.java
index 74d630588..38572021b 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/StorageBlockService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/StorageBlockService.java
@@ -1,11 +1,11 @@
 package tech.ebp.oqm.core.api.service.mongo;
 
 import com.mongodb.client.ClientSession;
+import com.mongodb.client.model.Indexes;
 import jakarta.enterprise.context.ApplicationScoped;
 import jakarta.inject.Inject;
 import jakarta.inject.Named;
 import lombok.extern.slf4j.Slf4j;
-import org.bson.Document;
 import org.bson.conversions.Bson;
 import org.bson.types.ObjectId;
 import tech.ebp.oqm.core.api.model.collectionStats.CollectionStats;
@@ -194,9 +194,9 @@ public int getCurrentSchemaVersion() {
 	}
 
 	@Override
-	List<Document> getDbIndexes() {
+	List<Bson> getDbIndexes() {
 		return List.of(
-			new Document("location", 1)
+			Indexes.ascending("name")
 		);
 	}
 }

From 4eb6d21b9d9560695a4e85741634227bc005a0e6 Mon Sep 17 00:00:00 2001
From: axgiri <146159445+axgiri@users.noreply.github.com>
Date: Sun, 17 May 2026 16:53:13 +0200
Subject: [PATCH 20/48] add unique and background options to mongodb indexes

---
 .../ebp/oqm/core/api/service/mongo/MongoDbAwareService.java   | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/MongoDbAwareService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/MongoDbAwareService.java
index 32f9f7b28..d7f811477 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/MongoDbAwareService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/MongoDbAwareService.java
@@ -4,6 +4,7 @@
 import com.mongodb.client.ClientSession;
 import com.mongodb.client.MongoClient;
 import com.mongodb.client.MongoCollection;
+import com.mongodb.client.model.IndexOptions;
 import jakarta.inject.Inject;
 import jakarta.validation.*;
 import lombok.Getter;
@@ -181,9 +182,10 @@ List<Bson> getDbIndexes() {
 	}
 
 	public void initDbByIdOrName(String oqmDbIdOrName) {
+		IndexOptions options = new IndexOptions().unique(true).background(true);
 		List<Bson> indexes = this.getDbIndexes();
 		for (Bson index : indexes) {
-			getDocumentCollection(oqmDbIdOrName).createIndex(index);
+			getDocumentCollection(oqmDbIdOrName).createIndex(index, options);
 		}
 	}
 

From 239afdb2ca1ded24e923503520c925b266165d0f Mon Sep 17 00:00:00 2001
From: axgiri <146159445+axgiri@users.noreply.github.com>
Date: Sun, 17 May 2026 21:44:40 +0200
Subject: [PATCH 21/48] refactor: add index initialization to
 TopLevelMongoService and MongoDbAwareService

---
 .../oqm/core/api/scheduled/MongoDbInit.java    |  5 +++--
 .../service/mongo/InventoryItemService.java    |  3 +--
 .../api/service/mongo/MongoDbAwareService.java |  3 ++-
 .../core/api/service/mongo/MongoService.java   |  7 +++++++
 .../api/service/mongo/StorageBlockService.java |  2 +-
 .../service/mongo/TopLevelMongoService.java    | 18 +++++++++++++++++-
 .../serviceState/db/OqmDatabaseService.java    |  9 +++++++++
 7 files changed, 40 insertions(+), 7 deletions(-)

diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/scheduled/MongoDbInit.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/scheduled/MongoDbInit.java
index 0b4009bc6..2b7511dae 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/scheduled/MongoDbInit.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/scheduled/MongoDbInit.java
@@ -9,6 +9,7 @@
 import lombok.extern.slf4j.Slf4j;
 import tech.ebp.oqm.core.api.service.mongo.InventoryItemService;
 import tech.ebp.oqm.core.api.service.mongo.MongoDbAwareService;
+import tech.ebp.oqm.core.api.service.mongo.MongoService;
 import tech.ebp.oqm.core.api.service.serviceState.InstanceMutexService;
 import tech.ebp.oqm.core.api.service.serviceState.db.DbCacheEntry;
 import tech.ebp.oqm.core.api.service.serviceState.db.OqmDatabaseService;
@@ -28,7 +29,7 @@ public class MongoDbInit {
 
     @Inject
     @Any
-    Instance<MongoDbAwareService<?, ?, ?>> mongoServices;
+    Instance<MongoService<?, ?, ?>> mongoServices;
 
     /**
      * This was introduced in version 4.4.8 ~ May 15, 2026
@@ -63,7 +64,7 @@ void onStart(
     }
 
     void initDb() {
-        for(MongoDbAwareService<?, ?, ?> service : this.mongoServices){
+        for(MongoService<?, ?, ?> service : this.mongoServices){
             service.initDb();
         }
     }
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/InventoryItemService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/InventoryItemService.java
index 655797274..845face85 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/InventoryItemService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/InventoryItemService.java
@@ -5,7 +5,6 @@
 import com.fasterxml.jackson.databind.node.ObjectNode;
 import com.mongodb.client.ClientSession;
 import com.mongodb.client.FindIterable;
-import com.mongodb.client.model.IndexOptions;
 import com.mongodb.client.model.Indexes;
 import jakarta.enterprise.context.ApplicationScoped;
 import jakarta.inject.Inject;
@@ -452,7 +451,7 @@ public void runPostUpgrade(String oqmDbIdOrName, ClientSession cs, CollectionUpg
 	}
 
 	@Override
-	List<Bson> getDbIndexes() {
+	public List<Bson> getDbIndexes() {
 		return List.of(
 			Indexes.ascending("name")
 		);
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/MongoDbAwareService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/MongoDbAwareService.java
index d7f811477..1a086c4ef 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/MongoDbAwareService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/MongoDbAwareService.java
@@ -177,7 +177,8 @@ public void runPostUpgrade(String oqmDbIdOrName, ClientSession cs, CollectionUpg
 		//nothing to do.
 	}
 
-	List<Bson> getDbIndexes() {
+	@Override
+	public List<Bson> getDbIndexes() {
 		return List.of();
 	}
 
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/MongoService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/MongoService.java
index 6b2d49aa7..356a9823f 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/MongoService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/MongoService.java
@@ -14,11 +14,14 @@
 import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.extern.slf4j.Slf4j;
+import org.bson.conversions.Bson;
 import org.eclipse.microprofile.config.inject.ConfigProperty;
 import tech.ebp.oqm.core.api.model.collectionStats.CollectionStats;
 import tech.ebp.oqm.core.api.model.object.MainObject;
 import tech.ebp.oqm.core.api.model.rest.search.SearchObject;
 
+import java.util.List;
+
 /**
  * This is the main mongo class. It specifies top level, commonly shared utilities.
  * @param <T> The type of object this mongo service is dealing with
@@ -104,4 +107,8 @@ public MongoService(Class<T> clazz) {
 	}
 	
 	public abstract int getCurrentSchemaVersion();
+
+	public abstract List<Bson> getDbIndexes();
+
+	public abstract void initDb();
 }
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/StorageBlockService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/StorageBlockService.java
index 38572021b..4f1446e2d 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/StorageBlockService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/StorageBlockService.java
@@ -194,7 +194,7 @@ public int getCurrentSchemaVersion() {
 	}
 
 	@Override
-	List<Bson> getDbIndexes() {
+	public List<Bson> getDbIndexes() {
 		return List.of(
 			Indexes.ascending("name")
 		);
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/TopLevelMongoService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/TopLevelMongoService.java
index 07c7a7576..4f2d8eed0 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/TopLevelMongoService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/TopLevelMongoService.java
@@ -4,6 +4,7 @@
 import com.mongodb.client.FindIterable;
 import com.mongodb.client.MongoCollection;
 import com.mongodb.client.MongoDatabase;
+import com.mongodb.client.model.IndexOptions;
 import com.mongodb.client.model.Sorts;
 import lombok.NonNull;
 import lombok.extern.slf4j.Slf4j;
@@ -202,5 +203,20 @@ public CollectionStats collectionStats() {
 	
 	public void runPostUpgrade(ClientSession cs, CollectionUpgradeResult upgradeResult) {
 		//nothing to do.
-	};
+	}
+
+	@Override
+	public List<Bson> getDbIndexes() {
+		return List.of();
+	}
+
+	@Override
+	public void initDb() {
+		//add indexes as unique?
+		IndexOptions options = new IndexOptions().background(true);
+		List<Bson> indexes = this.getDbIndexes();
+		for (Bson index : indexes) {
+			this.getDocumentCollection().createIndex(index, options);
+		}
+	}
 }
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/serviceState/db/OqmDatabaseService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/serviceState/db/OqmDatabaseService.java
index 810fe4ae8..83e2245c9 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/serviceState/db/OqmDatabaseService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/serviceState/db/OqmDatabaseService.java
@@ -2,6 +2,7 @@
 
 import com.mongodb.client.MongoCollection;
 import com.mongodb.client.model.Filters;
+import com.mongodb.client.model.Indexes;
 import jakarta.annotation.PostConstruct;
 import jakarta.enterprise.context.ApplicationScoped;
 import jakarta.validation.Valid;
@@ -11,6 +12,7 @@
 import lombok.NonNull;
 import lombok.Setter;
 import lombok.extern.slf4j.Slf4j;
+import org.bson.conversions.Bson;
 import org.bson.types.ObjectId;
 import org.eclipse.microprofile.config.ConfigProvider;
 import org.eclipse.microprofile.config.inject.ConfigProperty;
@@ -186,4 +188,11 @@ public boolean ensureDatabase(String dbName) {
 	public int getCurrentSchemaVersion() {
 		return OqmMongoDatabase.CUR_SCHEMA_VERSION;
 	}
+
+	@Override
+	public List<Bson> getDbIndexes() {
+		return List.of(
+			Indexes.ascending("name")
+		);
+	}
 }

From a15f8aa637c613e82714d2d42103633856a7aa3b Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Sun, 17 May 2026 18:58:09 -0400
Subject: [PATCH 22/48] Core - API - Set stored to use new stored state object.
 Updated stored search to reflect this

---
 .../object/storage/items/stored/Stored.java      | 14 +++++++++++---
 .../core/api/model/rest/search/StoredSearch.java | 16 ++++++++++++----
 2 files changed, 23 insertions(+), 7 deletions(-)

diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/Stored.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/Stored.java
index 982e7aec3..bee520e16 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/Stored.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/Stored.java
@@ -29,6 +29,8 @@
 import tech.ebp.oqm.core.api.model.object.storage.items.notification.StoredNotificationStatus;
 import tech.ebp.oqm.core.api.model.object.storage.items.pricing.CalculatedPricing;
 import tech.ebp.oqm.core.api.model.object.storage.items.pricing.StoredPricing;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredState;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredStateType;
 import tech.ebp.oqm.core.api.model.object.storage.storageBlock.StorageBlock;
 import tech.ebp.oqm.core.api.model.units.UnitUtils;
 import tech.ebp.oqm.core.api.model.validation.annotations.UniqueLabeledCollection;
@@ -247,10 +249,16 @@ public static String parseLabel(Stored stored, String format) {
 	private ObjectId item;
 	
 	/**
-	 * The {@link StorageBlock} this stored is stored in.
+	 * The state describing how this item is stored. Example, stored in a storage block, or installed in another item.
 	 */
-	@Schema(required = true, description = "The storage block where this item is stored.")
-	private ObjectId storageBlock;
+	@NonNull
+	@NotNull
+	@Schema(description = "The state describing how this item is stored. Example, stored in a storage block, or installed in another item.")
+	private StoredState state;
+	
+	public boolean isState(StoredStateType type) {
+		return this.getState().getType().equals(type);
+	}
 	
 	/**
 	 * The general ids that apply to this stored, but not to all stored (as specified in the associated item)
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/rest/search/StoredSearch.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/rest/search/StoredSearch.java
index 401335e8a..5c1ef3a90 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/rest/search/StoredSearch.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/rest/search/StoredSearch.java
@@ -1,6 +1,7 @@
 package tech.ebp.oqm.core.api.model.rest.search;
 
 import com.mongodb.client.model.Filters;
+import jakarta.ws.rs.DefaultValue;
 import jakarta.ws.rs.PathParam;
 import jakarta.ws.rs.QueryParam;
 import lombok.Getter;
@@ -10,6 +11,7 @@
 import org.bson.types.ObjectId;
 import tech.ebp.oqm.core.api.model.object.storage.items.InventoryItem;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.Stored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredStateType;
 import tech.ebp.oqm.core.api.service.mongo.search.SearchUtils;
 
 import java.util.ArrayList;
@@ -21,6 +23,10 @@
 @Getter
 @Setter
 public class StoredSearch extends SearchKeyAttObject<Stored> {
+	
+	@QueryParam("storedState")
+	@DefaultValue("STORED")
+	StoredStateType storedState = StoredStateType.STORED;
 
 	@PathParam("itemId") ObjectId inventoryItemIdFromPath;
 	@QueryParam("itemId") ObjectId inventoryItemIdFromQuery;
@@ -64,6 +70,8 @@ public ObjectId getInventoryItemId(){
 	@Override
 	public List<Bson> getSearchFilters() {
 		List<Bson> filters = super.getSearchFilters();
+		
+		filters.add(eq("state.type", this.getStoredState()));
 
 		if(hasValue(this.getInventoryItemIdFromPath())){
 			filters.add(eq("item", this.getInventoryItemIdFromPath()));
@@ -72,9 +80,9 @@ public List<Bson> getSearchFilters() {
 		}
 		
 		if(hasValue(this.getStorageBlockIdFromPath())){
-			filters.add(eq("storageBlock", this.getStorageBlockIdFromPath()));
+			filters.add(eq("state.storageBlock", this.getStorageBlockIdFromPath()));
 		} else if(hasValue(this.getStorageBlockIdFromQuery())){
-			filters.add(eq("storageBlock", this.getStorageBlockIdFromQuery()));
+			filters.add(eq("state.storageBlock", this.getStorageBlockIdFromQuery()));
 		}
 		
 		//TODO:: redo these
@@ -86,13 +94,13 @@ public List<Bson> getSearchFilters() {
 		if(hasValue(this.getInStorageBlocks())){
 			if(this.getInStorageBlocks().size() == 1){
 				filters.add(
-					eq("storageBlock", this.getInStorageBlocks().getFirst())
+					eq("state.storageBlock", this.getInStorageBlocks().getFirst())
 				);
 			} else {
 				filters.add(or(
 					this.getInStorageBlocks().stream().map((ObjectId storageBlockId) -> {
 //					return exists("storageBlocks." + storageBlockId.toHexString());
-						return eq("storageBlock", storageBlockId);
+						return eq("state.storageBlock", storageBlockId);
 					}).toList()
 				));
 			}

From f3b2f8e5c2668f5b1cd2245d1783fb0361f0ba6b Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Sun, 17 May 2026 18:59:05 -0400
Subject: [PATCH 23/48] Core - API - updated itemStatsService to reflect new
 stored state

---
 .../core/api/service/ItemStatsService.java    | 20 ++++++++++++++-----
 1 file changed, 15 insertions(+), 5 deletions(-)

diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/ItemStatsService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/ItemStatsService.java
index a029bda85..b7128c57e 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/ItemStatsService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/ItemStatsService.java
@@ -26,6 +26,9 @@
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.AmountStored;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.Stored;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.StoredType;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredInBlock;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredState;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredStateType;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.stats.BasicStatsContaining;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.stats.ItemStoredStats;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.stats.StatsWithTotalContaining;
@@ -138,7 +141,9 @@ private void addToStats(InventoryItem item, StoredInBlockStats storedInBlockStat
 	}
 	
 	private void addToStats(InventoryItem item, ItemStoredStats itemStoredStats, Stored stored) {
-		StoredInBlockStats storedInBlockStats = itemStoredStats.getStorageBlockStats().get(stored.getStorageBlock());
+		StoredInBlockStats storedInBlockStats = itemStoredStats.getStorageBlockStats().get(
+			((StoredInBlock)stored.getState()).getStorageBlock()
+		);
 		
 		this.addToStats(item, storedInBlockStats, stored);
 		this.addToStats(item, (StatsWithTotalContaining) itemStoredStats, stored);
@@ -345,7 +350,11 @@ public ItemPostTransactionProcessResults postTransactionProcess(
 			FindIterable<Stored> storedInItem = this.getStoredService().listIterator(
 				oqmDbIdOrName, cs, new StoredSearch()
 									   .setInventoryItemId(item.getId())
-									   .setInStorageBlocks(concerning.stream().map(Stored::getStorageBlock).distinct().collect(Collectors.toList()))
+									   .setInStorageBlocks(
+										   concerning.stream()
+											   .filter(s->s.isState(StoredStateType.STORED))
+											   .map(s->((StoredInBlock)(s.getState())).getStorageBlock()).distinct().collect(Collectors.toList())
+									   )
 			);
 			try (
 				MongoCursor<Stored> storedIterator = storedInItem.iterator();
@@ -365,11 +374,12 @@ oqmDbIdOrName, cs, new StoredSearch()
 					);
 					if (result.isPresent()) {
 						StoredExpiryLowStockProcessResult curResult = result.get();
+						ObjectId block = ((StoredInBlock)curStored.getState()).getStorageBlock();
 						
-						if (!results.getResults().containsKey(curStored.getStorageBlock())) {
-							results.getResults().put(curStored.getStorageBlock(), new ArrayList<>());
+						if (!results.getResults().containsKey(block)) {
+							results.getResults().put(block, new ArrayList<>());
 						}
-						results.getResults().get(curStored.getStorageBlock()).add(curResult);
+						results.getResults().get(block).add(curResult);
 					}
 				}
 			}

From bde2c4301d4ba384cc385024535b800f4e7c2f27 Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Sun, 17 May 2026 23:37:00 -0400
Subject: [PATCH 24/48] Core - API - initial usage of stored state rework

---
 .../object/storage/checkout/ItemCheckout.java |  1 +
 .../storage/checkout/ItemWholeCheckout.java   |  4 +-
 .../object/storage/items/stored/Stored.java   |  2 -
 .../core/api/service/mongo/StoredService.java | 55 ++++++++++++-------
 .../appliers/AddAmountTransactionApplier.java | 42 +++++++++-----
 .../appliers/AddWholeTransactionApplier.java  | 10 +++-
 .../CheckinFullTransactionApplier.java        | 55 ++++++++++++-------
 .../CheckoutAmountTransactionApplier.java     | 11 +++-
 .../appliers/SetAmountTransactionApplier.java | 29 ++++++----
 .../SubtractAmountTransactionApplier.java     |  8 ++-
 .../TransferAmountTransactionApplier.java     |  5 +-
 .../TransferWholeTransactionApplier.java      | 21 +++++--
 12 files changed, 163 insertions(+), 80 deletions(-)

diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/checkout/ItemCheckout.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/checkout/ItemCheckout.java
index 389109708..4027ce350 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/checkout/ItemCheckout.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/checkout/ItemCheckout.java
@@ -16,6 +16,7 @@
 import org.eclipse.microprofile.openapi.annotations.media.Schema;
 import tech.ebp.oqm.core.api.model.object.AttKeywordMainObject;
 import tech.ebp.oqm.core.api.model.object.storage.checkout.checkinDetails.CheckInDetails;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredState;
 
 import java.time.ZonedDateTime;
 
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/checkout/ItemWholeCheckout.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/checkout/ItemWholeCheckout.java
index 059c70472..1fee4a45c 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/checkout/ItemWholeCheckout.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/checkout/ItemWholeCheckout.java
@@ -9,6 +9,8 @@
 import org.bson.types.ObjectId;
 import org.eclipse.microprofile.openapi.annotations.media.Schema;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.Stored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredInBlock;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredState;
 
 /**
  * The details used to describe a checked out item
@@ -24,7 +26,7 @@ public class ItemWholeCheckout extends ItemCheckout<Stored> {
 	public static final int CUR_SCHEMA_VERSION = 2;
 	
 	public ObjectId getFromBlock() {
-		return this.getCheckedOut().getStorageBlock();
+		return ((StoredInBlock)(this.getCheckedOut().getState())).getStorageBlock();
 	}
 
 	@Override
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/Stored.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/Stored.java
index bee520e16..a16647c68 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/Stored.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/Stored.java
@@ -251,8 +251,6 @@ public static String parseLabel(Stored stored, String format) {
 	/**
 	 * The state describing how this item is stored. Example, stored in a storage block, or installed in another item.
 	 */
-	@NonNull
-	@NotNull
 	@Schema(description = "The state describing how this item is stored. Example, stored in a storage block, or installed in another item.")
 	private StoredState state;
 	
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/StoredService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/StoredService.java
index 1fd16fbb1..b59b0f404 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/StoredService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/StoredService.java
@@ -18,6 +18,7 @@
 import tech.ebp.oqm.core.api.model.object.interactingEntity.InteractingEntity;
 import tech.ebp.oqm.core.api.model.object.storage.items.InventoryItem;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.*;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredInBlock;
 import tech.ebp.oqm.core.api.model.rest.search.StoredSearch;
 import tech.ebp.oqm.core.api.exception.db.DbNotFoundException;
 import tech.ebp.oqm.core.api.service.mongo.search.ItemAwareSearchResult;
@@ -87,10 +88,41 @@ public void ensureObjectValid(String oqmDbIdOrName, boolean newObject, Stored ne
 			throw new ValidationException("Item " + newOrChangedObject.getItem().toHexString() + " does not exist.", e);
 		}
 		
-		if (!item.getStorageBlocks().contains(newOrChangedObject.getStorageBlock())) {
-			throw new ValidationException("Storage block " + newOrChangedObject.getStorageBlock().toHexString() + " not used to hold this item (" + item.getId() + ").");
+		if(newOrChangedObject.getState() == null) {
+			throw new ValidationException("Stored item must have a stored state.");
 		}
 		
+		switch (newOrChangedObject.getState().getType()){
+			case STORED:
+				ObjectId inBlock = ((StoredInBlock)(newOrChangedObject.getState())).getStorageBlock();
+				if (!item.getStorageBlocks().contains(inBlock)) {
+					throw new ValidationException("Storage block " + inBlock.toHexString() + " not used to hold this item (" + item.getId() + ").");
+				}
+				
+				if (item.getStorageType() == BULK) {
+					SearchResult<Stored> inBlockSearch = this.search(
+						oqmDbIdOrName,
+						new StoredSearch()
+							.setInventoryItemId(item.getId())
+							.setStorageBlockId(inBlock)
+					);
+					
+					if (!inBlockSearch.isEmpty()) {
+						if (inBlockSearch.getNumResults() != 1) {
+							throw new ValidationException("More than one stored held for item of type " + item.getStorageType());
+						}
+						Stored stored = inBlockSearch.getResults().get(0);
+						if (newObject || !stored.getId().equals(newOrChangedObject.getId())) {
+							throw new ValidationException("Cannot add more than one stored held for type " + item.getStorageType());
+						}
+					}
+				}
+				
+				
+				break;
+		}
+		
+		
 		if (item.getStorageType().storedType != newOrChangedObject.getType()) {
 			throw new ValidationException("Stored given of type " + newOrChangedObject.getType() + " cannot be held in item of storage type" + item.getStorageType());
 		}
@@ -107,25 +139,6 @@ public void ensureObjectValid(String oqmDbIdOrName, boolean newObject, Stored ne
 			}
 		}
 		
-		if (item.getStorageType() == BULK || item.getStorageType() == UNIQUE_SINGLE) {
-			SearchResult<Stored> inBlock = this.search(
-				oqmDbIdOrName,
-				new StoredSearch()
-					.setInventoryItemId(item.getId())
-					.setStorageBlockId(newOrChangedObject.getStorageBlock())
-			);
-			
-			if (!inBlock.isEmpty()) {
-				if (inBlock.getNumResults() != 1) {
-					throw new ValidationException("More than one stored held for item of type " + item.getStorageType());
-				}
-				Stored stored = inBlock.getResults().get(0);
-				if (newObject || !stored.getId().equals(newOrChangedObject.getId())) {
-					throw new ValidationException("Cannot add more than one stored held for type " + item.getStorageType());
-				}
-			}
-		}
-		
 		if (item.getStorageType() == UNIQUE_SINGLE) {
 			SearchResult<Stored> inItem = this.search(oqmDbIdOrName, new StoredSearch().setInventoryItemId(item.getId()));
 			if (!inItem.isEmpty()) {
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/AddAmountTransactionApplier.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/AddAmountTransactionApplier.java
index e42cd2f0f..1caa59dcf 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/AddAmountTransactionApplier.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/AddAmountTransactionApplier.java
@@ -8,6 +8,8 @@
 import tech.ebp.oqm.core.api.model.object.storage.items.InventoryItem;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.AmountStored;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.Stored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredInBlock;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredStateType;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.TransactionType;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.add.AddAmountTransaction;
 import tech.ebp.oqm.core.api.service.mongo.StoredService;
@@ -27,7 +29,7 @@ public class AddAmountTransactionApplier extends TransactionApplier<AddAmountTra
 	public TransactionType getTransactionType() {
 		return TransactionType.ADD_AMOUNT;
 	}
-
+	
 	@Override
 	public void apply(
 		String oqmDbIdOrName,
@@ -45,12 +47,12 @@ public void apply(
 				if (transaction.getToBlock() != null) {
 					try {
 						stored = this.getStoredService().getSingleStoredForItemBlock(oqmDbIdOrName, cs, inventoryItem.getId(), transaction.getToBlock(), AmountStored.class);
-					} catch (DbNotFoundException e) {
+					} catch(DbNotFoundException e) {
 						stored = AmountStored.builder()
-							.item(inventoryItem.getId())
-							.storageBlock(transaction.getToBlock())
-							.amount(Quantities.getQuantity(0, inventoryItem.getUnit()))
-							.build();
+									 .item(inventoryItem.getId())
+									 .state(StoredInBlock.builder().storageBlock(transaction.getToBlock()).build())
+									 .amount(Quantities.getQuantity(0, inventoryItem.getUnit()))
+									 .build();
 						this.getStoredService().add(oqmDbIdOrName, cs, stored, interactingEntity);
 					}
 					if (transaction.getToStored() != null) {
@@ -67,14 +69,22 @@ public void apply(
 			case AMOUNT_LIST -> {
 				if (transaction.getToStored() == null) {
 					stored = AmountStored.builder()
-						.item(inventoryItem.getId())
-						.storageBlock(transaction.getToBlock())
-						.amount(Quantities.getQuantity(0, inventoryItem.getUnit()))
-						.build();
+								 .item(inventoryItem.getId())
+								 .state(StoredInBlock.builder().storageBlock(transaction.getToBlock()).build())
+								 .amount(Quantities.getQuantity(0, inventoryItem.getUnit()))
+								 .build();
 					this.getStoredService().add(oqmDbIdOrName, cs, stored, interactingEntity);
 				} else {
 					stored = (AmountStored) this.getStoredService().get(oqmDbIdOrName, cs, transaction.getToStored());
-					if (!stored.getStorageBlock().equals(transaction.getToBlock())) {
+					
+					if(!stored.isState(StoredStateType.STORED)){
+						throw new IllegalArgumentException("Cannot add to stored that is not stored in a block.");
+					}
+					
+					if (
+						transaction.getToBlock() != null &&
+						!((StoredInBlock)(stored.getState())).getStorageBlock().equals(transaction.getToBlock())
+					) {
 						throw new IllegalArgumentException("To Stored given does not exist in block.");
 					}
 				}
@@ -83,13 +93,17 @@ public void apply(
 				throw new IllegalArgumentException("Cannot add an amount to a unique item.");
 			}
 		}
-
+		
 		if (!inventoryItem.getId().equals(stored.getItem())) {
 			throw new IllegalArgumentException("Stored is not associated with the item.");
 		}
-
+		
+		if(!stored.isState(StoredStateType.STORED)){
+			throw new IllegalArgumentException("Cannot add to stored that is not stored in a block.");
+		}
+		
 		stored.add(transaction.getAmount());
-
+		
 		affectedStored.add(stored);
 		this.getStoredService().update(oqmDbIdOrName, cs, stored, interactingEntity, historyDetails);
 	}
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/AddWholeTransactionApplier.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/AddWholeTransactionApplier.java
index c4e681a6c..8e525d9e4 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/AddWholeTransactionApplier.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/AddWholeTransactionApplier.java
@@ -8,6 +8,8 @@
 import tech.ebp.oqm.core.api.model.object.storage.items.InventoryItem;
 import tech.ebp.oqm.core.api.model.object.storage.items.StorageType;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.Stored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredInBlock;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredStateType;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.TransactionType;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.add.AddWholeTransaction;
 import tech.ebp.oqm.core.api.service.mongo.StoredService;
@@ -39,8 +41,10 @@ public void apply(
 			stored.setItem(inventoryItem.getId());
 		}
 		
-		if(stored.getStorageBlock() == null) {
-			stored.setStorageBlock(transaction.getToBlock());
+		if(stored.getState() == null) {
+			stored.setState(StoredInBlock.builder().storageBlock(transaction.getToBlock()).build());
+		} else if(!stored.isState(StoredStateType.STORED)) {
+			throw new IllegalArgumentException("Cannot add whole stored that is not stored in a block.");
 		}
 
 		if (!inventoryItem.getId().equals(stored.getItem())) {
@@ -51,7 +55,7 @@ public void apply(
 			throw new IllegalArgumentException("Cannot add whole item to a bulk storage typed item.");
 		}
 
-		if (!transaction.getToBlock().equals(stored.getStorageBlock())) {
+		if (!transaction.getToBlock().equals(((StoredInBlock)stored.getState()).getStorageBlock())) {
 			throw new IllegalArgumentException("To Block given does not match block marked in stored.");
 		}
 
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckinFullTransactionApplier.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckinFullTransactionApplier.java
index 1d0cf0101..093323194 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckinFullTransactionApplier.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckinFullTransactionApplier.java
@@ -11,6 +11,8 @@
 import tech.ebp.oqm.core.api.model.object.storage.items.InventoryItem;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.AmountStored;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.Stored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredInBlock;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredStateType;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.TransactionType;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.checkin.CheckinFullTransaction;
 import tech.ebp.oqm.core.api.service.mongo.ItemCheckoutService;
@@ -22,12 +24,12 @@
 
 @ApplicationScoped
 public class CheckinFullTransactionApplier extends CheckinOutTransactionApplier<CheckinFullTransaction> {
-
+	
 	@Override
 	public TransactionType getTransactionType() {
 		return TransactionType.CHECKIN_FULL;
 	}
-
+	
 	@Override
 	public void apply(
 		String oqmDbIdOrName,
@@ -40,14 +42,14 @@ public void apply(
 		ClientSession cs
 	) {
 		ItemCheckout<?> checkout = this.getItemCheckoutService().get(oqmDbIdOrName, cs, transaction.getCheckoutId());
-
+		
 		if (!inventoryItem.getId().equals(checkout.getItem())) {
 			throw new IllegalArgumentException("Checkout is not associated with the item.");
 		}
 		switch (checkout.getType()) {
 			case AMOUNT -> {
 				ItemAmountCheckout iac = (ItemAmountCheckout) checkout;
-
+				
 				AmountStored amountStored;
 				if (transaction.getToStored() != null) {
 					amountStored = (AmountStored) this.getStoredService().get(oqmDbIdOrName, cs, transaction.getToStored());
@@ -55,27 +57,33 @@ public void apply(
 					switch (inventoryItem.getStorageType()) {
 						case BULK -> {
 							try {
-								amountStored = this.getStoredService().getSingleStoredForItemBlock(oqmDbIdOrName, cs, inventoryItem.getId(), transaction.getToBlock(), AmountStored.class);
-							} catch (DbNotFoundException e) {
+								amountStored =
+									this.getStoredService().getSingleStoredForItemBlock(oqmDbIdOrName, cs, inventoryItem.getId(), transaction.getToBlock(), AmountStored.class);
+							} catch(DbNotFoundException e) {
 								amountStored = AmountStored.builder()
-									.item(inventoryItem.getId())
-									.storageBlock(transaction.getToBlock())
-									.amount(Quantities.getQuantity(0, inventoryItem.getUnit()))
-									.build();
+												   .item(inventoryItem.getId())
+												   .state(StoredInBlock.builder().storageBlock(transaction.getToBlock()).build())
+												   .amount(Quantities.getQuantity(0, inventoryItem.getUnit()))
+												   .build();
 								this.getStoredService().add(oqmDbIdOrName, cs, amountStored, interactingEntity);
 							}
 						}
 						case AMOUNT_LIST -> {
 							if (transaction.getToStored() == null) {
 								amountStored = AmountStored.builder()
-									.item(inventoryItem.getId())
-									.storageBlock(transaction.getToBlock())
-									.amount(Quantities.getQuantity(0, inventoryItem.getUnit()))
-									.build();
+												   .item(inventoryItem.getId())
+												   .state(StoredInBlock.builder().storageBlock(transaction.getToBlock()).build())
+												   .amount(Quantities.getQuantity(0, inventoryItem.getUnit()))
+												   .build();
 								this.getStoredService().add(oqmDbIdOrName, cs, amountStored, interactingEntity);
 							} else {
 								amountStored = (AmountStored) this.getStoredService().get(oqmDbIdOrName, cs, transaction.getToStored());
-								if (!amountStored.getStorageBlock().equals(transaction.getToBlock())) {
+								
+								if(!amountStored.isState(StoredStateType.STORED)){
+									throw new IllegalArgumentException("Cannot check into stored that is not stored.");
+								}
+								
+								if (!((StoredInBlock)amountStored.getState()).getStorageBlock().equals(transaction.getToBlock())) {
 									throw new IllegalArgumentException("To Stored given does not exist in block.");
 								}
 							}
@@ -85,11 +93,15 @@ public void apply(
 				} else {
 					throw new IllegalArgumentException("Must specify a stored or block to checkin into.");
 				}
-
+				
+				if(!amountStored.isState(StoredStateType.STORED)){
+					throw new IllegalArgumentException("Cannot check into stored that is not stored.");
+				}
+				
 				if (!inventoryItem.getId().equals(amountStored.getItem())) {
 					throw new IllegalArgumentException("Stored is not associated with the item.");
 				}
-
+				
 				amountStored.add(iac.getCheckedOut());
 				this.getStoredService().update(oqmDbIdOrName, cs, amountStored, interactingEntity, historyDetails);
 				affectedStored.add(amountStored);
@@ -99,7 +111,12 @@ public void apply(
 				if (!inventoryItem.getId().equals(checkedOut.getItem())) {
 					throw new IllegalArgumentException("Stored is not associated with the item.");
 				}
-				checkedOut.setStorageBlock(transaction.getToBlock());
+				
+				if(!checkedOut.isState(StoredStateType.STORED)){
+					throw new IllegalArgumentException("Cannot check in stored that is not stored in a block. This should bot happen, is bug.");
+				}
+				
+				((StoredInBlock)checkedOut.getState()).setStorageBlock(transaction.getToBlock());
 				this.getStoredService().add(oqmDbIdOrName, cs, checkedOut, interactingEntity, historyDetails);
 				affectedStored.add(checkedOut);
 			}
@@ -107,7 +124,7 @@ public void apply(
 				throw new IllegalArgumentException("Invalid checkout type.");
 			}
 		}
-
+		
 		checkout.setCheckInDetails(transaction.getDetails());
 		checkout.setCheckInTransaction(appliedTransactionId);
 		checkout.setCheckedInByEntity(interactingEntity.getId());
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckoutAmountTransactionApplier.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckoutAmountTransactionApplier.java
index 35f11b5bd..128bf1606 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckoutAmountTransactionApplier.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckoutAmountTransactionApplier.java
@@ -12,6 +12,8 @@
 import tech.ebp.oqm.core.api.model.object.storage.items.InventoryItem;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.AmountStored;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.Stored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredInBlock;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredStateType;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.TransactionType;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.checkin.CheckinPartTransaction;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.checkout.CheckoutAmountTransaction;
@@ -66,7 +68,12 @@ public void apply(
 		if (!inventoryItem.getId().equals(stored.getItem())) {
 			throw new IllegalArgumentException("Stored is not associated with the item.");
 		}
-		if (transaction.getFromBlock() != null && !stored.getStorageBlock().equals(transaction.getFromBlock())) {
+		
+		if(!stored.isState(StoredStateType.STORED)){
+			throw new IllegalArgumentException("Cannot subtract stored that is not stored in a block.");
+		}
+		
+		if (transaction.getFromBlock() != null && !((StoredInBlock)stored.getState()).getStorageBlock().equals(transaction.getFromBlock())) {
 			throw new IllegalArgumentException("From Storage block given mismatched stored's block.");
 		}
 		
@@ -91,7 +98,7 @@ public void apply(
 															.item(inventoryItem.getId())
 															.checkoutDetails(transaction.getCheckoutDetails())
 															.fromStored(stored.getId())
-															.fromBlock(stored.getStorageBlock())
+															.fromBlock(((StoredInBlock)stored.getState()).getStorageBlock())
 															.checkedOut(amount)
 															.checkOutTransaction(appliedTransactionId);
 		
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/SetAmountTransactionApplier.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/SetAmountTransactionApplier.java
index 3f1f2b898..8df4c6b23 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/SetAmountTransactionApplier.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/SetAmountTransactionApplier.java
@@ -8,6 +8,8 @@
 import tech.ebp.oqm.core.api.model.object.storage.items.InventoryItem;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.AmountStored;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.Stored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredInBlock;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredStateType;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.TransactionType;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.set.SetAmountTransaction;
 import tech.ebp.oqm.core.api.service.mongo.StoredService;
@@ -18,12 +20,12 @@
 
 @ApplicationScoped
 public class SetAmountTransactionApplier extends TransactionApplier<SetAmountTransaction> {
-
+	
 	@Override
 	public TransactionType getTransactionType() {
 		return TransactionType.SET_AMOUNT;
 	}
-
+	
 	@Override
 	public void apply(
 		String oqmDbIdOrName,
@@ -41,12 +43,12 @@ public void apply(
 				if (transaction.getBlock() != null) {
 					try {
 						stored = this.getStoredService().getSingleStoredForItemBlock(oqmDbIdOrName, cs, inventoryItem.getId(), transaction.getBlock(), AmountStored.class);
-					} catch (DbNotFoundException e) {
+					} catch(DbNotFoundException e) {
 						stored = AmountStored.builder()
-							.item(inventoryItem.getId())
-							.storageBlock(transaction.getBlock())
-							.amount(Quantities.getQuantity(0, inventoryItem.getUnit()))
-							.build();
+									 .item(inventoryItem.getId())
+									 .state(StoredInBlock.builder().storageBlock(transaction.getBlock()).build())
+									 .amount(Quantities.getQuantity(0, inventoryItem.getUnit()))
+									 .build();
 						this.getStoredService().add(oqmDbIdOrName, cs, stored, interactingEntity);
 					}
 					if (transaction.getStored() != null) {
@@ -65,7 +67,12 @@ public void apply(
 					throw new IllegalArgumentException("Must specify a stored to set the amount of.");
 				} else {
 					stored = (AmountStored) this.getStoredService().get(oqmDbIdOrName, cs, transaction.getStored());
-					if (transaction.getBlock() != null && !stored.getStorageBlock().equals(transaction.getBlock())) {
+					
+					if(!stored.isState(StoredStateType.STORED)){
+						throw new IllegalArgumentException("Cannot subtract stored that is not stored in a block.");
+					}
+					
+					if (transaction.getBlock() != null && !((StoredInBlock)stored.getState()).getStorageBlock().equals(transaction.getBlock())) {
 						throw new IllegalArgumentException("To Stored given does not exist in block.");
 					}
 				}
@@ -74,13 +81,13 @@ public void apply(
 				throw new IllegalArgumentException("Cannot add an amount to a unique item.");
 			}
 		}
-
+		
 		if (!inventoryItem.getId().equals(stored.getItem())) {
 			throw new IllegalArgumentException("Stored is not associated with the item.");
 		}
-
+		
 		stored.setAmount(transaction.getAmount());
-
+		
 		affectedStored.add(stored);
 		this.getStoredService().update(oqmDbIdOrName, cs, stored, interactingEntity, historyDetails);
 	}
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/SubtractAmountTransactionApplier.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/SubtractAmountTransactionApplier.java
index 3de5b5d35..0697890b7 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/SubtractAmountTransactionApplier.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/SubtractAmountTransactionApplier.java
@@ -8,6 +8,8 @@
 import tech.ebp.oqm.core.api.model.object.storage.items.InventoryItem;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.AmountStored;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.Stored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredInBlock;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredStateType;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.TransactionType;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.subtract.SubAmountTransaction;
 import tech.ebp.oqm.core.api.service.mongo.StoredService;
@@ -61,11 +63,15 @@ public void apply(
 		if (!inventoryItem.getId().equals(stored.getItem())) {
 			throw new IllegalArgumentException("Stored is not associated with the item.");
 		}
+		
+		if(!stored.isState(StoredStateType.STORED)){
+			throw new IllegalArgumentException("Cannot subtract stored that is not stored in a block.");
+		}
 
 		if (transaction.getFromStored() != null && !stored.getId().equals(transaction.getFromStored())) {
 			throw new IllegalArgumentException("Stored id in transaction not the id of stored found.");
 		}
-		if (transaction.getFromBlock() != null && !stored.getStorageBlock().equals(transaction.getFromBlock())) {
+		if (transaction.getFromBlock() != null && !((StoredInBlock)stored.getState()).getStorageBlock().equals(transaction.getFromBlock())) {
 			throw new IllegalArgumentException("Stored retrieved not in specified block.");
 		}
 		if(
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/TransferAmountTransactionApplier.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/TransferAmountTransactionApplier.java
index 0200f6e50..866e3bfcf 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/TransferAmountTransactionApplier.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/TransferAmountTransactionApplier.java
@@ -8,6 +8,7 @@
 import tech.ebp.oqm.core.api.model.object.storage.items.InventoryItem;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.AmountStored;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.Stored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredInBlock;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.TransactionType;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.transfer.TransferAmountTransaction;
 import tech.ebp.oqm.core.api.service.mongo.StoredService;
@@ -47,7 +48,7 @@ public void apply(
 				} catch(DbNotFoundException e) {
 					toStored = AmountStored.builder()
 								   .item(inventoryItem.getId())
-								   .storageBlock(transaction.getToBlock())
+								   .state(StoredInBlock.builder().storageBlock(transaction.getToBlock()).build())
 								   .amount(Quantities.getQuantity(0, inventoryItem.getUnit()))
 								   .build();
 					this.getStoredService().add(oqmDbIdOrName, cs, toStored, interactingEntity, historyDetails);
@@ -58,7 +59,7 @@ public void apply(
 				if (transaction.getToStored() == null) {
 					toStored = AmountStored.builder()
 								   .item(inventoryItem.getId())
-								   .storageBlock(transaction.getToBlock())
+								   .state(StoredInBlock.builder().storageBlock(transaction.getToBlock()).build())
 								   .amount(Quantities.getQuantity(0, inventoryItem.getUnit()))
 								   .build();
 					this.getStoredService().add(oqmDbIdOrName, cs, toStored, interactingEntity);
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/TransferWholeTransactionApplier.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/TransferWholeTransactionApplier.java
index 7df795978..1e7cf9802 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/TransferWholeTransactionApplier.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/TransferWholeTransactionApplier.java
@@ -7,6 +7,8 @@
 import tech.ebp.oqm.core.api.model.object.interactingEntity.InteractingEntity;
 import tech.ebp.oqm.core.api.model.object.storage.items.InventoryItem;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.Stored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredInBlock;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredStateType;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.TransactionType;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.transfer.TransferWholeTransaction;
 import tech.ebp.oqm.core.api.service.mongo.StoredService;
@@ -32,12 +34,15 @@ public void apply(
 		HistoryDetail[] historyDetails,
 		ClientSession cs
 	) {
-		
 		Stored toTransfer;
 		switch (inventoryItem.getStorageType()) {
 			case BULK, UNIQUE_SINGLE -> {
 				toTransfer = this.getStoredService().getSingleStoredForItemBlock(oqmDbIdOrName, cs, inventoryItem.getId(), transaction.getFromBlock(), Stored.class);
 				
+				if(!toTransfer.isState(StoredStateType.STORED)){
+					throw new IllegalArgumentException("Cannot transfer whole stored that not stored.");
+				}
+				
 				if(transaction.getStoredToTransfer() != null && !toTransfer.getId().equals(transaction.getStoredToTransfer())) {
 					throw new IllegalArgumentException("Stored item from block does not match stored specified.");
 				}
@@ -45,7 +50,11 @@ public void apply(
 			case AMOUNT_LIST, UNIQUE_MULTI -> {
 				toTransfer = this.getStoredService().get(oqmDbIdOrName, cs, transaction.getStoredToTransfer());
 				
-				if(transaction.getFromBlock() != null && !toTransfer.getStorageBlock().equals(transaction.getFromBlock())) {
+				if(!toTransfer.isState(StoredStateType.STORED)){
+					throw new IllegalArgumentException("Cannot transfer whole stored that not stored.");
+				}
+				
+				if(transaction.getFromBlock() != null && !((StoredInBlock)toTransfer.getState()).getStorageBlock().equals(transaction.getFromBlock())) {
 					throw new IllegalArgumentException("Stored item specified does not match stored from storage block.");
 				}
 			}
@@ -56,8 +65,12 @@ public void apply(
 		if (!inventoryItem.getId().equals(toTransfer.getItem())) {
 			throw new IllegalArgumentException("Stored is not associated with the item.");
 		}
-
-		toTransfer.setStorageBlock(transaction.getToBlock());
+		
+		if(!toTransfer.isState(StoredStateType.STORED)){
+			throw new IllegalArgumentException("Cannot transfer whole stored that not stored.");
+		}
+		
+		toTransfer.setState(StoredInBlock.builder().storageBlock(transaction.getToBlock()).build());
 
 		affectedStored.add(toTransfer);
 		this.getStoredService().update(oqmDbIdOrName, cs, toTransfer, interactingEntity, historyDetails);

From 6d8f32c8b71416f91e68f163afaa9951e6754deb Mon Sep 17 00:00:00 2001
From: axgiri <146159445+axgiri@users.noreply.github.com>
Date: Mon, 18 May 2026 13:50:22 +0200
Subject: [PATCH 25/48] move ensureItemMutexesExist call after db init

---
 .../main/java/tech/ebp/oqm/core/api/scheduled/MongoDbInit.java  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/scheduled/MongoDbInit.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/scheduled/MongoDbInit.java
index 2b7511dae..3579e27e6 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/scheduled/MongoDbInit.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/scheduled/MongoDbInit.java
@@ -59,7 +59,6 @@ void onStart(
         @Observes
         StartupEvent ev
     ) {
-        this.ensureItemMutexesExist();
         this.initDb();
     }
 
@@ -67,5 +66,6 @@ void initDb() {
         for(MongoService<?, ?, ?> service : this.mongoServices){
             service.initDb();
         }
+        this.ensureItemMutexesExist();
     }
 }

From 4ebe0f033612e87267e58c83bc8116b6bb3d373f Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Mon, 18 May 2026 20:46:32 -0400
Subject: [PATCH 26/48] Core - API - Fixed tests related to stored state rework

---
 .../items/InventoryItemsCrudTest.java         |  28 +-
 .../items/InventoryItemsStatsTest.java        |   6 +-
 .../items/StoredInItemEndpointsTest.java      |   6 +-
 .../storage/items/stored/StoredTest.java      |   5 +-
 .../api/service/mongo/StoredServiceTest.java  | 487 +++++++++---------
 .../AddAmountAppliedTransactionTest.java      |   7 +-
 .../AddWholeAppliedTransactionTest.java       |  21 +-
 ...eckinFullAmountAppliedTransactionTest.java |  11 +-
 .../CheckinWholeAppliedTransactionTest.java   |   7 +-
 .../CheckoutAmountAppliedTransactionTest.java |  23 +-
 .../CheckoutWholeAppliedTransactionTest.java  |   9 +-
 .../SetAmountAppliedTransactionTest.java      |   7 +-
 .../SubtractAmountAppliedTransactionTest.java |  33 +-
 .../TransferAmountAppliedTransactionTest.java |  33 +-
 .../TransferWholeAppliedTransactionTest.java  |   9 +-
 .../data/StoredTestObjectCreator.java         |   3 +-
 16 files changed, 370 insertions(+), 325 deletions(-)

diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/InventoryItemsCrudTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/InventoryItemsCrudTest.java
index 1f299f5cc..247cb50d1 100644
--- a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/InventoryItemsCrudTest.java
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/InventoryItemsCrudTest.java
@@ -29,6 +29,7 @@
 
 import jakarta.inject.Inject;
 
+import java.net.SocketTimeoutException;
 import java.time.Duration;
 import java.time.LocalDateTime;
 import java.time.temporal.ChronoUnit;
@@ -253,17 +254,24 @@ public Void call() {
 					
 					
 					try {
-					//initial update
-					ValidatableResponse response = setupJwtCall(given(), testUser.getAttributes().get(TestUserService.TEST_JWT_ATT_KEY))
-													   .when()
-													   .body(updates)
-													   .contentType(ContentType.JSON)
-													   .accept(ContentType.JSON)
-													   .pathParam("oqmDbIdOrName", DEFAULT_TEST_DB_NAME)
-													   .put(this.inventoryItemId)
-													   .then()
-													   .statusCode(200);
+						//initial update
+						ValidatableResponse response = setupJwtCall(given(), testUser.getAttributes().get(TestUserService.TEST_JWT_ATT_KEY))
+														   .when()
+														   .body(updates)
+														   .contentType(ContentType.JSON)
+														   .accept(ContentType.JSON)
+														   .pathParam("oqmDbIdOrName", DEFAULT_TEST_DB_NAME)
+														   .put(this.inventoryItemId)
+														   .then()
+														   .statusCode(200);
 					} catch (Throwable e) {
+						if(e instanceof SocketTimeoutException) {//somehow not able to be in its own catch
+							//not an issue, typically... only seems to happen in extreme cases.
+							log.warn("Socket timeout on iteration {}", i);
+							i--;
+							continue;
+						}
+						
 						log.error("Error in thread {} on iteration {}", this.threadId, i, e);
 						throw new RuntimeException("Error thrown in thread " + this.threadId + " on iteration " + i, e);
 					}
diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/InventoryItemsStatsTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/InventoryItemsStatsTest.java
index a6487967a..5d5329267 100644
--- a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/InventoryItemsStatsTest.java
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/InventoryItemsStatsTest.java
@@ -8,6 +8,7 @@
 import io.restassured.response.ValidatableResponse;
 import jakarta.inject.Inject;
 import lombok.extern.slf4j.Slf4j;
+import org.bson.types.ObjectId;
 import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Test;
 import tech.ebp.oqm.core.api.model.object.interactingEntity.user.User;
@@ -17,6 +18,7 @@
 import tech.ebp.oqm.core.api.model.object.storage.items.pricing.TotalPricing;
 import tech.ebp.oqm.core.api.model.object.storage.items.pricing.unit.PricePerUnit;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.AmountStored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredInBlock;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.stats.ItemStoredStats;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.stats.StoredInBlockStats;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.AppliedTransaction;
@@ -125,7 +127,7 @@ public void testItemStatsWithStored() throws JsonProcessingException {
 		AmountStored stored = AmountStored.builder()
 								  .amount(UnitUtils.Quantities.UNIT_ONE)
 								  .item(item.getId())
-								  .storageBlock(block.getId())
+								  .state(StoredInBlock.builder().storageBlock(block.getId()).build())
 								  .build();
 		
 		AppliedTransaction transaction =
@@ -221,7 +223,7 @@ public void testPricingTotals() throws JsonProcessingException {
 		AmountStored stored = AmountStored.builder()
 								  .amount(UnitUtils.Quantities.UNIT_ONE)
 								  .item(item.getId())
-								  .storageBlock(block.getId())
+								  .state(StoredInBlock.builder().storageBlock(block.getId()).build())
 								  .prices(new LinkedHashSet<>() {{
 									  add(StoredPricing.builder()
 											  .label("fromStoredFlat")
diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/StoredInItemEndpointsTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/StoredInItemEndpointsTest.java
index 623f6990f..ec1835d2c 100644
--- a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/StoredInItemEndpointsTest.java
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/interfaces/endpoints/inventory/items/StoredInItemEndpointsTest.java
@@ -11,6 +11,7 @@
 import io.restassured.response.ValidatableResponse;
 import jakarta.inject.Inject;
 import lombok.extern.slf4j.Slf4j;
+import org.bson.types.ObjectId;
 import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Test;
 import tech.ebp.oqm.core.api.model.object.interactingEntity.user.User;
@@ -19,6 +20,7 @@
 import tech.ebp.oqm.core.api.model.object.storage.items.pricing.StoredPricing;
 import tech.ebp.oqm.core.api.model.object.storage.items.pricing.unit.PricePerUnit;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.AmountStored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredInBlock;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.AppliedTransaction;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.add.AddWholeTransaction;
 import tech.ebp.oqm.core.api.model.object.storage.storageBlock.StorageBlock;
@@ -135,7 +137,7 @@ public void testSearchSimple() throws JsonProcessingException {
 		AmountStored stored = AmountStored.builder()
 								  .amount(UnitUtils.Quantities.UNIT_ONE)
 								  .item(item.getId())
-								  .storageBlock(block.getId())
+								  .state(StoredInBlock.builder().storageBlock(block.getId()).build())
 								  .prices(new LinkedHashSet<>() {{
 									  add(StoredPricing.builder()
 											  .label("fromStoredFlat")
@@ -258,7 +260,7 @@ public void testGetSimple() throws JsonProcessingException {
 		AmountStored stored = AmountStored.builder()
 								  .amount(UnitUtils.Quantities.UNIT_ONE)
 								  .item(item.getId())
-								  .storageBlock(block.getId())
+								  .state(StoredInBlock.builder().storageBlock(block.getId()).build())
 								  .prices(new LinkedHashSet<>() {{
 									  add(StoredPricing.builder()
 											  .label("fromStoredFlat")
diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/StoredTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/StoredTest.java
index 1612ab0d7..825043757 100644
--- a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/StoredTest.java
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/StoredTest.java
@@ -8,6 +8,7 @@
 import tech.ebp.oqm.core.api.model.object.storage.items.identifiers.Identifier;
 import tech.ebp.oqm.core.api.model.object.storage.items.identifiers.types.GenericIdentifier;
 import tech.ebp.oqm.core.api.model.object.storage.items.pricing.CalculatedPricing;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredInBlock;
 import tech.ebp.oqm.core.api.model.testUtils.BasicTest;
 import tech.ebp.oqm.core.api.model.units.UnitUtils;
 
@@ -49,7 +50,7 @@ public static Stream<Arguments> getParseLabelTests(){
 		AmountStored fullAmountStored = AmountStored.builder()
 											.id(ObjectId.get())
 											.item(ObjectId.get())
-											.storageBlock(ObjectId.get())
+											.state(StoredInBlock.builder().storageBlock(ObjectId.get()).build())
 											.amount(UnitUtils.Quantities.UNIT_ONE)
 											.identifiers(identifiers)
 											.calculatedPrices(pricingSet)
@@ -60,7 +61,7 @@ public static Stream<Arguments> getParseLabelTests(){
 		UniqueStored fullUniqueStored = UniqueStored.builder()
 											.id(ObjectId.get())
 											.item(ObjectId.get())
-											.storageBlock(ObjectId.get())
+											.state(StoredInBlock.builder().storageBlock(ObjectId.get()).build())
 											.identifiers(identifiers)
 											.build();
 		
diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/StoredServiceTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/StoredServiceTest.java
index 714fc1ad0..c3774c5bb 100644
--- a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/StoredServiceTest.java
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/StoredServiceTest.java
@@ -12,6 +12,7 @@
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.AmountStored;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.Stored;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.UniqueStored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredInBlock;
 import tech.ebp.oqm.core.api.model.object.storage.storageBlock.StorageBlock;
 import tech.ebp.oqm.core.api.model.rest.search.StoredSearch;
 import tech.ebp.oqm.core.api.model.units.OqmProvidedUnits;
@@ -30,60 +31,60 @@
 @Slf4j
 @QuarkusTest
 class StoredServiceTest extends MongoHistoriedServiceTest<Stored, StoredService> {
-
+	
 	@Inject
 	InventoryItemService inventoryItemService;
 	@Inject
 	StorageBlockService storageBlockService;
-
+	
 	@Inject
 	InventoryItemTestObjectCreator itemTestObjectCreator;
 	@Inject
 	StoredTestObjectCreator storedTestObjectCreator;
-
+	
 	@Inject
 	StoredService storedService;
-
+	
 	@Override
 	protected Stored getTestObject() {
 		return storedTestObjectCreator.getTestObject();
 	}
-
-//	@Test
-//	public void injectTest() {
-//		assertNotNull(inventoryItemService);
-//	}
-//
-//	@Test
-//	public void listTest() {
-//		this.defaultListTest(this.inventoryItemService);
-//	}
-//
-//	@Test
-//	public void countTest() {
-//		this.defaultCountTest(this.inventoryItemService);
-//	}
-//
-//	@Test
-//	public void addTest() {
-//		this.defaultAddTest(this.inventoryItemService);
-//	}
-//
-//	@Test
-//	public void getObjectIdTest() {
-//		this.defaultGetObjectIdTest(this.inventoryItemService);
-//	}
-//
-//	@Test
-//	public void getStringTest() {
-//		this.defaultGetStringTest(this.inventoryItemService);
-//	}
-//
-//	@Test
-//	public void removeAllTest() {
-//		this.defaultRemoveAllTest(this.inventoryItemService);
-//	}
-
+	
+	//	@Test
+	//	public void injectTest() {
+	//		assertNotNull(inventoryItemService);
+	//	}
+	//
+	//	@Test
+	//	public void listTest() {
+	//		this.defaultListTest(this.inventoryItemService);
+	//	}
+	//
+	//	@Test
+	//	public void countTest() {
+	//		this.defaultCountTest(this.inventoryItemService);
+	//	}
+	//
+	//	@Test
+	//	public void addTest() {
+	//		this.defaultAddTest(this.inventoryItemService);
+	//	}
+	//
+	//	@Test
+	//	public void getObjectIdTest() {
+	//		this.defaultGetObjectIdTest(this.inventoryItemService);
+	//	}
+	//
+	//	@Test
+	//	public void getStringTest() {
+	//		this.defaultGetStringTest(this.inventoryItemService);
+	//	}
+	//
+	//	@Test
+	//	public void removeAllTest() {
+	//		this.defaultRemoveAllTest(this.inventoryItemService);
+	//	}
+	
 	@Test
 	public void addTest() {
 		User user = this.getTestUserService().getTestUser();
@@ -95,19 +96,19 @@ public void addTest() {
 		InventoryItem item = this.itemTestObjectCreator.getTestObject();
 		item.setStorageType(StorageType.BULK).setStorageBlocks(new LinkedHashSet<>(List.of(blockId)));
 		this.inventoryItemService.add(DEFAULT_TEST_DB_NAME, item, user);
-
+		
 		Stored stored = this.storedTestObjectCreator.setItem(item).setStorageBlock(blockId).getTestObject();
-
+		
 		ObjectId storedId = this.storedService.add(
 			DEFAULT_TEST_DB_NAME,
 			stored,
 			user
 		).getId();
-
+		
 		assertNotNull(storedId);
 		assertEquals(stored, this.storedService.get(DEFAULT_TEST_DB_NAME, storedId));
 	}
-
+	
 	@Test
 	public void addInvalidItemTest() {
 		User user = this.getTestUserService().getTestUser();
@@ -119,17 +120,19 @@ public void addInvalidItemTest() {
 		InventoryItem item = this.itemTestObjectCreator.getTestObject();
 		item.setStorageType(StorageType.BULK).setStorageBlocks(new LinkedHashSet<>(List.of(blockId)));
 		this.inventoryItemService.add(DEFAULT_TEST_DB_NAME, item, user);
-
+		
 		Stored stored = this.storedTestObjectCreator.setItem(item).setStorageBlock(blockId).getTestObject();
 		stored.setItem(new ObjectId());
-
-		Exception exception = assertThrows(ValidationException.class, () -> this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			stored,
-			user
-		));
+		
+		Exception exception = assertThrows(
+			ValidationException.class, ()->this.storedService.add(
+				DEFAULT_TEST_DB_NAME,
+				stored,
+				user
+			)
+		);
 	}
-
+	
 	@Test
 	public void addInvalidNonExistentStorageBlockTest() {
 		User user = this.getTestUserService().getTestUser();
@@ -141,17 +144,19 @@ public void addInvalidNonExistentStorageBlockTest() {
 		InventoryItem item = this.itemTestObjectCreator.getTestObject();
 		item.setStorageType(StorageType.BULK).setStorageBlocks(new LinkedHashSet<>(List.of(blockId)));
 		this.inventoryItemService.add(DEFAULT_TEST_DB_NAME, item, user);
-
+		
 		Stored stored = this.storedTestObjectCreator.setItem(item).setStorageBlock(blockId).getTestObject();
-		stored.setStorageBlock(new ObjectId());
-
-		Exception exception = assertThrows(ValidationException.class, () -> this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			stored,
-			user
-		));
+		stored.setState(StoredInBlock.builder().storageBlock(ObjectId.get()).build());
+		
+		Exception exception = assertThrows(
+			ValidationException.class, ()->this.storedService.add(
+				DEFAULT_TEST_DB_NAME,
+				stored,
+				user
+			)
+		);
 	}
-
+	
 	@Test
 	public void addInvalidStorageBlockNotInItemTest() {
 		User user = this.getTestUserService().getTestUser();
@@ -163,21 +168,27 @@ public void addInvalidStorageBlockNotInItemTest() {
 		InventoryItem item = this.itemTestObjectCreator.getTestObject();
 		item.setStorageType(StorageType.BULK).setStorageBlocks(new LinkedHashSet<>(List.of(blockId)));
 		this.inventoryItemService.add(DEFAULT_TEST_DB_NAME, item, user);
-
+		
 		Stored stored = this.storedTestObjectCreator.setItem(item).setStorageBlock(blockId).getTestObject();
-		stored.setStorageBlock(this.storageBlockService.add(
-			DEFAULT_TEST_DB_NAME,
-			new StorageBlock().setLabel(FAKER.location().building() + "-2"),
-			user
-		).getId());
-
-		Exception exception = assertThrows(ValidationException.class, () -> this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			stored,
-			user
-		));
+		stored.setState(
+			StoredInBlock.builder().storageBlock(
+				this.storageBlockService.add(
+					DEFAULT_TEST_DB_NAME,
+					new StorageBlock().setLabel(FAKER.location().building() + "-2"),
+					user
+				).getId()
+			).build()
+		);
+		
+		Exception exception = assertThrows(
+			ValidationException.class, ()->this.storedService.add(
+				DEFAULT_TEST_DB_NAME,
+				stored,
+				user
+			)
+		);
 	}
-
+	
 	@Test
 	public void addInvalidTypeTest() {
 		User user = this.getTestUserService().getTestUser();
@@ -189,16 +200,18 @@ public void addInvalidTypeTest() {
 		InventoryItem item = this.itemTestObjectCreator.getTestObject();
 		item.setStorageType(StorageType.BULK).setStorageBlocks(new LinkedHashSet<>(List.of(blockId)));
 		ObjectId itemId = this.inventoryItemService.add(DEFAULT_TEST_DB_NAME, item, user).getId();
-
-		Stored stored = UniqueStored.builder().item(itemId).storageBlock(blockId).build();
-
-		Exception exception = assertThrows(ValidationException.class, () -> this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			stored,
-			user
-		));
+		
+		Stored stored = UniqueStored.builder().item(itemId).state(StoredInBlock.builder().storageBlock(blockId).build()).build();
+		
+		Exception exception = assertThrows(
+			ValidationException.class, ()->this.storedService.add(
+				DEFAULT_TEST_DB_NAME,
+				stored,
+				user
+			)
+		);
 	}
-
+	
 	@Test
 	public void addInvalidUnitTest() {
 		User user = this.getTestUserService().getTestUser();
@@ -210,17 +223,19 @@ public void addInvalidUnitTest() {
 		InventoryItem item = this.itemTestObjectCreator.getTestObject();
 		item.setStorageType(StorageType.BULK).setStorageBlocks(new LinkedHashSet<>(List.of(blockId)));
 		this.inventoryItemService.add(DEFAULT_TEST_DB_NAME, item, user);
-
+		
 		Stored stored = this.storedTestObjectCreator.setItem(item).setStorageBlock(blockId).getTestObject();
-		((AmountStored)stored).setAmount(Quantities.getQuantity(0, OqmProvidedUnits.WATT_HOURS));
-
-		Exception exception = assertThrows(ValidationException.class, () -> this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			stored,
-			user
-		));
+		((AmountStored) stored).setAmount(Quantities.getQuantity(0, OqmProvidedUnits.WATT_HOURS));
+		
+		Exception exception = assertThrows(
+			ValidationException.class, ()->this.storedService.add(
+				DEFAULT_TEST_DB_NAME,
+				stored,
+				user
+			)
+		);
 	}
-
+	
 	@Test
 	public void addInvalidSecondBulkTest() {
 		User user = this.getTestUserService().getTestUser();
@@ -232,16 +247,18 @@ public void addInvalidSecondBulkTest() {
 		InventoryItem item = this.itemTestObjectCreator.getTestObject();
 		item.setStorageType(StorageType.BULK).setStorageBlocks(new LinkedHashSet<>(List.of(blockId)));
 		this.inventoryItemService.add(DEFAULT_TEST_DB_NAME, item, user);
-
+		
 		this.storedService.add(DEFAULT_TEST_DB_NAME, this.storedTestObjectCreator.setItem(item).setStorageBlock(blockId).getTestObject(), user);
-
-		Exception exception = assertThrows(ValidationException.class, () -> this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			this.storedTestObjectCreator.setItem(item).setStorageBlock(blockId).getTestObject(),
-			user
-		));
+		
+		Exception exception = assertThrows(
+			ValidationException.class, ()->this.storedService.add(
+				DEFAULT_TEST_DB_NAME,
+				this.storedTestObjectCreator.setItem(item).setStorageBlock(blockId).getTestObject(),
+				user
+			)
+		);
 	}
-
+	
 	@Test
 	public void addInvalidSecondUniqueSingleSameBlockTest() {
 		User user = this.getTestUserService().getTestUser();
@@ -253,16 +270,18 @@ public void addInvalidSecondUniqueSingleSameBlockTest() {
 		InventoryItem item = this.itemTestObjectCreator.getTestObject();
 		item.setStorageType(StorageType.UNIQUE_SINGLE).setStorageBlocks(new LinkedHashSet<>(List.of(blockId)));
 		this.inventoryItemService.add(DEFAULT_TEST_DB_NAME, item, user);
-
+		
 		this.storedService.add(DEFAULT_TEST_DB_NAME, this.storedTestObjectCreator.setItem(item).setStorageBlock(blockId).getTestObject(), user);
-
-		Exception exception = assertThrows(ValidationException.class, () -> this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			this.storedTestObjectCreator.setItem(item).setStorageBlock(blockId).getTestObject(),
-			user
-		));
+		
+		Exception exception = assertThrows(
+			ValidationException.class, ()->this.storedService.add(
+				DEFAULT_TEST_DB_NAME,
+				this.storedTestObjectCreator.setItem(item).setStorageBlock(blockId).getTestObject(),
+				user
+			)
+		);
 	}
-
+	
 	@Test
 	public void addInvalidSecondUniqueSingleDifferentBlockTest() {
 		User user = this.getTestUserService().getTestUser();
@@ -279,17 +298,19 @@ public void addInvalidSecondUniqueSingleDifferentBlockTest() {
 		InventoryItem item = this.itemTestObjectCreator.getTestObject();
 		item.setStorageType(StorageType.UNIQUE_SINGLE).setStorageBlocks(new LinkedHashSet<>(List.of(blockIdOne)));
 		this.inventoryItemService.add(DEFAULT_TEST_DB_NAME, item, user);
-
+		
 		this.storedService.add(DEFAULT_TEST_DB_NAME, this.storedTestObjectCreator.setItem(item).setStorageBlock(blockIdOne).getTestObject(), user);
-
-		Exception exception = assertThrows(ValidationException.class, () -> this.storedService.add(
-			DEFAULT_TEST_DB_NAME,
-			this.storedTestObjectCreator.setItem(item).setStorageBlock(blockIdTwo).getTestObject(),
-			user
-		));
+		
+		Exception exception = assertThrows(
+			ValidationException.class, ()->this.storedService.add(
+				DEFAULT_TEST_DB_NAME,
+				this.storedTestObjectCreator.setItem(item).setStorageBlock(blockIdTwo).getTestObject(),
+				user
+			)
+		);
 	}
-
-
+	
+	
 	@Test
 	public void searchInStorageBlockTest() {
 		User user = this.getTestUserService().getTestUser();
@@ -306,137 +327,137 @@ public void searchInStorageBlockTest() {
 		InventoryItem item = this.itemTestObjectCreator.getTestObject();
 		item.setStorageType(StorageType.BULK).setStorageBlocks(new LinkedHashSet<>(List.of(blockId, otherBlockId)));
 		this.inventoryItemService.add(DEFAULT_TEST_DB_NAME, item, user);
-
+		
 		Stored stored = this.storedTestObjectCreator.setItem(item).setStorageBlock(blockId).getTestObject();
 		Stored otherStored = this.storedTestObjectCreator.setItem(item).setStorageBlock(otherBlockId).getTestObject();
-
+		
 		this.storedService.add(DEFAULT_TEST_DB_NAME, stored, user);
 		this.storedService.add(DEFAULT_TEST_DB_NAME, otherStored, user);
-
+		
 		SearchResult<Stored> result = this.storedService.search(DEFAULT_TEST_DB_NAME, new StoredSearch().setInStorageBlocks(List.of(blockId)));
-
+		
 		assertEquals(1, result.getNumResults());
 		assertEquals(stored, result.getResults().get(0));
 	}
-
+	
 	//TODO:: update
 	//TODO:: invalid update; amount, item, storage block
 	//TODO:: delete
-
+	
 	//TODO:: tests with images, file?
-
-
+	
+	
 	//TODO:: rework
-//	@Test
-//	public void testAddSimpleAmountItem(){
-//		SimpleAmountItem item = (SimpleAmountItem) new SimpleAmountItem().setName(FAKER.commerce().productName());
-//		item.getStorageMap().put(ObjectId.get(), new SingleAmountStoredWrapper(new AmountStored(0, item.getUnit())));
-//
-//		ObjectId id = this.inventoryItemService.add(DEFAULT_TEST_DB_NAME, item, this.getTestUserService().getTestUser());
-//
-//		assertNotNull(item.getId());
-//		assertEquals(id, item.getId());
-//
-//		List<InventoryItem> list = inventoryItemService.list(DEFAULT_TEST_DB_NAME);
-//		log.info("num in collection: {}", list.size());
-//		assertEquals(1, list.size(), "Unexpected number of objects in collection.");
-//	}
-//
-//	@Test
-//	public void testAddListAmountItem(){
-//		ListAmountItem item = (ListAmountItem) new ListAmountItem().setName(FAKER.commerce().productName());
-//		item.add(ObjectId.get(), new AmountStored(0, item.getUnit()));
-//
-//		ObjectId id = this.inventoryItemService.add(DEFAULT_TEST_DB_NAME, item, this.getTestUserService().getTestUser());
-//
-//		assertNotNull(item.getId());
-//		assertEquals(id, item.getId());
-//
-//		List<InventoryItem> list = inventoryItemService.list(DEFAULT_TEST_DB_NAME);
-//		log.info("num in collection: {}", list.size());
-//		assertEquals(1, list.size(), "Unexpected number of objects in collection.");
-//	}
-//	@Test
-//	public void testAddTrackedItem(){
-//		TrackedItem item = (TrackedItem) new TrackedItem()
-//											 .setTrackedItemIdentifierName("id")
-//											 .setName(FAKER.commerce().productName());
-//		item.add(ObjectId.get(), new TrackedStored(FAKER.commerce().productName()));
-//
-//		ObjectId id = this.inventoryItemService.add(DEFAULT_TEST_DB_NAME, item, this.getTestUserService().getTestUser());
-//
-//		assertNotNull(item.getId());
-//		assertEquals(id, item.getId());
-//
-//		List<InventoryItem> list = inventoryItemService.list(DEFAULT_TEST_DB_NAME);
-//		log.info("num in collection: {}", list.size());
-//		assertEquals(1, list.size(), "Unexpected number of objects in collection.");
-//	}
-//
-//	@Test
-//	public void testUpdateSimpleAmountItemJson(){
-//		SimpleAmountItem item = (SimpleAmountItem) new SimpleAmountItem().setName(FAKER.commerce().productName());
-//		item.getStorageMap().put(ObjectId.get(), new SingleAmountStoredWrapper(new AmountStored(0, item.getUnit())));
-//		ObjectId id = this.inventoryItemService.add(DEFAULT_TEST_DB_NAME, item, this.getTestUserService().getTestUser());
-//
-//		ObjectNode update = ObjectUtils.OBJECT_MAPPER.valueToTree(item);
-//		String newName = item.getName() + " new";
-//
-//		update.put("name", newName);
-//
-//		SimpleAmountItem item2 = (SimpleAmountItem) this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, id, update);
-//
-//		assertEquals(newName, item2.getName());
-//	}
-//
-//	@Test
-//	public void testUpdateListAmountItemJson(){
-//		ListAmountItem item = (ListAmountItem) new ListAmountItem().setName(FAKER.commerce().productName());
-//		item.add(ObjectId.get(), new AmountStored(0, item.getUnit()));
-//		ObjectId id = this.inventoryItemService.add(DEFAULT_TEST_DB_NAME, item, this.getTestUserService().getTestUser());
-//
-//		ObjectNode update = ObjectUtils.OBJECT_MAPPER.valueToTree(item);
-//		String newName = item.getName() + " new";
-//
-//		update.put("name", newName);
-//
-//		ListAmountItem item2 = (ListAmountItem) this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, id, update);
-//
-//		assertEquals(newName, item2.getName());
-//	}
-//
-//	@Test
-//	public void testUpdateTrackedItemJson(){
-//		TrackedItem item = (TrackedItem) new TrackedItem()
-//											 .setTrackedItemIdentifierName("id")
-//											 .setName(FAKER.commerce().productName());
-//		item.add(ObjectId.get(), new TrackedStored(FAKER.commerce().productName()));
-//		ObjectId id = this.inventoryItemService.add(DEFAULT_TEST_DB_NAME, item, this.getTestUserService().getTestUser());
-//
-//		ObjectNode update = ObjectUtils.OBJECT_MAPPER.valueToTree(item);
-//		String newName = item.getName() + " new";
-//
-//		update.put("name", newName);
-//
-//		TrackedItem item2 = (TrackedItem) this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, id, update);
-//
-//		assertEquals(newName, item2.getName());
-//	}
-
-
+	//	@Test
+	//	public void testAddSimpleAmountItem(){
+	//		SimpleAmountItem item = (SimpleAmountItem) new SimpleAmountItem().setName(FAKER.commerce().productName());
+	//		item.getStorageMap().put(ObjectId.get(), new SingleAmountStoredWrapper(new AmountStored(0, item.getUnit())));
+	//
+	//		ObjectId id = this.inventoryItemService.add(DEFAULT_TEST_DB_NAME, item, this.getTestUserService().getTestUser());
+	//
+	//		assertNotNull(item.getId());
+	//		assertEquals(id, item.getId());
+	//
+	//		List<InventoryItem> list = inventoryItemService.list(DEFAULT_TEST_DB_NAME);
+	//		log.info("num in collection: {}", list.size());
+	//		assertEquals(1, list.size(), "Unexpected number of objects in collection.");
+	//	}
+	//
+	//	@Test
+	//	public void testAddListAmountItem(){
+	//		ListAmountItem item = (ListAmountItem) new ListAmountItem().setName(FAKER.commerce().productName());
+	//		item.add(ObjectId.get(), new AmountStored(0, item.getUnit()));
+	//
+	//		ObjectId id = this.inventoryItemService.add(DEFAULT_TEST_DB_NAME, item, this.getTestUserService().getTestUser());
+	//
+	//		assertNotNull(item.getId());
+	//		assertEquals(id, item.getId());
+	//
+	//		List<InventoryItem> list = inventoryItemService.list(DEFAULT_TEST_DB_NAME);
+	//		log.info("num in collection: {}", list.size());
+	//		assertEquals(1, list.size(), "Unexpected number of objects in collection.");
+	//	}
+	//	@Test
+	//	public void testAddTrackedItem(){
+	//		TrackedItem item = (TrackedItem) new TrackedItem()
+	//											 .setTrackedItemIdentifierName("id")
+	//											 .setName(FAKER.commerce().productName());
+	//		item.add(ObjectId.get(), new TrackedStored(FAKER.commerce().productName()));
+	//
+	//		ObjectId id = this.inventoryItemService.add(DEFAULT_TEST_DB_NAME, item, this.getTestUserService().getTestUser());
+	//
+	//		assertNotNull(item.getId());
+	//		assertEquals(id, item.getId());
+	//
+	//		List<InventoryItem> list = inventoryItemService.list(DEFAULT_TEST_DB_NAME);
+	//		log.info("num in collection: {}", list.size());
+	//		assertEquals(1, list.size(), "Unexpected number of objects in collection.");
+	//	}
+	//
+	//	@Test
+	//	public void testUpdateSimpleAmountItemJson(){
+	//		SimpleAmountItem item = (SimpleAmountItem) new SimpleAmountItem().setName(FAKER.commerce().productName());
+	//		item.getStorageMap().put(ObjectId.get(), new SingleAmountStoredWrapper(new AmountStored(0, item.getUnit())));
+	//		ObjectId id = this.inventoryItemService.add(DEFAULT_TEST_DB_NAME, item, this.getTestUserService().getTestUser());
+	//
+	//		ObjectNode update = ObjectUtils.OBJECT_MAPPER.valueToTree(item);
+	//		String newName = item.getName() + " new";
+	//
+	//		update.put("name", newName);
+	//
+	//		SimpleAmountItem item2 = (SimpleAmountItem) this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, id, update);
+	//
+	//		assertEquals(newName, item2.getName());
+	//	}
+	//
+	//	@Test
+	//	public void testUpdateListAmountItemJson(){
+	//		ListAmountItem item = (ListAmountItem) new ListAmountItem().setName(FAKER.commerce().productName());
+	//		item.add(ObjectId.get(), new AmountStored(0, item.getUnit()));
+	//		ObjectId id = this.inventoryItemService.add(DEFAULT_TEST_DB_NAME, item, this.getTestUserService().getTestUser());
+	//
+	//		ObjectNode update = ObjectUtils.OBJECT_MAPPER.valueToTree(item);
+	//		String newName = item.getName() + " new";
+	//
+	//		update.put("name", newName);
+	//
+	//		ListAmountItem item2 = (ListAmountItem) this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, id, update);
+	//
+	//		assertEquals(newName, item2.getName());
+	//	}
+	//
+	//	@Test
+	//	public void testUpdateTrackedItemJson(){
+	//		TrackedItem item = (TrackedItem) new TrackedItem()
+	//											 .setTrackedItemIdentifierName("id")
+	//											 .setName(FAKER.commerce().productName());
+	//		item.add(ObjectId.get(), new TrackedStored(FAKER.commerce().productName()));
+	//		ObjectId id = this.inventoryItemService.add(DEFAULT_TEST_DB_NAME, item, this.getTestUserService().getTestUser());
+	//
+	//		ObjectNode update = ObjectUtils.OBJECT_MAPPER.valueToTree(item);
+	//		String newName = item.getName() + " new";
+	//
+	//		update.put("name", newName);
+	//
+	//		TrackedItem item2 = (TrackedItem) this.inventoryItemService.update(DEFAULT_TEST_DB_NAME, id, update);
+	//
+	//		assertEquals(newName, item2.getName());
+	//	}
+	
+	
 	//TODO:: rework
-//	@Test
-//	public void testStoreItemWithNulledStorageBlockKey(){
-//		SimpleAmountItem item = (SimpleAmountItem) new SimpleAmountItem().setName(FAKER.commerce().productName());
-//		item.getStorageMap().put(new ObjectId(new byte[12]), new SingleAmountStoredWrapper(new AmountStored(0, item.getUnit())));
-//		ObjectId id = this.inventoryItemService.add(DEFAULT_TEST_DB_NAME, item, this.getTestUserService().getTestUser());
-//
-//		SimpleAmountItem returned = (SimpleAmountItem) this.inventoryItemService.get(DEFAULT_TEST_DB_NAME, id);
-//		assertEquals(item, returned);
-//	}
-
+	//	@Test
+	//	public void testStoreItemWithNulledStorageBlockKey(){
+	//		SimpleAmountItem item = (SimpleAmountItem) new SimpleAmountItem().setName(FAKER.commerce().productName());
+	//		item.getStorageMap().put(new ObjectId(new byte[12]), new SingleAmountStoredWrapper(new AmountStored(0, item.getUnit())));
+	//		ObjectId id = this.inventoryItemService.add(DEFAULT_TEST_DB_NAME, item, this.getTestUserService().getTestUser());
+	//
+	//		SimpleAmountItem returned = (SimpleAmountItem) this.inventoryItemService.get(DEFAULT_TEST_DB_NAME, id);
+	//		assertEquals(item, returned);
+	//	}
+	
 	//TODO:: test expiry related
-
+	
 	//    @Test
 	//    public void listTest(){
 	//
diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/AddAmountAppliedTransactionTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/AddAmountAppliedTransactionTest.java
index 87a642982..e771366c0 100644
--- a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/AddAmountAppliedTransactionTest.java
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/AddAmountAppliedTransactionTest.java
@@ -16,6 +16,7 @@
 import tech.ebp.oqm.core.api.model.object.storage.items.StorageType;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.AmountStored;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.Stored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredInBlock;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.AppliedTransaction;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.ItemStoredTransaction;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.add.AddAmountTransaction;
@@ -99,7 +100,7 @@ public void applyAddAmountSuccessBulkAlreadyInBlock() throws Exception {
 		
 		AmountStored originalStored = AmountStored.builder()
 										  .item(item.getId())
-										  .storageBlock(item.getStorageBlocks().getFirst())
+										  .state(StoredInBlock.builder().storageBlock(item.getStorageBlocks().getFirst()).build())
 										  .amount(Quantities.getQuantity(5, item.getUnit()))
 										  .build();
 		this.storedService.add(DEFAULT_TEST_DB_NAME, originalStored, entity);
@@ -184,7 +185,7 @@ public void applyAddAmountSuccessAmtListExistingStored() throws Exception {
 		
 		AmountStored originalStored = AmountStored.builder()
 										  .item(item.getId())
-										  .storageBlock(item.getStorageBlocks().getFirst())
+										  .state(StoredInBlock.builder().storageBlock(item.getStorageBlocks().getFirst()).build())
 										  .amount(Quantities.getQuantity(5, item.getUnit()))
 										  .build();
 		this.storedService.add(DEFAULT_TEST_DB_NAME, originalStored, entity);
@@ -320,7 +321,7 @@ public void applyAddAmountFailAmtListBadStoredNotInBlock() {
 		
 		AmountStored originalStored = AmountStored.builder()
 										  .item(item.getId())
-										  .storageBlock(origBlock)
+										  .state(StoredInBlock.builder().storageBlock(origBlock).build())
 										  .amount(Quantities.getQuantity(5, item.getUnit()))
 										  .build();
 		this.storedService.add(DEFAULT_TEST_DB_NAME, originalStored, entity);
diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/AddWholeAppliedTransactionTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/AddWholeAppliedTransactionTest.java
index 0dcf5125d..908cb01be 100644
--- a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/AddWholeAppliedTransactionTest.java
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/AddWholeAppliedTransactionTest.java
@@ -18,6 +18,7 @@
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.AmountStored;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.Stored;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.UniqueStored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredInBlock;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.AppliedTransaction;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.ItemStoredTransaction;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.add.AddAmountTransaction;
@@ -52,7 +53,7 @@ public void applyAddWholeSuccessAmtList() throws Exception {
 															AmountStored.builder()
 																.item(item.getId())
 																.amount(Quantities.getQuantity(5, item.getUnit()))
-																.storageBlock(item.getStorageBlocks().getFirst())
+																.state(StoredInBlock.builder().storageBlock(item.getStorageBlocks().getFirst()).build())
 																.build()
 														)
 														.toBlock(item.getStorageBlocks().getFirst())
@@ -95,7 +96,7 @@ public void applyAddWholeSuccessUniqueMulti() throws Exception {
 														.toAdd(
 															UniqueStored.builder()
 																.item(item.getId())
-																.storageBlock(item.getStorageBlocks().getFirst())
+																.state(StoredInBlock.builder().storageBlock(item.getStorageBlocks().getFirst()).build())
 																.build()
 														)
 														.toBlock(item.getStorageBlocks().getFirst())
@@ -137,7 +138,7 @@ public void applyAddWholeSuccessUniqueSingle() throws Exception {
 														.toAdd(
 															UniqueStored.builder()
 																.item(item.getId())
-																.storageBlock(item.getStorageBlocks().getFirst())
+																.state(StoredInBlock.builder().storageBlock(item.getStorageBlocks().getFirst()).build())
 																.build()
 														)
 														.toBlock(item.getStorageBlocks().getFirst())
@@ -180,7 +181,7 @@ public void applyAddWholeFailBulk() {
 															AmountStored.builder()
 																.item(item.getId())
 																.amount(Quantities.getQuantity(5, item.getUnit()))
-																.storageBlock(item.getStorageBlocks().getFirst())
+																.state(StoredInBlock.builder().storageBlock(item.getStorageBlocks().getFirst()).build())
 																.build()
 														)
 														.toBlock(item.getStorageBlocks().getFirst())
@@ -201,7 +202,7 @@ public void applyAddWholeFailAnotherUniqueSingle() throws Exception {
 														.toAdd(
 															UniqueStored.builder()
 																.item(item.getId())
-																.storageBlock(item.getStorageBlocks().getFirst())
+																.state(StoredInBlock.builder().storageBlock(item.getStorageBlocks().getFirst()).build())
 																.build()
 														)
 														.toBlock(item.getStorageBlocks().getFirst())
@@ -210,7 +211,7 @@ public void applyAddWholeFailAnotherUniqueSingle() throws Exception {
 		this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity);
 		
 		ValidationException e = assertThrows(ValidationException.class, ()->this.appliedTransactionService.apply(DEFAULT_TEST_DB_NAME, null, item, preApplyTransaction, entity));
-		assertEquals("Cannot add more than one stored held for type UNIQUE_SINGLE", e.getMessage());
+		assertEquals("Cannot store more than one globally unique stored item.", e.getMessage());
 	}
 	
 	@Test
@@ -222,7 +223,7 @@ public void applyAddWholeFailMismatchedBlock() {
 														.toAdd(
 															UniqueStored.builder()
 																.item(item.getId())
-																.storageBlock(new ObjectId())
+																.state(StoredInBlock.builder().storageBlock(ObjectId.get()).build())
 																.build()
 														)
 														.toBlock(item.getStorageBlocks().getFirst())
@@ -237,7 +238,7 @@ public void applyAddWholeFailMismatchedBlock() {
 														 .toAdd(
 															 UniqueStored.builder()
 																 .item(item.getId())
-																 .storageBlock(item.getStorageBlocks().getFirst())
+																 .state(StoredInBlock.builder().storageBlock(item.getStorageBlocks().getFirst()).build())
 																 .build()
 														 )
 														 .toBlock(new ObjectId())
@@ -256,7 +257,7 @@ public void applyAddWholeFailBlockNotInItem() {
 														.toAdd(
 															UniqueStored.builder()
 																.item(item.getId())
-																.storageBlock(new ObjectId())
+																.state(StoredInBlock.builder().storageBlock(ObjectId.get()).build())
 																.build()
 														)
 														.toBlock(item.getStorageBlocks().getFirst())
@@ -277,7 +278,7 @@ public void applyAddWholeFailItemMismatched() {
 														.toAdd(
 															UniqueStored.builder()
 																.item(new ObjectId())
-																.storageBlock(item.getStorageBlocks().getFirst())
+																.state(StoredInBlock.builder().storageBlock(item.getStorageBlocks().getFirst()).build())
 																.build()
 														)
 														.toBlock(item.getStorageBlocks().getFirst())
diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/CheckinFullAmountAppliedTransactionTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/CheckinFullAmountAppliedTransactionTest.java
index fcc00a63b..ea0a6e340 100644
--- a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/CheckinFullAmountAppliedTransactionTest.java
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/CheckinFullAmountAppliedTransactionTest.java
@@ -23,6 +23,7 @@
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.AmountStored;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.Stored;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.UniqueStored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredInBlock;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.AppliedTransaction;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.ItemStoredTransaction;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.add.AddWholeTransaction;
@@ -56,7 +57,7 @@ public void applyCheckinFullAmountSuccessBulkToBlock() throws Exception {
 		
 		AmountStored initialStored = AmountStored.builder()
 										 .item(item.getId())
-										 .storageBlock(blockId)
+										 .state(StoredInBlock.builder().storageBlock(blockId).build())
 										 .amount(Quantities.getQuantity(5, item.getUnit()))
 										 .build();
 		this.storedService.add(DEFAULT_TEST_DB_NAME, initialStored, entity);
@@ -135,7 +136,7 @@ public void applyCheckinFullAmountSuccessBulkToBlockWithoutStored() throws Excep
 		
 		AmountStored initialStored = AmountStored.builder()
 										 .item(item.getId())
-										 .storageBlock(origBlockId)
+										 .state(StoredInBlock.builder().storageBlock(origBlockId).build())
 										 .amount(Quantities.getQuantity(5, item.getUnit()))
 										 .build();
 		this.storedService.add(DEFAULT_TEST_DB_NAME, initialStored, entity);
@@ -209,7 +210,7 @@ public void applyCheckinFullAmountSuccessBulkToStored() throws Exception {
 		
 		AmountStored initialStored = AmountStored.builder()
 										 .item(item.getId())
-										 .storageBlock(blockId)
+										 .state(StoredInBlock.builder().storageBlock(blockId).build())
 										 .amount(Quantities.getQuantity(5, item.getUnit()))
 										 .build();
 		this.storedService.add(DEFAULT_TEST_DB_NAME, initialStored, entity);
@@ -283,7 +284,7 @@ public void applyCheckinFullAmountSuccessAmtListToStored() throws Exception {
 		
 		AmountStored initialStored = AmountStored.builder()
 										 .item(item.getId())
-										 .storageBlock(blockId)
+										 .state(StoredInBlock.builder().storageBlock(blockId).build())
 										 .amount(Quantities.getQuantity(5, item.getUnit()))
 										 .build();
 		this.storedService.add(DEFAULT_TEST_DB_NAME, initialStored, entity);
@@ -356,7 +357,7 @@ public void applyCheckinFullAmountSuccessAmtListToBlock() throws Exception {
 		
 		AmountStored initialStored = AmountStored.builder()
 										 .item(item.getId())
-										 .storageBlock(blockId)
+										 .state(StoredInBlock.builder().storageBlock(blockId).build())
 										 .amount(Quantities.getQuantity(5, item.getUnit()))
 										 .build();
 		this.storedService.add(DEFAULT_TEST_DB_NAME, initialStored, entity);
diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/CheckinWholeAppliedTransactionTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/CheckinWholeAppliedTransactionTest.java
index 7d52b1b1e..d3b6c46d4 100644
--- a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/CheckinWholeAppliedTransactionTest.java
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/CheckinWholeAppliedTransactionTest.java
@@ -23,6 +23,7 @@
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.AmountStored;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.Stored;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.UniqueStored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredInBlock;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.AppliedTransaction;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.ItemStoredTransaction;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.checkin.CheckinFullTransaction;
@@ -57,7 +58,7 @@ public void applyCheckinFullWholeSuccessBulk() throws Exception {
 		
 		AmountStored initialStored = AmountStored.builder()
 										 .item(item.getId())
-										 .storageBlock(blockId)
+										 .state(StoredInBlock.builder().storageBlock(blockId).build())
 										 .amount(Quantities.getQuantity(5, item.getUnit()))
 										 .build();
 		this.storedService.add(DEFAULT_TEST_DB_NAME, initialStored, entity);
@@ -130,7 +131,7 @@ public void applyCheckinFullWholeSuccessUniqueMulti() throws Exception {
 		
 		UniqueStored initialStored = UniqueStored.builder()
 										 .item(item.getId())
-										 .storageBlock(blockId)
+										 .state(StoredInBlock.builder().storageBlock(blockId).build())
 										 .build();
 		this.storedService.add(DEFAULT_TEST_DB_NAME, initialStored, entity);
 		
@@ -201,7 +202,7 @@ public void applyCheckinFullWholeSuccessUniqueSingle() throws Exception {
 		
 		UniqueStored initialStored = UniqueStored.builder()
 										 .item(item.getId())
-										 .storageBlock(blockId)
+										 .state(StoredInBlock.builder().storageBlock(blockId).build())
 										 .build();
 		this.storedService.add(DEFAULT_TEST_DB_NAME, initialStored, entity);
 		
diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/CheckoutAmountAppliedTransactionTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/CheckoutAmountAppliedTransactionTest.java
index 3fcd5bf47..0310262e9 100644
--- a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/CheckoutAmountAppliedTransactionTest.java
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/CheckoutAmountAppliedTransactionTest.java
@@ -21,6 +21,7 @@
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.AmountStored;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.Stored;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.UniqueStored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredInBlock;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.AppliedTransaction;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.ItemStoredTransaction;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.checkin.CheckinFullTransaction;
@@ -56,7 +57,7 @@ public void applyCheckoutAmountSuccessBulkFromBlock() throws Exception {
 			DEFAULT_TEST_DB_NAME,
 			AmountStored.builder()
 				.item(item.getId())
-				.storageBlock(blockId)
+				.state(StoredInBlock.builder().storageBlock(blockId).build())
 				.amount(Quantities.getQuantity(6, item.getUnit()))
 				.build(),
 			entity
@@ -118,7 +119,7 @@ public void applyCheckoutAmountSuccessBulkFromStored() throws Exception {
 			DEFAULT_TEST_DB_NAME,
 			AmountStored.builder()
 				.item(item.getId())
-				.storageBlock(blockId)
+				.state(StoredInBlock.builder().storageBlock(blockId).build())
 				.amount(Quantities.getQuantity(6, item.getUnit()))
 				.build(),
 			entity
@@ -180,7 +181,7 @@ public void applyCheckoutAmountSuccessAmtList() throws Exception {
 			DEFAULT_TEST_DB_NAME,
 			AmountStored.builder()
 				.item(item.getId())
-				.storageBlock(blockId)
+				.state(StoredInBlock.builder().storageBlock(blockId).build())
 				.amount(Quantities.getQuantity(6, item.getUnit()))
 				.build(),
 			entity
@@ -242,7 +243,7 @@ public void applyCheckoutAmountFailBulkFromNothing() throws Exception {
 			DEFAULT_TEST_DB_NAME,
 			AmountStored.builder()
 				.item(item.getId())
-				.storageBlock(blockId)
+				.state(StoredInBlock.builder().storageBlock(blockId).build())
 				.amount(Quantities.getQuantity(6, item.getUnit()))
 				.build(),
 			entity
@@ -272,7 +273,7 @@ public void applyCheckoutAmountFailAmtListFromNothing() throws Exception {
 			DEFAULT_TEST_DB_NAME,
 			AmountStored.builder()
 				.item(item.getId())
-				.storageBlock(blockId)
+				.state(StoredInBlock.builder().storageBlock(blockId).build())
 				.amount(Quantities.getQuantity(6, item.getUnit()))
 				.build(),
 			entity
@@ -302,7 +303,7 @@ public void applyCheckoutAmountFailAmtListFromNoStored() throws Exception {
 			DEFAULT_TEST_DB_NAME,
 			AmountStored.builder()
 				.item(item.getId())
-				.storageBlock(blockId)
+				.state(StoredInBlock.builder().storageBlock(blockId).build())
 				.amount(Quantities.getQuantity(6, item.getUnit()))
 				.build(),
 			entity
@@ -333,7 +334,7 @@ public void applyCheckoutAmountFailAmtListBadBlock() throws Exception {
 			DEFAULT_TEST_DB_NAME,
 			AmountStored.builder()
 				.item(item.getId())
-				.storageBlock(blockId)
+				.state(StoredInBlock.builder().storageBlock(blockId).build())
 				.amount(Quantities.getQuantity(6, item.getUnit()))
 				.build(),
 			entity
@@ -365,7 +366,7 @@ public void applyCheckoutAmountFailBulkNotEnoughToCheckout() throws Exception {
 			DEFAULT_TEST_DB_NAME,
 			AmountStored.builder()
 				.item(item.getId())
-				.storageBlock(blockId)
+				.state(StoredInBlock.builder().storageBlock(blockId).build())
 				.amount(Quantities.getQuantity(6, item.getUnit()))
 				.build(),
 			entity
@@ -397,7 +398,7 @@ public void applyCheckoutAmountFailAmtListNotEnoughToCheckout() throws Exception
 			DEFAULT_TEST_DB_NAME,
 			AmountStored.builder()
 				.item(item.getId())
-				.storageBlock(blockId)
+				.state(StoredInBlock.builder().storageBlock(blockId).build())
 				.amount(Quantities.getQuantity(6, item.getUnit()))
 				.build(),
 			entity
@@ -429,7 +430,7 @@ public void applyCheckoutAmountFailUniqueSingle() throws Exception {
 			DEFAULT_TEST_DB_NAME,
 			UniqueStored.builder()
 				.item(item.getId())
-				.storageBlock(blockId)
+				.state(StoredInBlock.builder().storageBlock(blockId).build())
 				.build(),
 			entity
 		).getId();
@@ -460,7 +461,7 @@ public void applyCheckoutAmountFailUniqueMulti() throws Exception {
 			DEFAULT_TEST_DB_NAME,
 			UniqueStored.builder()
 				.item(item.getId())
-				.storageBlock(blockId)
+				.state(StoredInBlock.builder().storageBlock(blockId).build())
 				.build(),
 			entity
 		).getId();
diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/CheckoutWholeAppliedTransactionTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/CheckoutWholeAppliedTransactionTest.java
index b20b1eb62..e6f7d1aed 100644
--- a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/CheckoutWholeAppliedTransactionTest.java
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/CheckoutWholeAppliedTransactionTest.java
@@ -21,6 +21,7 @@
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.AmountStored;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.Stored;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.UniqueStored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredInBlock;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.AppliedTransaction;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.ItemStoredTransaction;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.checkout.CheckoutAmountTransaction;
@@ -53,7 +54,7 @@ public void applyCheckoutWholeSuccessBulk() throws Exception {
 		
 		AmountStored initialStored = AmountStored.builder()
 										 .item(item.getId())
-										 .storageBlock(blockId)
+										 .state(StoredInBlock.builder().storageBlock(blockId).build())
 										 .amount(Quantities.getQuantity(6, item.getUnit()))
 										 .build();
 		ObjectId initialStoredId = this.storedService.add(
@@ -109,7 +110,7 @@ public void applyCheckoutWholeSuccessAmtList() throws Exception {
 		
 		AmountStored initialStored = AmountStored.builder()
 										 .item(item.getId())
-										 .storageBlock(blockId)
+										 .state(StoredInBlock.builder().storageBlock(blockId).build())
 										 .amount(Quantities.getQuantity(6, item.getUnit()))
 										 .build();
 		ObjectId initialStoredId = this.storedService.add(
@@ -165,7 +166,7 @@ public void applyCheckoutWholeSuccessUniqueMulti() throws Exception {
 		
 		UniqueStored initialStored = UniqueStored.builder()
 										 .item(item.getId())
-										 .storageBlock(blockId)
+										 .state(StoredInBlock.builder().storageBlock(blockId).build())
 										 .build();
 		ObjectId initialStoredId = this.storedService.add(
 			DEFAULT_TEST_DB_NAME,
@@ -220,7 +221,7 @@ public void applyCheckoutWholeSuccessUniqueSingle() throws Exception {
 		
 		UniqueStored initialStored = UniqueStored.builder()
 										 .item(item.getId())
-										 .storageBlock(blockId)
+										 .state(StoredInBlock.builder().storageBlock(blockId).build())
 										 .build();
 		ObjectId initialStoredId = this.storedService.add(
 			DEFAULT_TEST_DB_NAME,
diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/SetAmountAppliedTransactionTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/SetAmountAppliedTransactionTest.java
index 46f3006d4..e95343ea6 100644
--- a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/SetAmountAppliedTransactionTest.java
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/SetAmountAppliedTransactionTest.java
@@ -21,6 +21,7 @@
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.AmountStored;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.Stored;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.UniqueStored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredInBlock;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.AppliedTransaction;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.ItemStoredTransaction;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.checkout.CheckoutWholeTransaction;
@@ -90,7 +91,7 @@ public void applySetAmountSuccessBulkAlreadyInBlock() throws Exception {
 		
 		AmountStored originalStored = AmountStored.builder()
 										  .item(item.getId())
-										  .storageBlock(item.getStorageBlocks().getFirst())
+										  .state(StoredInBlock.builder().storageBlock(item.getStorageBlocks().getFirst()).build())
 										  .amount(Quantities.getQuantity(5, item.getUnit()))
 										  .build();
 		this.storedService.add(DEFAULT_TEST_DB_NAME, originalStored, entity);
@@ -138,7 +139,7 @@ public void applySetAmountSuccessAmtListExistingStored() throws Exception {
 		
 		AmountStored originalStored = AmountStored.builder()
 										  .item(item.getId())
-										  .storageBlock(item.getStorageBlocks().getFirst())
+										  .state(StoredInBlock.builder().storageBlock(item.getStorageBlocks().getFirst()).build())
 										  .amount(Quantities.getQuantity(5, item.getUnit()))
 										  .build();
 		this.storedService.add(DEFAULT_TEST_DB_NAME, originalStored, entity);
@@ -274,7 +275,7 @@ public void applySetAmountFailAmtListBadStoredNotInBlock() {
 		
 		AmountStored originalStored = AmountStored.builder()
 										  .item(item.getId())
-										  .storageBlock(origBlock)
+										  .state(StoredInBlock.builder().storageBlock(origBlock).build())
 										  .amount(Quantities.getQuantity(5, item.getUnit()))
 										  .build();
 		this.storedService.add(DEFAULT_TEST_DB_NAME, originalStored, entity);
diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/SubtractAmountAppliedTransactionTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/SubtractAmountAppliedTransactionTest.java
index 2cdc525f6..5fa90e4bc 100644
--- a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/SubtractAmountAppliedTransactionTest.java
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/SubtractAmountAppliedTransactionTest.java
@@ -16,6 +16,7 @@
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.AmountStored;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.Stored;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.UniqueStored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredInBlock;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.AppliedTransaction;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.ItemStoredTransaction;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.set.SetAmountTransaction;
@@ -49,7 +50,7 @@ public void applySubtractAmountSuccessBulkBlock() throws Exception {
 			AmountStored.builder()
 				.amount(Quantities.getQuantity(5, item.getUnit()))
 				.item(item.getId())
-				.storageBlock(item.getStorageBlocks().getFirst())
+				.state(StoredInBlock.builder().storageBlock(item.getStorageBlocks().getFirst()).build())
 				.build(),
 			entity
 		);
@@ -95,7 +96,7 @@ public void applySubtractAmountSuccessBulkStored() throws Exception {
 		AmountStored initialStored = AmountStored.builder()
 										 .amount(Quantities.getQuantity(5, item.getUnit()))
 										 .item(item.getId())
-										 .storageBlock(item.getStorageBlocks().getFirst())
+										 .state(StoredInBlock.builder().storageBlock(item.getStorageBlocks().getFirst()).build())
 										 .build();
 		this.storedService.add(
 			DEFAULT_TEST_DB_NAME,
@@ -145,7 +146,7 @@ public void applySubtractAmountSuccessList() throws Exception {
 		AmountStored initialStored = AmountStored.builder()
 										 .amount(Quantities.getQuantity(5, item.getUnit()))
 										 .item(item.getId())
-										 .storageBlock(item.getStorageBlocks().getFirst())
+										 .state(StoredInBlock.builder().storageBlock(item.getStorageBlocks().getFirst()).build())
 										 .build();
 		this.storedService.add(
 			DEFAULT_TEST_DB_NAME,
@@ -194,7 +195,7 @@ public void applySubtractAmountFailUniqueMulti() throws Exception {
 		
 		UniqueStored initialStored = UniqueStored.builder()
 										 .item(item.getId())
-										 .storageBlock(item.getStorageBlocks().getFirst())
+										 .state(StoredInBlock.builder().storageBlock(item.getStorageBlocks().getFirst()).build())
 										 .build();
 		this.storedService.add(
 			DEFAULT_TEST_DB_NAME,
@@ -220,7 +221,7 @@ public void applySubtractAmountFailUniqueSingle() throws Exception {
 		
 		UniqueStored initialStored = UniqueStored.builder()
 										 .item(item.getId())
-										 .storageBlock(item.getStorageBlocks().getFirst())
+										 .state(StoredInBlock.builder().storageBlock(item.getStorageBlocks().getFirst()).build())
 										 .build();
 		this.storedService.add(
 			DEFAULT_TEST_DB_NAME,
@@ -247,7 +248,7 @@ public void applySubtractAmountFailBulkSubMoreThanHeld() throws Exception {
 		AmountStored initialStored = AmountStored.builder()
 										 .amount(Quantities.getQuantity(2, item.getUnit()))
 										 .item(item.getId())
-										 .storageBlock(item.getStorageBlocks().getFirst())
+										 .state(StoredInBlock.builder().storageBlock(item.getStorageBlocks().getFirst()).build())
 										 .build();
 		this.storedService.add(
 			DEFAULT_TEST_DB_NAME,
@@ -274,7 +275,7 @@ public void applySubtractAmountFailAmtListSubMoreThanHeld() throws Exception {
 		AmountStored initialStored = AmountStored.builder()
 										 .amount(Quantities.getQuantity(2, item.getUnit()))
 										 .item(item.getId())
-										 .storageBlock(item.getStorageBlocks().getFirst())
+										 .state(StoredInBlock.builder().storageBlock(item.getStorageBlocks().getFirst()).build())
 										 .build();
 		this.storedService.add(
 			DEFAULT_TEST_DB_NAME,
@@ -306,7 +307,7 @@ public void applySubtractAmountFailBulkMismatchedBlock() throws Exception {
 		AmountStored initialStored = AmountStored.builder()
 										 .amount(Quantities.getQuantity(5, item.getUnit()))
 										 .item(item.getId())
-										 .storageBlock(item.getStorageBlocks().getFirst())
+										 .state(StoredInBlock.builder().storageBlock(item.getStorageBlocks().getFirst()).build())
 										 .build();
 		this.storedService.add(
 			DEFAULT_TEST_DB_NAME,
@@ -316,7 +317,7 @@ public void applySubtractAmountFailBulkMismatchedBlock() throws Exception {
 		AmountStored secondStored = AmountStored.builder()
 										.amount(Quantities.getQuantity(5, item.getUnit()))
 										.item(item.getId())
-										.storageBlock(newBlock.getId())
+										.state(StoredInBlock.builder().storageBlock(newBlock.getId()).build())
 										.build();
 		this.storedService.add(
 			DEFAULT_TEST_DB_NAME,
@@ -348,7 +349,7 @@ public void applySubtractAmountFailBulkMismatchedStored() throws Exception {
 		AmountStored initialStored = AmountStored.builder()
 										 .amount(Quantities.getQuantity(5, item.getUnit()))
 										 .item(item.getId())
-										 .storageBlock(item.getStorageBlocks().getFirst())
+										 .state(StoredInBlock.builder().storageBlock(item.getStorageBlocks().getFirst()).build())
 										 .build();
 		this.storedService.add(
 			DEFAULT_TEST_DB_NAME,
@@ -358,7 +359,7 @@ public void applySubtractAmountFailBulkMismatchedStored() throws Exception {
 		AmountStored secondStored = AmountStored.builder()
 										.amount(Quantities.getQuantity(5, item.getUnit()))
 										.item(item.getId())
-										.storageBlock(newBlock.getId())
+										.state(StoredInBlock.builder().storageBlock(newBlock.getId()).build())
 										.build();
 		this.storedService.add(
 			DEFAULT_TEST_DB_NAME,
@@ -390,7 +391,7 @@ public void applySubtractAmountFailListMismatchedBlock() throws Exception {
 		AmountStored initialStored = AmountStored.builder()
 										 .amount(Quantities.getQuantity(5, item.getUnit()))
 										 .item(item.getId())
-										 .storageBlock(item.getStorageBlocks().getFirst())
+										 .state(StoredInBlock.builder().storageBlock(item.getStorageBlocks().getFirst()).build())
 										 .build();
 		this.storedService.add(
 			DEFAULT_TEST_DB_NAME,
@@ -400,7 +401,7 @@ public void applySubtractAmountFailListMismatchedBlock() throws Exception {
 		AmountStored secondStored = AmountStored.builder()
 										.amount(Quantities.getQuantity(5, item.getUnit()))
 										.item(item.getId())
-										.storageBlock(newBlock.getId())
+										.state(StoredInBlock.builder().storageBlock(newBlock.getId()).build())
 										.build();
 		this.storedService.add(
 			DEFAULT_TEST_DB_NAME,
@@ -432,7 +433,7 @@ public void applySubtractAmountFailListMismatchedStored() throws Exception {
 		AmountStored initialStored = AmountStored.builder()
 										 .amount(Quantities.getQuantity(5, item.getUnit()))
 										 .item(item.getId())
-										 .storageBlock(item.getStorageBlocks().getFirst())
+										 .state(StoredInBlock.builder().storageBlock(item.getStorageBlocks().getFirst()).build())
 										 .build();
 		this.storedService.add(
 			DEFAULT_TEST_DB_NAME,
@@ -442,7 +443,7 @@ public void applySubtractAmountFailListMismatchedStored() throws Exception {
 		AmountStored secondStored = AmountStored.builder()
 										.amount(Quantities.getQuantity(5, item.getUnit()))
 										.item(item.getId())
-										.storageBlock(newBlock.getId())
+										.state(StoredInBlock.builder().storageBlock(newBlock.getId()).build())
 										.build();
 		this.storedService.add(
 			DEFAULT_TEST_DB_NAME,
@@ -469,7 +470,7 @@ public void applySubtractAmountFailNullStored() throws Exception {
 		AmountStored initialStored = AmountStored.builder()
 										 .amount(Quantities.getQuantity(5, item.getUnit()))
 										 .item(item.getId())
-										 .storageBlock(item.getStorageBlocks().getFirst())
+										 .state(StoredInBlock.builder().storageBlock(item.getStorageBlocks().getFirst()).build())
 										 .build();
 		this.storedService.add(
 			DEFAULT_TEST_DB_NAME,
diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/TransferAmountAppliedTransactionTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/TransferAmountAppliedTransactionTest.java
index 21b064134..954c3bc40 100644
--- a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/TransferAmountAppliedTransactionTest.java
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/TransferAmountAppliedTransactionTest.java
@@ -14,6 +14,7 @@
 import tech.ebp.oqm.core.api.model.object.storage.items.StorageType;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.AmountStored;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.Stored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredInBlock;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.AppliedTransaction;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.ItemStoredTransaction;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.transfer.TransferAmountTransaction;
@@ -53,7 +54,7 @@ public void applyTransferAmountSuccessBulkNotInBlock() throws Exception {
 		ObjectId initialStoredId = this.storedService.add(
 			DEFAULT_TEST_DB_NAME, AmountStored.builder()
 									  .item(item.getId())
-									  .storageBlock(firstBlock)
+									  .state(StoredInBlock.builder().storageBlock(firstBlock).build())
 									  .amount(Quantities.getQuantity(5, item.getUnit()))
 									  .build(),
 			entity
@@ -127,7 +128,7 @@ public void applyTransferAmountSuccessBulkInBlock() throws Exception {
 		ObjectId initialStoredId = this.storedService.add(
 			DEFAULT_TEST_DB_NAME, AmountStored.builder()
 									  .item(item.getId())
-									  .storageBlock(firstBlock)
+									  .state(StoredInBlock.builder().storageBlock(firstBlock).build())
 									  .amount(Quantities.getQuantity(5, item.getUnit()))
 									  .build(),
 			entity
@@ -135,7 +136,7 @@ public void applyTransferAmountSuccessBulkInBlock() throws Exception {
 		ObjectId destinationStoredId = this.storedService.add(
 			DEFAULT_TEST_DB_NAME, AmountStored.builder()
 									  .item(item.getId())
-									  .storageBlock(secondBlock)
+									  .state(StoredInBlock.builder().storageBlock(secondBlock).build())
 									  .amount(Quantities.getQuantity(0, item.getUnit()))
 									  .build(),
 			entity
@@ -209,7 +210,7 @@ public void applyTransferAmountSuccessBulkFromBlockToStored() throws Exception {
 		ObjectId initialStoredId = this.storedService.add(
 			DEFAULT_TEST_DB_NAME, AmountStored.builder()
 									  .item(item.getId())
-									  .storageBlock(firstBlock)
+									  .state(StoredInBlock.builder().storageBlock(firstBlock).build())
 									  .amount(Quantities.getQuantity(5, item.getUnit()))
 									  .build(),
 			entity
@@ -217,7 +218,7 @@ public void applyTransferAmountSuccessBulkFromBlockToStored() throws Exception {
 		ObjectId destinationStoredId = this.storedService.add(
 			DEFAULT_TEST_DB_NAME, AmountStored.builder()
 									  .item(item.getId())
-									  .storageBlock(secondBlock)
+									  .state(StoredInBlock.builder().storageBlock(secondBlock).build())
 									  .amount(Quantities.getQuantity(0, item.getUnit()))
 									  .build(),
 			entity
@@ -292,7 +293,7 @@ public void applyTransferAmountSuccessBulkFromStoredToBlock() throws Exception {
 		ObjectId initialStoredId = this.storedService.add(
 			DEFAULT_TEST_DB_NAME, AmountStored.builder()
 									  .item(item.getId())
-									  .storageBlock(firstBlock)
+									  .state(StoredInBlock.builder().storageBlock(firstBlock).build())
 									  .amount(Quantities.getQuantity(5, item.getUnit()))
 									  .build(),
 			entity
@@ -300,7 +301,7 @@ public void applyTransferAmountSuccessBulkFromStoredToBlock() throws Exception {
 		ObjectId destinationStoredId = this.storedService.add(
 			DEFAULT_TEST_DB_NAME, AmountStored.builder()
 									  .item(item.getId())
-									  .storageBlock(secondBlock)
+									  .state(StoredInBlock.builder().storageBlock(secondBlock).build())
 									  .amount(Quantities.getQuantity(0, item.getUnit()))
 									  .build(),
 			entity
@@ -375,7 +376,7 @@ public void applyTransferAmountSuccessList() throws Exception {
 		ObjectId initialStoredId = this.storedService.add(
 			DEFAULT_TEST_DB_NAME, AmountStored.builder()
 									  .item(item.getId())
-									  .storageBlock(firstBlock)
+									  .state(StoredInBlock.builder().storageBlock(firstBlock).build())
 									  .amount(Quantities.getQuantity(5, item.getUnit()))
 									  .build(),
 			entity
@@ -383,7 +384,7 @@ public void applyTransferAmountSuccessList() throws Exception {
 		ObjectId destinationStoredId = this.storedService.add(
 			DEFAULT_TEST_DB_NAME, AmountStored.builder()
 									  .item(item.getId())
-									  .storageBlock(secondBlock)
+									  .state(StoredInBlock.builder().storageBlock(secondBlock).build())
 									  .amount(Quantities.getQuantity(0, item.getUnit()))
 									  .build(),
 			entity
@@ -459,7 +460,7 @@ public void applyTransferAmountSuccessListToNonExistent() throws Exception {
 		ObjectId initialStoredId = this.storedService.add(
 			DEFAULT_TEST_DB_NAME, AmountStored.builder()
 									  .item(item.getId())
-									  .storageBlock(firstBlock)
+									  .state(StoredInBlock.builder().storageBlock(firstBlock).build())
 									  .amount(Quantities.getQuantity(5, item.getUnit()))
 									  .build(),
 			entity
@@ -583,7 +584,7 @@ public void applyTransferAmountFailBulkNotEnoughToTransfer() throws Exception {
 		ObjectId initialStoredId = this.storedService.add(
 			DEFAULT_TEST_DB_NAME, AmountStored.builder()
 									  .item(item.getId())
-									  .storageBlock(firstBlock)
+									  .state(StoredInBlock.builder().storageBlock(firstBlock).build())
 									  .amount(Quantities.getQuantity(5, item.getUnit()))
 									  .build(),
 			entity
@@ -617,7 +618,7 @@ public void applyTransferAmountFailAmtListNotEnoughToTransfer() throws Exception
 		ObjectId initialStoredId = this.storedService.add(
 			DEFAULT_TEST_DB_NAME, AmountStored.builder()
 									  .item(item.getId())
-									  .storageBlock(firstBlock)
+									  .state(StoredInBlock.builder().storageBlock(firstBlock).build())
 									  .amount(Quantities.getQuantity(5, item.getUnit()))
 									  .build(),
 			entity
@@ -652,7 +653,7 @@ public void applyTransferAmountFailBulkMismatchedStoredId() throws Exception {
 		ObjectId initialStoredId = this.storedService.add(
 			DEFAULT_TEST_DB_NAME, AmountStored.builder()
 									  .item(item.getId())
-									  .storageBlock(firstBlock)
+									  .state(StoredInBlock.builder().storageBlock(firstBlock).build())
 									  .amount(Quantities.getQuantity(5, item.getUnit()))
 									  .build(),
 			entity
@@ -660,7 +661,7 @@ public void applyTransferAmountFailBulkMismatchedStoredId() throws Exception {
 		ObjectId destinationStoredId = this.storedService.add(
 			DEFAULT_TEST_DB_NAME, AmountStored.builder()
 									  .item(item.getId())
-									  .storageBlock(secondBlock)
+									  .state(StoredInBlock.builder().storageBlock(secondBlock).build())
 									  .amount(Quantities.getQuantity(0, item.getUnit()))
 									  .build(),
 			entity
@@ -695,7 +696,7 @@ public void applyTransferAmountFailBulkMismatchedBlockTo() throws Exception {
 		ObjectId initialStoredId = this.storedService.add(
 			DEFAULT_TEST_DB_NAME, AmountStored.builder()
 									  .item(item.getId())
-									  .storageBlock(firstBlock)
+									  .state(StoredInBlock.builder().storageBlock(firstBlock).build())
 									  .amount(Quantities.getQuantity(5, item.getUnit()))
 									  .build(),
 			entity
@@ -703,7 +704,7 @@ public void applyTransferAmountFailBulkMismatchedBlockTo() throws Exception {
 		ObjectId destinationStoredId = this.storedService.add(
 			DEFAULT_TEST_DB_NAME, AmountStored.builder()
 									  .item(item.getId())
-									  .storageBlock(secondBlock)
+									  .state(StoredInBlock.builder().storageBlock(secondBlock).build())
 									  .amount(Quantities.getQuantity(0, item.getUnit()))
 									  .build(),
 			entity
diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/TransferWholeAppliedTransactionTest.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/TransferWholeAppliedTransactionTest.java
index d380a2732..f66b2467f 100644
--- a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/TransferWholeAppliedTransactionTest.java
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/service/mongo/transactions/transactionApplier/TransferWholeAppliedTransactionTest.java
@@ -15,6 +15,7 @@
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.AmountStored;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.Stored;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.UniqueStored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredInBlock;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.AppliedTransaction;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.ItemStoredTransaction;
 import tech.ebp.oqm.core.api.model.object.storage.items.transactions.transactions.transfer.TransferAmountTransaction;
@@ -55,7 +56,7 @@ public void applyTransferWholeSuccessBulk() throws Exception {
 		ObjectId initialStoredId = this.storedService.add(
 			DEFAULT_TEST_DB_NAME, AmountStored.builder()
 									  .item(item.getId())
-									  .storageBlock(firstBlock)
+									  .state(StoredInBlock.builder().storageBlock(firstBlock).build())
 									  .amount(Quantities.getQuantity(5, item.getUnit()))
 									  .build(),
 			entity
@@ -113,7 +114,7 @@ public void applyTransferWholeSuccessAmtList() throws Exception {
 		ObjectId initialStoredId = this.storedService.add(
 			DEFAULT_TEST_DB_NAME, AmountStored.builder()
 									  .item(item.getId())
-									  .storageBlock(firstBlock)
+									  .state(StoredInBlock.builder().storageBlock(firstBlock).build())
 									  .amount(Quantities.getQuantity(5, item.getUnit()))
 									  .build(),
 			entity
@@ -172,7 +173,7 @@ public void applyTransferWholeSuccessUniqueMulti() throws Exception {
 		ObjectId initialStoredId = this.storedService.add(
 			DEFAULT_TEST_DB_NAME, UniqueStored.builder()
 									  .item(item.getId())
-									  .storageBlock(firstBlock)
+									  .state(StoredInBlock.builder().storageBlock(firstBlock).build())
 									  .build(),
 			entity
 		).getId();
@@ -230,7 +231,7 @@ public void applyTransferWholeSuccessUniqueSingle() throws Exception {
 		ObjectId initialStoredId = this.storedService.add(
 			DEFAULT_TEST_DB_NAME, UniqueStored.builder()
 									  .item(item.getId())
-									  .storageBlock(firstBlock)
+									  .state(StoredInBlock.builder().storageBlock(firstBlock).build())
 									  .build(),
 			entity
 		).getId();
diff --git a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/testResources/data/StoredTestObjectCreator.java b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/testResources/data/StoredTestObjectCreator.java
index 4cd30ea6b..fd9ba0578 100644
--- a/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/testResources/data/StoredTestObjectCreator.java
+++ b/software/core/oqm-core-api/src/test/java/tech/ebp/oqm/core/api/testResources/data/StoredTestObjectCreator.java
@@ -10,6 +10,7 @@
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.AmountStored;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.Stored;
 import tech.ebp.oqm.core.api.model.object.storage.items.stored.UniqueStored;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredInBlock;
 import tech.units.indriya.quantity.Quantities;
 
 import javax.measure.Quantity;
@@ -34,7 +35,7 @@ public Stored getTestObject() {
 		};
 		builder
 			.item(this.item.getId())
-			.storageBlock(this.storageBlock);
+			.state(StoredInBlock.builder().storageBlock(this.storageBlock).build());
 
 		return builder.build();
 	}

From 4b37d0901f9577a162dcfaeccf37e9eb91b1140d Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Tue, 19 May 2026 00:17:47 -0400
Subject: [PATCH 27/48] Core - API - Now working upgrader

---
 software/core/oqm-core-api/build.gradle       |  2 +-
 .../object/storage/items/stored/Stored.java   |  2 +-
 .../api/model/rest/search/StoredSearch.java   | 38 +++++++-------
 .../stored/StoredSchemaUpgrader.java          |  4 +-
 .../stored/bumpers/StoredItemBumper5.java     | 51 +++++++++++++++++++
 5 files changed, 76 insertions(+), 21 deletions(-)
 create mode 100644 software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/schemaVersioning/upgraders/stored/bumpers/StoredItemBumper5.java

diff --git a/software/core/oqm-core-api/build.gradle b/software/core/oqm-core-api/build.gradle
index ff8a46dda..1e141a3db 100644
--- a/software/core/oqm-core-api/build.gradle
+++ b/software/core/oqm-core-api/build.gradle
@@ -8,7 +8,7 @@ plugins {
 }
 
 group 'com.ebp.openQuarterMaster'
-version '4.4.8-SNAPSHOT'
+version '5.0.0-SNAPSHOT'
 
 repositories {
 	mavenCentral()
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/Stored.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/Stored.java
index a16647c68..344897a6b 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/Stored.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/Stored.java
@@ -69,7 +69,7 @@
 @Schema(oneOf = {AmountStored.class, UniqueStored.class})
 public abstract class Stored extends ImagedMainObject implements FileAttachmentContaining {
 	
-	public static final int CUR_SCHEMA_VERSION = 4;
+	public static final int CUR_SCHEMA_VERSION = 5;
 	
 	private static final Pattern LABEL_PARTS_PATTERN = Pattern.compile("\\{[^}]*}");
 	private static final String LABEL_PLACEHOLDER_PART_DELIM = ";";
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/rest/search/StoredSearch.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/rest/search/StoredSearch.java
index 5c1ef3a90..dfee395c9 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/rest/search/StoredSearch.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/rest/search/StoredSearch.java
@@ -79,32 +79,34 @@ public List<Bson> getSearchFilters() {
 			filters.add(eq("item", this.getInventoryItemIdFromQuery()));
 		}
 		
-		if(hasValue(this.getStorageBlockIdFromPath())){
-			filters.add(eq("state.storageBlock", this.getStorageBlockIdFromPath()));
-		} else if(hasValue(this.getStorageBlockIdFromQuery())){
-			filters.add(eq("state.storageBlock", this.getStorageBlockIdFromQuery()));
-		}
-		
 		//TODO:: redo these
 //		if (this.hasValue(this.getItemBarcode())) {
 //			filters.add(
 //				eq("barcode", this.getItemBarcode())
 //			);
 //		}
-		if(hasValue(this.getInStorageBlocks())){
-			if(this.getInStorageBlocks().size() == 1){
-				filters.add(
-					eq("state.storageBlock", this.getInStorageBlocks().getFirst())
-				);
-			} else {
-				filters.add(or(
-					this.getInStorageBlocks().stream().map((ObjectId storageBlockId) -> {
-//					return exists("storageBlocks." + storageBlockId.toHexString());
-						return eq("state.storageBlock", storageBlockId);
-					}).toList()
-				));
+		if(this.getStoredState() == StoredStateType.STORED){
+			if(hasValue(this.getStorageBlockIdFromPath())){
+				filters.add(eq("state.storageBlock", this.getStorageBlockIdFromPath()));
+			} else if(hasValue(this.getStorageBlockIdFromQuery())){
+				filters.add(eq("state.storageBlock", this.getStorageBlockIdFromQuery()));
+			}
+			if(hasValue(this.getInStorageBlocks())){
+				if(this.getInStorageBlocks().size() == 1){
+					filters.add(
+						eq("state.storageBlock", this.getInStorageBlocks().getFirst())
+					);
+				} else {
+					filters.add(or(
+						this.getInStorageBlocks().stream().map((ObjectId storageBlockId) -> {
+							//					return exists("storageBlocks." + storageBlockId.toHexString());
+							return eq("state.storageBlock", storageBlockId);
+						}).toList()
+					));
+				}
 			}
 		}
+		
 		if(hasValue(this.getHasExpiryDate())){
 			filters.add(
 				ne("expires", null)
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/schemaVersioning/upgraders/stored/StoredSchemaUpgrader.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/schemaVersioning/upgraders/stored/StoredSchemaUpgrader.java
index 1db1821f9..3fbe05b16 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/schemaVersioning/upgraders/stored/StoredSchemaUpgrader.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/schemaVersioning/upgraders/stored/StoredSchemaUpgrader.java
@@ -7,6 +7,7 @@
 import tech.ebp.oqm.core.api.service.schemaVersioning.upgraders.stored.bumpers.StoredItemBumper2;
 import tech.ebp.oqm.core.api.service.schemaVersioning.upgraders.stored.bumpers.StoredItemBumper3;
 import tech.ebp.oqm.core.api.service.schemaVersioning.upgraders.stored.bumpers.StoredItemBumper4;
+import tech.ebp.oqm.core.api.service.schemaVersioning.upgraders.stored.bumpers.StoredItemBumper5;
 
 import java.util.TreeSet;
 
@@ -18,7 +19,8 @@ public StoredSchemaUpgrader() {
 			Stored.class,
 			new StoredItemBumper2(),
 			new StoredItemBumper3(),
-			new StoredItemBumper4()
+			new StoredItemBumper4(),
+			new StoredItemBumper5()
 		);
 	}
 }
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/schemaVersioning/upgraders/stored/bumpers/StoredItemBumper5.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/schemaVersioning/upgraders/stored/bumpers/StoredItemBumper5.java
new file mode 100644
index 000000000..c15e0791d
--- /dev/null
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/schemaVersioning/upgraders/stored/bumpers/StoredItemBumper5.java
@@ -0,0 +1,51 @@
+package tech.ebp.oqm.core.api.service.schemaVersioning.upgraders.stored.bumpers;
+
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import tech.ebp.oqm.core.api.model.object.storage.items.stored.Stored;
+import tech.ebp.oqm.core.api.model.object.upgrade.SingleUpgradeResult;
+import tech.ebp.oqm.core.api.model.object.upgrade.UpgradeCreatedObjectsResults;
+import tech.ebp.oqm.core.api.service.schemaVersioning.upgraders.ObjectSchemaVersionBumper;
+import tech.ebp.oqm.core.api.service.schemaVersioning.upgraders.UpgradingUtils;
+import tech.ebp.oqm.core.api.service.schemaVersioning.upgraders.sharedOps.GenUnIdToIdentifierUpgrade;
+
+import javax.measure.Unit;
+import java.time.Duration;
+
+public class StoredItemBumper5 extends ObjectSchemaVersionBumper<Stored> {
+	
+	public StoredItemBumper5() {
+		super(5);
+	}
+	
+	
+	@Override
+	protected SingleUpgradeResult bumpObjectSchema(ObjectNode oldObj) {
+		UpgradeCreatedObjectsResults createdObjectsResults = new UpgradeCreatedObjectsResults();
+		SingleUpgradeResult.SingleUpgradeResultBuilder resultBuilder = SingleUpgradeResult.builder()
+														.upgradedObject(oldObj)
+														.createdObjects(createdObjectsResults);
+		
+		UpgradingUtils.normalizeObjectId(oldObj, "storageBlock");
+		String storageBlockId = oldObj.remove("storageBlock").asText();
+		ObjectNode state = oldObj.putObject("state");
+		state.put("type", "STORED");
+		state.put("storageBlock", storageBlockId);
+		
+		//normal stuff
+		UpgradingUtils.normalizeObjectId(oldObj, "item");
+		UpgradingUtils.stringToConvertedTree(oldObj, "expiryWarningThreshold", Duration.class);
+		UpgradingUtils.stringToConvertedTree(oldObj, "unit", Unit.class);
+		UpgradingUtils.normalizeObjectIdList((ArrayNode) oldObj.get("imageIds"));
+		UpgradingUtils.normalizeObjectIdList((ArrayNode) oldObj.get("attachedFiles"));
+		UpgradingUtils.dequoteString(oldObj, "expires");
+		
+		if(oldObj.has("amount") && !oldObj.get("amount").isNull() && !oldObj.get("amount").isObject()){
+			UpgradingUtils.deserializeJsonField(oldObj, "amount");
+		}
+		UpgradingUtils.monetaryAmountMongoToJackson((ArrayNode) oldObj.get("prices"));
+		
+		
+		return resultBuilder.build();
+	}
+}

From d2b2ea49b3ee96b9b27280f1ad7538f0eaa8e482 Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Tue, 19 May 2026 00:21:09 -0400
Subject: [PATCH 28/48] Lib - Core API for Quarkus - Updates for new stored
 search

---
 software/libs/core-api-lib-quarkus/deployment/pom.xml        | 2 +-
 .../quarkus/deployment/config/CoreApiLibBuildTimeConfig.java | 2 +-
 software/libs/core-api-lib-quarkus/integration-tests/pom.xml | 2 +-
 software/libs/core-api-lib-quarkus/pom.xml                   | 2 +-
 software/libs/core-api-lib-quarkus/runtime/pom.xml           | 2 +-
 .../runtime/restClient/searchObjects/StoredSearch.java       | 5 +++++
 6 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/software/libs/core-api-lib-quarkus/deployment/pom.xml b/software/libs/core-api-lib-quarkus/deployment/pom.xml
index f74cb21ed..f9b4f3293 100644
--- a/software/libs/core-api-lib-quarkus/deployment/pom.xml
+++ b/software/libs/core-api-lib-quarkus/deployment/pom.xml
@@ -8,7 +8,7 @@
 	<parent>
 		<groupId>tech.epic-breakfast-productions.openquartermaster.lib.core</groupId>
 		<artifactId>core-api-lib-quarkus-parent</artifactId>
-		<version>4.4.8</version>
+		<version>5.0.0-SNAPSHOT</version>
 	</parent>
 	<artifactId>core-api-lib-quarkus-deployment</artifactId>
 	<name>Core Api Lib Quarkus - Deployment</name>
diff --git a/software/libs/core-api-lib-quarkus/deployment/src/main/java/tech/ebp/oqm/lib/core/api/quarkus/deployment/config/CoreApiLibBuildTimeConfig.java b/software/libs/core-api-lib-quarkus/deployment/src/main/java/tech/ebp/oqm/lib/core/api/quarkus/deployment/config/CoreApiLibBuildTimeConfig.java
index 680712485..1e799684f 100644
--- a/software/libs/core-api-lib-quarkus/deployment/src/main/java/tech/ebp/oqm/lib/core/api/quarkus/deployment/config/CoreApiLibBuildTimeConfig.java
+++ b/software/libs/core-api-lib-quarkus/deployment/src/main/java/tech/ebp/oqm/lib/core/api/quarkus/deployment/config/CoreApiLibBuildTimeConfig.java
@@ -96,7 +96,7 @@ interface ImageConfig {
 			 *
 			 * @return The version/ tag of the core api container image
 			 */
-			@WithDefault("4.4.7")
+			@WithDefault("5.0.0-SNAPSHOT")
 			String version();
 			
 			/**
diff --git a/software/libs/core-api-lib-quarkus/integration-tests/pom.xml b/software/libs/core-api-lib-quarkus/integration-tests/pom.xml
index 0d56e4776..ffbf2463b 100644
--- a/software/libs/core-api-lib-quarkus/integration-tests/pom.xml
+++ b/software/libs/core-api-lib-quarkus/integration-tests/pom.xml
@@ -5,7 +5,7 @@
   <parent>
     <groupId>tech.ebp.oqm.lib.core.api.quark</groupId>
     <artifactId>core-api-lib-quarkus-parent</artifactId>
-    <version>4.4.8</version>
+    <version>5.0.0-SNAPSHOT</version>
   </parent>
   <artifactId>core-api-lib-quarkus-integration-tests</artifactId>
   <name>Core Api Lib Quarkus - Integration Tests</name>
diff --git a/software/libs/core-api-lib-quarkus/pom.xml b/software/libs/core-api-lib-quarkus/pom.xml
index dc42836af..92e09f95d 100644
--- a/software/libs/core-api-lib-quarkus/pom.xml
+++ b/software/libs/core-api-lib-quarkus/pom.xml
@@ -7,7 +7,7 @@
 	<modelVersion>4.0.0</modelVersion>
 	<groupId>tech.epic-breakfast-productions.openquartermaster.lib.core</groupId>
 	<artifactId>core-api-lib-quarkus-parent</artifactId>
-	<version>4.4.8</version>
+	<version>5.0.0-SNAPSHOT</version>
 	<packaging>pom</packaging>
 	<name>Core Api Lib Quarkus - Parent</name>
 	<description>The parent pom package for the Core API Library for Quarkus.</description>
diff --git a/software/libs/core-api-lib-quarkus/runtime/pom.xml b/software/libs/core-api-lib-quarkus/runtime/pom.xml
index 68a068630..318c601b1 100644
--- a/software/libs/core-api-lib-quarkus/runtime/pom.xml
+++ b/software/libs/core-api-lib-quarkus/runtime/pom.xml
@@ -8,7 +8,7 @@
 	<parent>
 		<groupId>tech.epic-breakfast-productions.openquartermaster.lib.core</groupId>
 		<artifactId>core-api-lib-quarkus-parent</artifactId>
-		<version>4.4.8</version>
+		<version>5.0.0-SNAPSHOT</version>
 	</parent>
 	<artifactId>core-api-lib-quarkus</artifactId>
 	<name>Core Api Lib Quarkus - Runtime</name>
diff --git a/software/libs/core-api-lib-quarkus/runtime/src/main/java/tech/ebp/oqm/lib/core/api/quarkus/runtime/restClient/searchObjects/StoredSearch.java b/software/libs/core-api-lib-quarkus/runtime/src/main/java/tech/ebp/oqm/lib/core/api/quarkus/runtime/restClient/searchObjects/StoredSearch.java
index b5040758c..bb0bda9d8 100644
--- a/software/libs/core-api-lib-quarkus/runtime/src/main/java/tech/ebp/oqm/lib/core/api/quarkus/runtime/restClient/searchObjects/StoredSearch.java
+++ b/software/libs/core-api-lib-quarkus/runtime/src/main/java/tech/ebp/oqm/lib/core/api/quarkus/runtime/restClient/searchObjects/StoredSearch.java
@@ -1,5 +1,6 @@
 package tech.ebp.oqm.lib.core.api.quarkus.runtime.restClient.searchObjects;
 
+import jakarta.ws.rs.DefaultValue;
 import jakarta.ws.rs.PathParam;
 import jakarta.ws.rs.QueryParam;
 import lombok.Getter;
@@ -18,6 +19,10 @@
 @SuperBuilder(toBuilder = true)
 public class StoredSearch extends SearchKeyAttObject {
 	
+	@QueryParam("storedState")
+	@DefaultValue("STORED")
+	String storedState;
+	
 	@QueryParam("itemId") String inventoryItemIdFromQuery;
 	@QueryParam("blockId") String storageBlockIdFromQuery;
 

From 3ddfee55570b2e595980eb857b2d245059caccc4 Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Tue, 19 May 2026 00:34:35 -0400
Subject: [PATCH 29/48] Core - Base Station - version bump for dev

---
 software/core/oqm-core-base-station/build.gradle | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/software/core/oqm-core-base-station/build.gradle b/software/core/oqm-core-base-station/build.gradle
index 1d2c0f446..9779c41c9 100644
--- a/software/core/oqm-core-base-station/build.gradle
+++ b/software/core/oqm-core-base-station/build.gradle
@@ -5,7 +5,7 @@ plugins {
 }
 
 group 'com.ebp.openQuarterMaster'
-version '1.17.1'
+version '1.18.0-SNAPSHOT'
 
 repositories {
     mavenCentral()
@@ -32,7 +32,7 @@ dependencies {
     implementation 'io.quarkus:quarkus-scheduler'
 
     implementation 'tech.epic-breakfast-productions.openquartermaster.lib.core:core-characteristics-lib-quarkus:1.0.1'
-    implementation 'tech.epic-breakfast-productions.openquartermaster.lib.core:core-api-lib-quarkus:4.4.8'
+    implementation 'tech.epic-breakfast-productions.openquartermaster.lib.core:core-api-lib-quarkus:5.0.0-SNAPSHOT'
 
     implementation 'org.apache.commons:commons-io:1.3.2'
     implementation 'org.apache.commons:commons-text:1.15.0'

From 9ac14ba8858a484c8a649279ba25e9d674eca540 Mon Sep 17 00:00:00 2001
From: axgiri <146159445+axgiri@users.noreply.github.com>
Date: Tue, 19 May 2026 23:19:41 +0200
Subject: [PATCH 30/48] static implementation defined in MongoService

---
 .../oqm/core/api/service/mongo/MongoDbAwareService.java  | 6 +-----
 .../ebp/oqm/core/api/service/mongo/MongoService.java     | 9 +++++++++
 .../oqm/core/api/service/mongo/TopLevelMongoService.java | 7 +------
 3 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/MongoDbAwareService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/MongoDbAwareService.java
index 1a086c4ef..006e916e0 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/MongoDbAwareService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/MongoDbAwareService.java
@@ -183,11 +183,7 @@ public List<Bson> getDbIndexes() {
 	}
 
 	public void initDbByIdOrName(String oqmDbIdOrName) {
-		IndexOptions options = new IndexOptions().unique(true).background(true);
-		List<Bson> indexes = this.getDbIndexes();
-		for (Bson index : indexes) {
-			getDocumentCollection(oqmDbIdOrName).createIndex(index, options);
-		}
+		setupIndexes(getDocumentCollection(oqmDbIdOrName), this.getDbIndexes());
 	}
 
 	public void initDb(){
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/MongoService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/MongoService.java
index 356a9823f..03187b0e2 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/MongoService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/MongoService.java
@@ -7,6 +7,8 @@
 import com.mongodb.WriteConcern;
 import com.mongodb.client.ClientSession;
 import com.mongodb.client.MongoClient;
+import com.mongodb.client.MongoCollection;
+import com.mongodb.client.model.IndexOptions;
 import jakarta.inject.Inject;
 import jakarta.validation.Validation;
 import jakarta.validation.Validator;
@@ -111,4 +113,11 @@ public MongoService(Class<T> clazz) {
 	public abstract List<Bson> getDbIndexes();
 
 	public abstract void initDb();
+
+	protected static void setupIndexes(MongoCollection<?> collection, List<Bson> indexes) {
+		IndexOptions options = new IndexOptions().background(true);
+		for (Bson index : indexes) {
+			collection.createIndex(index, options);
+		}
+	}
 }
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/TopLevelMongoService.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/TopLevelMongoService.java
index 4f2d8eed0..31036922a 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/TopLevelMongoService.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/TopLevelMongoService.java
@@ -212,11 +212,6 @@ public List<Bson> getDbIndexes() {
 
 	@Override
 	public void initDb() {
-		//add indexes as unique?
-		IndexOptions options = new IndexOptions().background(true);
-		List<Bson> indexes = this.getDbIndexes();
-		for (Bson index : indexes) {
-			this.getDocumentCollection().createIndex(index, options);
-		}
+		setupIndexes(getDocumentCollection(), this.getDbIndexes());
 	}
 }

From 6faf287a5aeef6d2953b410995ddd3c71d31dce7 Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Tue, 19 May 2026 23:17:48 -0400
Subject: [PATCH 31/48] Core - Base Station - Fixed search result tweaks for
 stored results

---
 .../inventory/ItemCheckoutPassthrough.java       |  2 +-
 .../inventory/ItemInBlockPassthrough.java        |  2 +-
 .../inventory/ItemStoredPassthrough.java         |  3 ++-
 .../interfaces/ui/pages/ItemCheckoutUi.java      |  2 +-
 .../interfaces/ui/pages/OverviewUi.java          |  6 ++++--
 .../service/modelTweak/SearchResultTweak.java    | 16 ++++++++++++----
 6 files changed, 21 insertions(+), 10 deletions(-)

diff --git a/software/core/oqm-core-base-station/src/main/java/tech/ebp/oqm/core/baseStation/interfaces/rest/passthrough/inventory/ItemCheckoutPassthrough.java b/software/core/oqm-core-base-station/src/main/java/tech/ebp/oqm/core/baseStation/interfaces/rest/passthrough/inventory/ItemCheckoutPassthrough.java
index bd88e1959..a72b20723 100644
--- a/software/core/oqm-core-base-station/src/main/java/tech/ebp/oqm/core/baseStation/interfaces/rest/passthrough/inventory/ItemCheckoutPassthrough.java
+++ b/software/core/oqm-core-base-station/src/main/java/tech/ebp/oqm/core/baseStation/interfaces/rest/passthrough/inventory/ItemCheckoutPassthrough.java
@@ -70,7 +70,7 @@ public Uni<Response> search(
 		return this.handleCall(
 			this.processSearchResults(
 				this.getOqmCoreApiClient().itemCheckoutSearch(this.getBearerHeaderStr(), this.getSelectedDb(), itemCheckoutSearch)
-					.call(results->searchResultTweak.addStorageBlockLabelToSearchResult(results, this.getSelectedDb(), "fromBlock", this.getBearerHeaderStr()))
+					.call(results->searchResultTweak.addStorageBlockLabelToSearchResult(results, this.getSelectedDb(), this.getBearerHeaderStr(), "fromBlock"))
 					.call(results->searchResultTweak.addItemNameToSearchResult(results, this.getSelectedDb(), "item", this.getBearerHeaderStr()))
 					.call(results->searchResultTweak.addCreatedByInteractingEntityRefToCheckoutSearchResult(results, this.getSelectedDb(), this.getBearerHeaderStr()))
 					.call(results->searchResultTweak.addInteractingEntityRefToCheckoutSearchResult(results, this.getBearerHeaderStr()))
diff --git a/software/core/oqm-core-base-station/src/main/java/tech/ebp/oqm/core/baseStation/interfaces/rest/passthrough/inventory/ItemInBlockPassthrough.java b/software/core/oqm-core-base-station/src/main/java/tech/ebp/oqm/core/baseStation/interfaces/rest/passthrough/inventory/ItemInBlockPassthrough.java
index 12011ca06..5bd9279f8 100644
--- a/software/core/oqm-core-base-station/src/main/java/tech/ebp/oqm/core/baseStation/interfaces/rest/passthrough/inventory/ItemInBlockPassthrough.java
+++ b/software/core/oqm-core-base-station/src/main/java/tech/ebp/oqm/core/baseStation/interfaces/rest/passthrough/inventory/ItemInBlockPassthrough.java
@@ -76,7 +76,7 @@ public Uni<Response> searchInBlock(
 			this.processSearchResults(
 				this.getOqmCoreApiClient()
 					.invItemStoredInBlockSearch(this.getBearerHeaderStr(), this.getSelectedDb(), this.getItemId(), this.getBlockId(), storedSearch)
-					.call(results->searchResultTweak.addStorageBlockLabelToSearchResult(results, this.getSelectedDb(), "storageBlock", this.getBearerHeaderStr()))
+					.call(results->searchResultTweak.addStorageBlockLabelToSearchResult(results, this.getSelectedDb(), this.getBearerHeaderStr(), "state", "storageBlock"))
 					.call(results->searchResultTweak.addItemNameToSearchResult(results, this.getSelectedDb(), "item", this.getBearerHeaderStr()))
 				,
 				this.searchResultTemplate
diff --git a/software/core/oqm-core-base-station/src/main/java/tech/ebp/oqm/core/baseStation/interfaces/rest/passthrough/inventory/ItemStoredPassthrough.java b/software/core/oqm-core-base-station/src/main/java/tech/ebp/oqm/core/baseStation/interfaces/rest/passthrough/inventory/ItemStoredPassthrough.java
index 7fecf6a56..4a3120a41 100644
--- a/software/core/oqm-core-base-station/src/main/java/tech/ebp/oqm/core/baseStation/interfaces/rest/passthrough/inventory/ItemStoredPassthrough.java
+++ b/software/core/oqm-core-base-station/src/main/java/tech/ebp/oqm/core/baseStation/interfaces/rest/passthrough/inventory/ItemStoredPassthrough.java
@@ -70,7 +70,8 @@ public Uni<Response> search(
 						return this.processSearchResults(
 							this.getOqmCoreApiClient()
 								.invItemStoredSearch(this.getBearerHeaderStr(), this.getSelectedDb(), this.getItemId(), storedSearch)
-								.call(results->searchResultTweak.addStorageBlockLabelToSearchResult(results, this.getSelectedDb(), "storageBlock", this.getBearerHeaderStr()))
+								.call(results->searchResultTweak.addStorageBlockLabelToSearchResult(results, this.getSelectedDb(), this.getBearerHeaderStr(), "state",
+									"storageBlock"))
 								.call(results->searchResultTweak.addItemNameToSearchResult(results, this.getSelectedDb(), "item", this.getBearerHeaderStr()))
 							,
 							this.searchResultTemplate
diff --git a/software/core/oqm-core-base-station/src/main/java/tech/ebp/oqm/core/baseStation/interfaces/ui/pages/ItemCheckoutUi.java b/software/core/oqm-core-base-station/src/main/java/tech/ebp/oqm/core/baseStation/interfaces/ui/pages/ItemCheckoutUi.java
index 41809075b..307529812 100644
--- a/software/core/oqm-core-base-station/src/main/java/tech/ebp/oqm/core/baseStation/interfaces/ui/pages/ItemCheckoutUi.java
+++ b/software/core/oqm-core-base-station/src/main/java/tech/ebp/oqm/core/baseStation/interfaces/ui/pages/ItemCheckoutUi.java
@@ -61,7 +61,7 @@ public Uni<Response> itemCheckoutPage(@BeanParam ItemCheckoutSearch search) {
 			Map.of(
 				"allCategorySearchResults", this.coreApiClient.itemCatSearch(this.getBearerHeaderStr(), this.getSelectedDb(), new ItemCategorySearch()),
 				"searchResults", this.coreApiClient.itemCheckoutSearch(this.getBearerHeaderStr(), this.getSelectedDb(), search)
-					.call(results -> searchResultTweak.addStorageBlockLabelToSearchResult(results, this.getSelectedDb(), "fromBlock", this.getBearerHeaderStr()))
+					.call(results -> searchResultTweak.addStorageBlockLabelToSearchResult(results, this.getSelectedDb(), this.getBearerHeaderStr(), "fromBlock"))
 					.call(results -> searchResultTweak.addItemNameToSearchResult(results, this.getSelectedDb(), "item", this.getBearerHeaderStr()))
 					.call(results -> searchResultTweak.addCreatedByInteractingEntityRefToCheckoutSearchResult(results, this.getSelectedDb(), this.getBearerHeaderStr()))
 					.call(results -> searchResultTweak.addInteractingEntityRefToCheckoutSearchResult(results, this.getBearerHeaderStr()))
diff --git a/software/core/oqm-core-base-station/src/main/java/tech/ebp/oqm/core/baseStation/interfaces/ui/pages/OverviewUi.java b/software/core/oqm-core-base-station/src/main/java/tech/ebp/oqm/core/baseStation/interfaces/ui/pages/OverviewUi.java
index 0aa232b80..4fc157d14 100644
--- a/software/core/oqm-core-base-station/src/main/java/tech/ebp/oqm/core/baseStation/interfaces/ui/pages/OverviewUi.java
+++ b/software/core/oqm-core-base-station/src/main/java/tech/ebp/oqm/core/baseStation/interfaces/ui/pages/OverviewUi.java
@@ -103,10 +103,12 @@ public Uni<Response> overview(
 				"storageCollectionStats", this.coreApiClient.storageBlockCollectionStats(this.getBearerHeaderStr(), this.getSelectedDb()),
 				"parentBlocks", this.coreApiClient.storageBlockSearch(this.getBearerHeaderStr(), this.getSelectedDb(), treeBlockSearch),
 				"expiredResults", this.coreApiClient.invItemStoredSearch(this.getBearerHeaderStr(), this.getSelectedDb(), expiredSearch)
-									  .call(results->searchResultTweak.addStorageBlockLabelToSearchResult(results, this.getSelectedDb(), "storageBlock", this.getBearerHeaderStr()))
+									  .call(results->searchResultTweak.addStorageBlockLabelToSearchResult(results, this.getSelectedDb(), this.getBearerHeaderStr(), "state",
+										  "storageBlock"))
 									  .call(results->searchResultTweak.addItemNameToSearchResult(results, this.getSelectedDb(), "item", this.getBearerHeaderStr())),
 				"expiryWarnResults", this.coreApiClient.invItemStoredSearch(this.getBearerHeaderStr(), this.getSelectedDb(), expiringSearch)
-										 .call(results->searchResultTweak.addStorageBlockLabelToSearchResult(results, this.getSelectedDb(), "storageBlock", this.getBearerHeaderStr()))
+										 .call(results->searchResultTweak.addStorageBlockLabelToSearchResult(results, this.getSelectedDb(), this.getBearerHeaderStr(), "state",
+											 "storageBlock"))
 										 .call(results->searchResultTweak.addItemNameToSearchResult(results, this.getSelectedDb(), "item", this.getBearerHeaderStr())),
 				"lowStockResults", this.coreApiClient.invItemSearch(this.getBearerHeaderStr(), this.getSelectedDb(), lowStockSearch),
 				"currency", this.coreApiClient.getCurrency(this.getBearerHeaderStr()),
diff --git a/software/core/oqm-core-base-station/src/main/java/tech/ebp/oqm/core/baseStation/service/modelTweak/SearchResultTweak.java b/software/core/oqm-core-base-station/src/main/java/tech/ebp/oqm/core/baseStation/service/modelTweak/SearchResultTweak.java
index 8f80421f7..68d8227e1 100644
--- a/software/core/oqm-core-base-station/src/main/java/tech/ebp/oqm/core/baseStation/service/modelTweak/SearchResultTweak.java
+++ b/software/core/oqm-core-base-station/src/main/java/tech/ebp/oqm/core/baseStation/service/modelTweak/SearchResultTweak.java
@@ -28,7 +28,15 @@ public class SearchResultTweak {
 	@Getter
 	OqmCoreApiClientService oqmCoreApiClient;
 	
-	public Uni<ObjectNode> addStorageBlockLabelToSearchResult(ObjectNode searchResults, String oqmDb, String key, String apiToken) {
+	private JsonNode nodeFromKeys(JsonNode node, boolean includeLast, String... keys){
+		JsonNode curNode = node;
+		for(int i = 0; i < (includeLast ? keys.length : keys.length - 1); i++){
+			curNode = curNode.get(keys[i]);
+		}
+		return curNode;
+	}
+	
+	public Uni<ObjectNode> addStorageBlockLabelToSearchResult(ObjectNode searchResults, String oqmDb, String apiToken, String... keys) {
 		if (searchResults.get("empty").asBoolean()) {
 			return Uni.createFrom().item(searchResults);
 		}
@@ -37,7 +45,7 @@ public Uni<ObjectNode> addStorageBlockLabelToSearchResult(ObjectNode searchResul
 		for (JsonNode curResult : searchResults.get("results")) {
 			//TODO:: this is probably bad for performance
 			resultIdMap.merge(
-				curResult.get(key).asText(),
+				this.nodeFromKeys(curResult, true, keys).asText(),
 				List.of((ObjectNode) curResult),
 				(objectNodes, collection)->Stream.concat(objectNodes.stream(), collection.stream()).toList()
 			);
@@ -53,11 +61,11 @@ public Uni<ObjectNode> addStorageBlockLabelToSearchResult(ObjectNode searchResul
 		return uniJoinBuilder.joinAll()
 				   .andCollectFailures()
 				   .map((List<ObjectNode> resultList)->{
-					   String newFieldName = key + "-labelText";
+					   String newFieldName = keys[keys.length - 1] + "-labelText";
 					   for (ObjectNode curStorageBlock : resultList) {
 						   String curLabelText = curStorageBlock.get("labelText").asText();
 						   for (ObjectNode curResult : resultIdMap.get(curStorageBlock.get("id").asText())) {
-							   curResult.put(newFieldName, curLabelText);
+							   ((ObjectNode)this.nodeFromKeys(curResult, false, keys)).put(newFieldName, curLabelText);
 						   }
 					   }
 					   return searchResults;

From b5d949fd7572098bee3e363b655816b1753fe327 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 20 May 2026 03:27:40 +0000
Subject: [PATCH 32/48] Bump com.microsoft.playwright:playwright

Bumps [com.microsoft.playwright:playwright](https://github.com/microsoft/playwright-java) from 1.59.0 to 1.60.0.
- [Release notes](https://github.com/microsoft/playwright-java/releases)
- [Commits](https://github.com/microsoft/playwright-java/compare/v1.59.0...v1.60.0)

---
updated-dependencies:
- dependency-name: com.microsoft.playwright:playwright
  dependency-version: 1.60.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 software/core/oqm-core-base-station/build.gradle | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/software/core/oqm-core-base-station/build.gradle b/software/core/oqm-core-base-station/build.gradle
index 1d2c0f446..e469df42e 100644
--- a/software/core/oqm-core-base-station/build.gradle
+++ b/software/core/oqm-core-base-station/build.gradle
@@ -49,7 +49,7 @@ dependencies {
     testImplementation 'io.rest-assured:rest-assured'
     testImplementation 'net.datafaker:datafaker:2.5.4'
 
-    testImplementation 'com.microsoft.playwright:playwright:1.59.0'
+    testImplementation 'com.microsoft.playwright:playwright:1.60.0'
     testImplementation 'com.deque.html.axe-core:playwright:4.11.3'
 }
 

From cd1b9143f7a85fff61d3380efc0843288ec2f885 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 20 May 2026 03:27:41 +0000
Subject: [PATCH 33/48] Bump tech.units:indriya in /software/core/oqm-core-api

Bumps [tech.units:indriya](https://github.com/unitsofmeasurement/indriya) from 2.2.3 to 2.2.4.
- [Release notes](https://github.com/unitsofmeasurement/indriya/releases)
- [Commits](https://github.com/unitsofmeasurement/indriya/compare/2.2.3...2.2.4)

---
updated-dependencies:
- dependency-name: tech.units:indriya
  dependency-version: 2.2.4
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 software/core/oqm-core-api/build.gradle | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/software/core/oqm-core-api/build.gradle b/software/core/oqm-core-api/build.gradle
index ff8a46dda..13e30a3fe 100644
--- a/software/core/oqm-core-api/build.gradle
+++ b/software/core/oqm-core-api/build.gradle
@@ -44,7 +44,7 @@ dependencies {
 
 	// https://mvnrepository.com/artifact/tech.units/indriya
 	//     https://unitsofmeasurement.gitbook.io/uom-guide/getting-started/getting-started-with-indriya
-	implementation 'tech.units:indriya:2.2.3'
+	implementation 'tech.units:indriya:2.2.4'
 	implementation 'systems.uom:systems-common:2.2'
 	// https://mvnrepository.com/artifact/tech.uom.lib/uom-lib-jackson
 	implementation 'tech.uom.lib:uom-lib-jackson:2.1'

From 0e2ac71a2b4caabf631293dff161d79bc68c4a44 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 20 May 2026 03:27:44 +0000
Subject: [PATCH 34/48] Bump org.junit.jupiter:junit-jupiter-params

Bumps [org.junit.jupiter:junit-jupiter-params](https://github.com/junit-team/junit-framework) from 6.0.3 to 6.1.0.
- [Release notes](https://github.com/junit-team/junit-framework/releases)
- [Commits](https://github.com/junit-team/junit-framework/compare/r6.0.3...r6.1.0)

---
updated-dependencies:
- dependency-name: org.junit.jupiter:junit-jupiter-params
  dependency-version: 6.1.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 software/core/oqm-core-base-station/build.gradle | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/software/core/oqm-core-base-station/build.gradle b/software/core/oqm-core-base-station/build.gradle
index 1d2c0f446..7d9901449 100644
--- a/software/core/oqm-core-base-station/build.gradle
+++ b/software/core/oqm-core-base-station/build.gradle
@@ -45,7 +45,7 @@ dependencies {
     implementation 'org.webjars:bootstrap:5.3.8'
 
     testImplementation 'io.quarkus:quarkus-junit5'
-    testImplementation "org.junit.jupiter:junit-jupiter-params:6.0.3"
+    testImplementation "org.junit.jupiter:junit-jupiter-params:6.1.0"
     testImplementation 'io.rest-assured:rest-assured'
     testImplementation 'net.datafaker:datafaker:2.5.4'
 

From 0ace2dba278473394b5fb2715adae4f4b5f128e1 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 20 May 2026 03:28:50 +0000
Subject: [PATCH 35/48] Bump ubi9/ubi-minimal in
 /software/plugins/storagotchi/src/main/docker

Bumps ubi9/ubi-minimal from 9.7 to 9.8.

---
updated-dependencies:
- dependency-name: ubi9/ubi-minimal
  dependency-version: '9.8'
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 software/plugins/storagotchi/src/main/docker/Dockerfile.native | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/software/plugins/storagotchi/src/main/docker/Dockerfile.native b/software/plugins/storagotchi/src/main/docker/Dockerfile.native
index 15373a17f..1be2b839e 100644
--- a/software/plugins/storagotchi/src/main/docker/Dockerfile.native
+++ b/software/plugins/storagotchi/src/main/docker/Dockerfile.native
@@ -16,7 +16,7 @@
 # The ` registry.access.redhat.com/ubi9/ubi-minimal:9.6` base image is based on UBI 9.
 # To use UBI 8, switch to `quay.io/ubi8/ubi-minimal:8.10`.
 ###
-FROM registry.access.redhat.com/ubi9/ubi-minimal:9.7
+FROM registry.access.redhat.com/ubi9/ubi-minimal:9.8
 WORKDIR /work/
 RUN chown 1001 /work \
     && chmod "g+rwX" /work \

From db5a60c9b440d0b96635cba7f4738f8936a6cfaf Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Tue, 19 May 2026 23:40:13 -0400
Subject: [PATCH 36/48] Core - Base Station - Fixing storage block label
 viewing in storeds

---
 .../resources/res/js/obj/item/ItemView.js     |  2 +-
 .../res/js/obj/itemStored/StoredView.js       | 22 +++++++++----------
 .../tags/search/itemStored/searchResults.html |  2 +-
 3 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/software/core/oqm-core-base-station/src/main/resources/META-INF/resources/res/js/obj/item/ItemView.js b/software/core/oqm-core-base-station/src/main/resources/META-INF/resources/res/js/obj/item/ItemView.js
index d136fd83a..71f5726c1 100644
--- a/software/core/oqm-core-base-station/src/main/resources/META-INF/resources/res/js/obj/item/ItemView.js
+++ b/software/core/oqm-core-base-station/src/main/resources/META-INF/resources/res/js/obj/item/ItemView.js
@@ -464,7 +464,7 @@ export class ItemView extends PageUtility {
 									promises.push(Getters.StorageBlock.getStorageBlockLabel(curBlock, function (labelText) {
 										let newLink = Links.getStorageViewLink(curBlock, labelText);
 
-										if (curBlock === stored.storageBlock) {
+										if (curBlock === stored.state.storageBlock) {
 											storageLabel.find(".uniqueItemStoredInLabel").append(newLink);
 										} else {
 											storageLabel.find(".uniqueItemStoredAlsoInLabel").append(newLink);
diff --git a/software/core/oqm-core-base-station/src/main/resources/META-INF/resources/res/js/obj/itemStored/StoredView.js b/software/core/oqm-core-base-station/src/main/resources/META-INF/resources/res/js/obj/itemStored/StoredView.js
index 5d3b2bd1e..b15e7bf04 100644
--- a/software/core/oqm-core-base-station/src/main/resources/META-INF/resources/res/js/obj/itemStored/StoredView.js
+++ b/software/core/oqm-core-base-station/src/main/resources/META-INF/resources/res/js/obj/itemStored/StoredView.js
@@ -37,25 +37,25 @@ export class StoredView {
 		valueJq.text(value);
 		return StoredView.getBlockViewCell(name, valueJq);
 	}
-	static getStorageBlockTrackedIdentifierView(stored) {
+	static getTrackedIdentifierView(stored) {
 		if (stored.type.includes("UNIQUE")) {
 			return StoredView.getSimpleBlockViewCell("Identifier", stored.identifier);
 		}
 		return "";
 	}
-	static getStorageBlockAmountHeldView(stored, showCurrently = false) {
+	static getAmountHeldView(stored, showCurrently = false) {
 		if (stored.type.includes("AMOUNT")) {
 			return StoredView.getSimpleBlockViewCell((showCurrently ? "Currently " : "") + "Stored:", stored.amount.value + stored.amount.unit.symbol, "storedViewAmount");
 		}
 		return "";
 	}
-	static getStorageBlockIdentifyingDetailsView(stored) {
+	static getIdentifyingDetailsView(stored) {
 		if (stored.type.includes("TRACKED") && stored.identifyingDetails) {
 			return StoredView.getSimpleBlockViewCell("Identifying Details", stored.identifyingDetails);
 		}
 		return "";
 	}
-	static getStorageBlockConditionView(stored) {
+	static getConditionView(stored) {
 		if (stored.condition || stored.conditionNotes) {
 			let conditionJqs = [];
 
@@ -78,7 +78,7 @@ export class StoredView {
 		}
 		return "";
 	}
-	static getStorageBlockExpiresView(stored) {
+	static getExpiresView(stored) {
 		if (stored.expires) {
 			return StoredView.getSimpleBlockViewCell("Expires", stored.expires);
 		}
@@ -230,22 +230,22 @@ export class StoredView {
 
 		if (includeBlockLink) {
 			newContentButtons.append(
-				StoredView.getStoredBlockLink(stored.storageBlock, true)
+				StoredView.getStoredBlockLink(stored.state.storageBlock, true)
 			);
 		}
 
 		if (includeIdentifier) {//TODO:: likely remove, after label rework #1003
 			newContent.append(
-				StoredView.getStorageBlockTrackedIdentifierView(stored)
+				StoredView.getTrackedIdentifierView(stored)
 			);
 		}
 
 		newContentInfo.append(
 			StoredView.getStoredImages(stored),
-			StoredView.getStorageBlockAmountHeldView(stored, showCurrentlyStored),
-			StoredView.getStorageBlockIdentifyingDetailsView(stored),
-			StoredView.getStorageBlockConditionView(stored),
-			StoredView.getStorageBlockExpiresView(stored),
+			StoredView.getAmountHeldView(stored, showCurrentlyStored),
+			StoredView.getIdentifyingDetailsView(stored),
+			StoredView.getConditionView(stored),
+			StoredView.getExpiresView(stored),
 			StoredView.getStoredKeywords(stored),
 			StoredView.getStoredAtts(stored),
 			StoredView.getStoredIdentifiers(stored),
diff --git a/software/core/oqm-core-base-station/src/main/resources/templates/tags/search/itemStored/searchResults.html b/software/core/oqm-core-base-station/src/main/resources/templates/tags/search/itemStored/searchResults.html
index 6535aebd7..ee2659575 100644
--- a/software/core/oqm-core-base-station/src/main/resources/templates/tags/search/itemStored/searchResults.html
+++ b/software/core/oqm-core-base-station/src/main/resources/templates/tags/search/itemStored/searchResults.html
@@ -51,7 +51,7 @@ <h2>
 
     {#if showType}<td>{cdi:EnumFormattingService.formatEnum(result.get("type").asText())}</td>{/if}
     {#if showItem}<td>{result.get("item-name").asText()}</td>{/if}{!TODO:: link this !}
-    {#if showStorage}<td>{result.get("storageBlock-labelText").asText()}</td>{/if}{!TODO:: link !}
+    {#if showStorage}<td>{result.get("state").get("storageBlock-labelText").asText()}</td>{/if}{!TODO:: link !}
     {#if showAmount}
 		<td>
 			{#if cdi:ItemStoredResultsQuteFunctions.storedIsAmount(result)}

From dcfbbaad2c88722d7e7958f88ebcde6f393dcfcd Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Wed, 20 May 2026 00:03:41 -0400
Subject: [PATCH 37/48] Core - Base Station - Updating required core api
 version for snh

---
 .../oqm-core-base-station/installerSrc/installerProperties.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/software/core/oqm-core-base-station/installerSrc/installerProperties.json b/software/core/oqm-core-base-station/installerSrc/installerProperties.json
index 56e30b3ac..4d3389cfe 100644
--- a/software/core/oqm-core-base-station/installerSrc/installerProperties.json
+++ b/software/core/oqm-core-base-station/installerSrc/installerProperties.json
@@ -6,7 +6,7 @@
 	"description": "Base Station instance for Open QuarterMaster.",
 	"homepage": "https://github.com/Epic-Breakfast-Productions/OpenQuarterMaster/tree/main/software/open-qm-base-station",
 	"dependencies": {
-		"deb": "curl, jq, docker.io, oqm-manager-station+captain (>= 2.11.0), oqm-infra-keycloak (>= 2.0.0), oqm-infra-traefik (>= 1.0.0), oqm-core-api (>= 4.4.0), oqm-core-characteristics (>= 1.0.1)",
+		"deb": "curl, jq, docker.io, oqm-manager-station+captain (>= 2.11.0), oqm-infra-keycloak (>= 2.0.0), oqm-infra-traefik (>= 1.0.0), oqm-core-api (>= 5.0.0), oqm-core-characteristics (>= 1.0.1)",
 		"debRec": "oqm-plugin-ext_item_search"
 	},
 	"copyright": {

From 38eb983f7f2be2bcd30b0c8e671b8963c343eca5 Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Wed, 20 May 2026 00:34:56 -0400
Subject: [PATCH 38/48] Core - API - Fixing some openapi definition

---
 .../object/storage/checkout/ItemCheckout.java | 29 +++++++++----------
 .../items/stored/state/StoredInBlock.java     |  5 ++--
 .../items/stored/state/StoredState.java       |  6 ++--
 3 files changed, 19 insertions(+), 21 deletions(-)

diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/checkout/ItemCheckout.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/checkout/ItemCheckout.java
index 4027ce350..bcf8352c3 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/checkout/ItemCheckout.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/checkout/ItemCheckout.java
@@ -16,7 +16,6 @@
 import org.eclipse.microprofile.openapi.annotations.media.Schema;
 import tech.ebp.oqm.core.api.model.object.AttKeywordMainObject;
 import tech.ebp.oqm.core.api.model.object.storage.checkout.checkinDetails.CheckInDetails;
-import tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredState;
 
 import java.time.ZonedDateTime;
 
@@ -40,75 +39,75 @@
 @BsonDiscriminator
 @Schema(oneOf = {ItemAmountCheckout.class, ItemWholeCheckout.class})
 public abstract class ItemCheckout<T> extends AttKeywordMainObject {
-	
+
 	public static final int CUR_SCHEMA_VERSION = 2;
-	
+
 	@ToString.Include
 	public abstract CheckoutType getType();
-	
+
 	@ToString.Include
 	public abstract ObjectId getFromBlock();
-	
+
 	/**
 	 * When these item(s) were checked out
 	 */
 	@lombok.Builder.Default
 	private ZonedDateTime checkoutDate = ZonedDateTime.now();
-	
+
 	/**
 	 * The id of the checked out item
 	 */
 	@NonNull
 	@NotNull
 	private ObjectId item;
-	
+
 	/**
 	 * The transaction that created this checkout.
 	 */
 	@NonNull
 	@NotNull
 	private ObjectId checkOutTransaction;
-	
+
 	/**
 	 * The exact item being checked out
 	 */
 	@NonNull
 	@NotNull
 	private T checkedOut;
-	
+
 	/**
 	 * Which OQM entity did the checking out
 	 */
 	@NonNull
 	@NotNull
 	private ObjectId checkedOutByEntity;
-	
+
 	/**
 	 * Which OQM entity did the checking in
 	 */
 	private ObjectId checkedInByEntity;
-	
+
 	@NotNull
 	@NonNull
 	private CheckoutDetails checkoutDetails;
-	
+
 	/**
 	 * The details of checking back in this checkout.
 	 */
 	@lombok.Builder.Default
 	private CheckInDetails checkInDetails = null;
-	
+
 	/**
 	 * The transaction that checked in this.
 	 */
 	@lombok.Builder.Default
 	private ObjectId checkInTransaction = null;
-	
+
 	@JsonProperty(access = JsonProperty.Access.READ_ONLY)
 	public boolean isStillCheckedOut() {
 		return this.checkInDetails == null;
 	}
-	
+
 	@Override
 	public int getSchemaVersion() {
 		return CUR_SCHEMA_VERSION;
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/state/StoredInBlock.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/state/StoredInBlock.java
index 6935446c2..090d50faa 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/state/StoredInBlock.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/state/StoredInBlock.java
@@ -20,13 +20,14 @@
 @Builder
 @AllArgsConstructor
 @NoArgsConstructor
+@Schema(title = "StoredInBlock", description = "The state to specify this stored is actually stored in a storage block.")
 public class StoredInBlock extends StoredState {
-	
+
 	@Override
 	public StoredStateType getType() {
 		return StoredStateType.STORED;
 	}
-	
+
 	/**
 	 * The {@link StorageBlock} this stored is stored in.
 	 */
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/state/StoredState.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/state/StoredState.java
index b2d463429..1f66e99cb 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/state/StoredState.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/state/StoredState.java
@@ -8,8 +8,6 @@
 import lombok.experimental.SuperBuilder;
 import org.bson.codecs.pojo.annotations.BsonDiscriminator;
 import org.eclipse.microprofile.openapi.annotations.media.Schema;
-import tech.ebp.oqm.core.api.model.object.storage.items.stored.AmountStored;
-import tech.ebp.oqm.core.api.model.object.storage.items.stored.UniqueStored;
 
 @Data
 @SuperBuilder(toBuilder = true)
@@ -21,10 +19,10 @@
 	@JsonSubTypes.Type(value = StoredInBlock.class, name = "STORED")
 })
 @JsonInclude(JsonInclude.Include.ALWAYS)
-@Schema(oneOf = {AmountStored.class, UniqueStored.class})
+@Schema(oneOf = {StoredInBlock.class})
 @BsonDiscriminator
 @NoArgsConstructor
 public abstract class StoredState {
-	
+
 	public abstract StoredStateType getType();
 }

From 71ceead12259578d268d0c7a4a3fe54c45736485 Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Wed, 20 May 2026 01:29:29 -0400
Subject: [PATCH 39/48] Core - Base Station - More fixing to stored things

---
 .../res/js/obj/itemStored/ItemStoredTransaction.js       | 4 ++--
 .../templates/tags/search/itemStored/searchResults.html  | 9 ++++-----
 2 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/software/core/oqm-core-base-station/src/main/resources/META-INF/resources/res/js/obj/itemStored/ItemStoredTransaction.js b/software/core/oqm-core-base-station/src/main/resources/META-INF/resources/res/js/obj/itemStored/ItemStoredTransaction.js
index 921dff777..f349378ef 100644
--- a/software/core/oqm-core-base-station/src/main/resources/META-INF/resources/res/js/obj/itemStored/ItemStoredTransaction.js
+++ b/software/core/oqm-core-base-station/src/main/resources/META-INF/resources/res/js/obj/itemStored/ItemStoredTransaction.js
@@ -1190,7 +1190,7 @@ export class ItemStoredTransaction extends PageUtility {
 					item.storageBlocks.forEach(function (blockId) {
 						let newBlockOption = $('<option></option>');
 						newBlockOption.val(blockId);
-						if (stored && stored.storageBlock === blockId) {
+						if (stored && stored.state.storageBlock === blockId) {
 							newBlockOption.attr("selected", true);
 						}
 						promises.push(Getters.StorageBlock.getStorageBlockLabel(blockId, function (blockLabel) {
@@ -1795,7 +1795,7 @@ export class ItemStoredTransaction extends PageUtility {
 						function (storedInItem) {
 							ItemStoredTransaction.Transfer.fromBlockSelect.find("option").each(function (i, option) {
 								let optionJq = $(option);
-								if (optionJq.val() !== storedInItem.storageBlock) {
+								if (optionJq.val() !== storedInItem.state.storageBlock) {
 									optionJq.prop("disabled", true);
 									optionJq.prop("selected", false);
 								}
diff --git a/software/core/oqm-core-base-station/src/main/resources/templates/tags/search/itemStored/searchResults.html b/software/core/oqm-core-base-station/src/main/resources/templates/tags/search/itemStored/searchResults.html
index ee2659575..a3347613e 100644
--- a/software/core/oqm-core-base-station/src/main/resources/templates/tags/search/itemStored/searchResults.html
+++ b/software/core/oqm-core-base-station/src/main/resources/templates/tags/search/itemStored/searchResults.html
@@ -91,19 +91,18 @@ <h2>
         {#icons/edit}{/icons/edit}
       </button>
       {#itemStored/transaction/buttons/transactionDropdown dropdownClasses="btn-sm me-1" buttonText=false storedId=id itemId=itemId checkinButton=false /}
-      
+
     {#else if actionType == 'select'}
     <td class="d-grid gap-2">
       <button type="button" class="btn btn-sm btn-success" title="Select {labelText}"
               data-bs-toggle="modal" {#if otherModalId??}data-bs-target="#{otherModalId}"{/if}
-              onclick="ItemStoredSearchSelect.selectStoredItem('{labelText}', '{result.get("storageBlock").asText()}', '{id}', '{inputIdPrepend}');">
+              onclick="ItemStoredSearchSelect.selectStoredItem('{labelText}', '{result.get("state").get("storageBlock").asText()}', '{id}', '{inputIdPrepend}');">
         {#icons/select}{/icons/select} Select
       </button>
 	{#else if actionType == 'view'}
 	  <td class="d-grid gap-2">
-		  <a href="{rootPrefix}/items?viewStored={id}" class="btn btn-sm btn-info" title="View Stored">{#icons/view}{/icons/view}</a>
+		  <a href="{rootPrefix}/items?viewStored={id}" class="btn btn-sm btn-info" title="View Stored">{#icons/view /}</a>
       {/if}
-		  
     </td>
   </tr>
   	{/let}
@@ -117,4 +116,4 @@ <h2>
     </td>
   </tr>
   </tfoot>
-      {/let}
\ No newline at end of file
+      {/let}

From e60c2c21725a6404c5acdd5ad509ec256fb68aa3 Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Wed, 20 May 2026 01:45:12 -0400
Subject: [PATCH 40/48] Core - API - Adding to checks for transfer amount
 applier

---
 .../TransferAmountTransactionApplier.java     | 30 ++++++++++++-------
 1 file changed, 20 insertions(+), 10 deletions(-)

diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/TransferAmountTransactionApplier.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/TransferAmountTransactionApplier.java
index 866e3bfcf..0702e324a 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/TransferAmountTransactionApplier.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/TransferAmountTransactionApplier.java
@@ -18,14 +18,16 @@
 import javax.measure.Quantity;
 import java.util.Set;
 
+import static tech.ebp.oqm.core.api.model.object.storage.items.stored.state.StoredStateType.STORED;
+
 @ApplicationScoped
 public class TransferAmountTransactionApplier extends TransactionApplier<TransferAmountTransaction> {
-	
+
 	@Override
 	public TransactionType getTransactionType() {
 		return TransactionType.TRANSFER_AMOUNT;
 	}
-	
+
 	@Override
 	public void apply(
 		String oqmDbIdOrName,
@@ -39,7 +41,7 @@ public void apply(
 	) {
 		AmountStored fromStored;
 		AmountStored toStored;
-		
+
 		switch (inventoryItem.getStorageType()) {
 			case BULK -> {
 				fromStored = this.getStoredService().getSingleStoredForItemBlock(oqmDbIdOrName, cs, inventoryItem.getId(), transaction.getFromBlock(), AmountStored.class);
@@ -71,15 +73,15 @@ public void apply(
 				throw new IllegalArgumentException("Cannot subtract an amount from a unique item.");
 			}
 		}
-		
-		
+
+
 		if (!inventoryItem.getId().equals(toStored.getItem())) {
 			throw new IllegalArgumentException("To Stored is not associated with the item.");
 		}
 		if (!inventoryItem.getId().equals(fromStored.getItem())) {
 			throw new IllegalArgumentException("From Stored is not associated with the item.");
 		}
-		
+
 		if (transaction.getFromStored() != null && !transaction.getFromStored().equals(fromStored.getId())) {
 			throw new IllegalArgumentException("From Stored retrieved not in specified block.");
 		}
@@ -95,20 +97,28 @@ public void apply(
 		if (transaction.getAmount() != null && transaction.isAll()) {
 			throw new IllegalArgumentException("Either amount or all is required, but not both.");
 		}
-		
+
+		if(!fromStored.isState(STORED)) {
+			throw new IllegalArgumentException("Cannot transfer from non-stored item.");
+		}
+		if(!toStored.isState(STORED)) {
+			throw new IllegalArgumentException("Cannot transfer to non-stored item.");
+		}
+
 		Quantity toTransfer = (
 			transaction.isAll() ?
 				fromStored.getAmount() :
 				transaction.getAmount()
 		);
-		
+
+
 		if(toTransfer.getValue().equals(0)){
 			throw new IllegalArgumentException("Amount to transfer must be greater than zero.");
 		}
-		
+
 		fromStored.subtract(toTransfer);
 		toStored.add(toTransfer);
-		
+
 		affectedStored.add(toStored);
 		affectedStored.add(fromStored);
 		this.getStoredService().update(oqmDbIdOrName, cs, fromStored, interactingEntity, historyDetails);

From f40839a715575f3791a236ed94708fff9461074c Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Wed, 20 May 2026 02:18:02 -0400
Subject: [PATCH 41/48] Core - Base Station - eliminating a possible edge case
 that fails tests

---
 .../oqm/core/baseStation/testResources/testUsers/TestUser.java  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/software/core/oqm-core-base-station/src/test/java/tech/ebp/oqm/core/baseStation/testResources/testUsers/TestUser.java b/software/core/oqm-core-base-station/src/test/java/tech/ebp/oqm/core/baseStation/testResources/testUsers/TestUser.java
index 07134b45d..efe17ef4b 100644
--- a/software/core/oqm-core-base-station/src/test/java/tech/ebp/oqm/core/baseStation/testResources/testUsers/TestUser.java
+++ b/software/core/oqm-core-base-station/src/test/java/tech/ebp/oqm/core/baseStation/testResources/testUsers/TestUser.java
@@ -27,7 +27,7 @@ public class TestUser {
 
 	public String getUsername(){
 		if(username == null){
-			return this.firstname + "." + this.lastname;
+			return (this.firstname + "." + this.lastname).replace("'", "");
 		}
 		return this.username;
 	}

From 96b53db4c269d887ede74bf331af64cea3b36002 Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Wed, 20 May 2026 15:07:28 -0400
Subject: [PATCH 42/48] Core - API - Tweaks from review

---
 .../object/storage/items/stored/Stored.java   | 94 +++++++++----------
 .../CheckinFullTransactionApplier.java        | 53 +++++------
 .../appliers/SetAmountTransactionApplier.java | 16 ++--
 3 files changed, 79 insertions(+), 84 deletions(-)

diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/Stored.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/Stored.java
index 344897a6b..99c0df0f1 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/Stored.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/Stored.java
@@ -68,16 +68,16 @@
 @BsonDiscriminator
 @Schema(oneOf = {AmountStored.class, UniqueStored.class})
 public abstract class Stored extends ImagedMainObject implements FileAttachmentContaining {
-	
+
 	public static final int CUR_SCHEMA_VERSION = 5;
-	
+
 	private static final Pattern LABEL_PARTS_PATTERN = Pattern.compile("\\{[^}]*}");
 	private static final String LABEL_PLACEHOLDER_PART_DELIM = ";";
 	private static final String LABEL_PLACEHOLDER_ARG_DELIM = LABEL_PLACEHOLDER_PART_DELIM;
 	private static final String LABEL_ERROR = "#E#";
 	private static final DateTimeFormatter LABEL_DT_DEFAULT_FORMATTER = DateTimeFormatter.ofPattern("MM/dd/yyyy");
-	
-	
+
+
 	/**
 	 *
 	 * Supported format variables:
@@ -122,32 +122,32 @@ public static String parseLabel(Stored stored, String format) {
 		if (format == null || format.isBlank()) {
 			throw new IllegalArgumentException("Format cannot be null, blank, or empty.");
 		}
-		
+
 		if (!format.equals(format.trim())) {
 			throw new IllegalArgumentException("Format cannot contain leading or trailing whitespace.");
 		}
-		
+
 		StringBuilder sb = new StringBuilder();
 		AtomicInteger numPlaceholders = new AtomicInteger();
 		AtomicInteger curStart = new AtomicInteger();
 		AtomicInteger lastEnd = new AtomicInteger();
-		
+
 		LABEL_PARTS_PATTERN.matcher(format).results()
 			.forEach((MatchResult result)->{
 				numPlaceholders.getAndIncrement();
 				sb.append(format, curStart.get(), result.start());
 				curStart.set(result.end());
 				lastEnd.set(result.end());
-				
+
 				String placeholder = result.group();
 				//				log.debug("placeholder: {}", placeholder);
-				
+
 				String[] parts = placeholder.replace("{", "").replace("}", "").split(LABEL_PLACEHOLDER_PART_DELIM, 2);
 				String placeholderType = parts[0].toLowerCase();
 				String[] args = parts.length > 1 ? parts[1].split(LABEL_PLACEHOLDER_ARG_DELIM) : new String[0];
-				
+
 				//				log.debug("placeholderType: {}, args: {}", placeholderType, args);
-				
+
 				switch (placeholderType) {
 					case "id":
 						sb.append(stored.getId());
@@ -159,12 +159,12 @@ public static String parseLabel(Stored stored, String format) {
 						} else {
 							amount = UnitUtils.Quantities.UNIT_ONE;
 						}
-						
+
 						sb.append(amount.toString());
 						break;
 					case "cnd":
 						Integer condition = stored.getCondition();
-						
+
 						sb.append(
 							condition == null ?
 								"-" :
@@ -174,11 +174,11 @@ public static String parseLabel(Stored stored, String format) {
 						break;
 					case "exp":
 						DateTimeFormatter formatter = LABEL_DT_DEFAULT_FORMATTER;
-						
+
 						if (args.length > 0) {
 							formatter = DateTimeFormatter.ofPattern(args[0]);
 						}
-						
+
 						sb.append(
 							stored.getExpires() == null?
 								'-' :
@@ -190,7 +190,7 @@ public static String parseLabel(Stored stored, String format) {
 						if (args.length != 1) {
 							throw new IllegalArgumentException("Must specify exactly one argument for 'ident', and 'price'.");
 						}
-						
+
 						String label = args[0];
 						Optional<Labeled> foundLabel = Labeled.findLabeledInSet(
 							label,
@@ -200,10 +200,10 @@ public static String parseLabel(Stored stored, String format) {
 								default -> new ArrayList<Identifier>(0);
 							}
 						);
-						
+
 						if (foundLabel.isPresent()) {
 							Labeled cur = foundLabel.get();
-							
+
 							if (cur instanceof Identifier) {
 								sb.append(((Identifier) cur).getValue());
 							} else if (cur instanceof CalculatedPricing) {
@@ -217,29 +217,29 @@ public static String parseLabel(Stored stored, String format) {
 						if (args.length != 1) {
 							throw new IllegalArgumentException("Must specify exactly one argument for 'att'.");
 						}
-						
+
 						sb.append(stored.getAttributes().getOrDefault(args[0], LABEL_ERROR));
-						
+
 						break;
 					default:
 						throw new IllegalArgumentException("Unknown placeholder type: '" + placeholderType + "'");
 				}
 			});
-		
+
 		if (numPlaceholders.intValue() == 0) {
 			throw new IllegalArgumentException("No placeholders found in format.");
 		}
-		
+
 		sb.append(format, lastEnd.get(), format.length());
-		
+
 		String newIdentifier = sb.toString();
-		
+
 		return newIdentifier;
 	}
-	
+
 	@Schema(required = true, description = "The type of stored object.")
 	public abstract StoredType getType();
-	
+
 	/**
 	 * The {@link InventoryItem} this stored is associated with.
 	 */
@@ -247,17 +247,17 @@ public static String parseLabel(Stored stored, String format) {
 	@NotNull
 	@Schema(description = "The item that this stored is associated with.")
 	private ObjectId item;
-	
+
 	/**
 	 * The state describing how this item is stored. Example, stored in a storage block, or installed in another item.
 	 */
 	@Schema(description = "The state describing how this item is stored. Example, stored in a storage block, or installed in another item.")
 	private StoredState state;
-	
+
 	public boolean isState(StoredStateType type) {
-		return this.getState().getType().equals(type);
+		return this.getState() != null && this.getState().getType().equals(type);
 	}
-	
+
 	/**
 	 * The general ids that apply to this stored, but not to all stored (as specified in the associated item)
 	 */
@@ -266,14 +266,14 @@ public boolean isState(StoredStateType type) {
 	@lombok.Builder.Default
 	@UniqueLabeledCollection
 	private LinkedHashSet<@NotNull Identifier> identifiers = new LinkedHashSet<>();
-	
+
 	/**
 	 * When the item(s) held expire. Null if it does not expire.
 	 */
 	@lombok.Builder.Default
 	@Schema(required = false, description = "When the item(s) held expire. Null if it does not expire.", examples = {"null", "2022-03-10T12:15:50"})
 	private ZonedDateTime expires = null;
-	
+
 	/**
 	 * Prices for this stored item.
 	 */
@@ -282,12 +282,12 @@ public boolean isState(StoredStateType type) {
 	@lombok.Builder.Default
 	@UniqueLabeledCollection
 	private LinkedHashSet<@NotNull StoredPricing> prices = new LinkedHashSet<>();
-	
+
 	@JsonProperty(access = JsonProperty.Access.READ_ONLY)
 	@Setter(AccessLevel.PRIVATE)
 	@lombok.Builder.Default
 	private LinkedHashSet<@NotNull CalculatedPricing> calculatedPrices = null;
-	
+
 	protected boolean calculatePrices(InventoryItem item) {
 		LinkedHashSet<CalculatedPricing> storedPrices = this.getPrices().stream()
 															.map((p)->p.calculatePrice(this)).collect(Collectors.toCollection(LinkedHashSet::new));
@@ -302,13 +302,13 @@ protected boolean calculatePrices(InventoryItem item) {
 				storedPrices.add(itemPrice.calculatePrice(this).setFromDefault(true));
 			}
 		}
-		
+
 		boolean output = this.getCalculatedPrices() == null || !this.getCalculatedPrices().equals(storedPrices);
 		this.setCalculatedPrices(storedPrices);
-		
+
 		return output;
 	}
-	
+
 	/**
 	 * Statuses about this stored object.
 	 */
@@ -317,7 +317,7 @@ protected boolean calculatePrices(InventoryItem item) {
 	@lombok.Builder.Default
 	@Schema(required = false, description = "State of the notifications sent about this item stored.")
 	private StoredNotificationStatus notificationStatus = new StoredNotificationStatus();
-	
+
 	/**
 	 * The condition of the stored object. 100 = mint, 0 = completely deteriorated. Null if N/A.
 	 */
@@ -326,7 +326,7 @@ protected boolean calculatePrices(InventoryItem item) {
 	@lombok.Builder.Default
 	@Schema(required = false, description = "The condition of the stored object. 100 = mint, 0 = completely deteriorated. Null if N/A.", examples = {"null", "100"})
 	private Integer condition = null;
-	
+
 	/**
 	 * Notes on the condition on the thing(s) stored.
 	 */
@@ -343,10 +343,10 @@ protected boolean calculatePrices(InventoryItem item) {
 	@NotNull
 	@lombok.Builder.Default
 	List<@NotNull ObjectId> imageIds = new ArrayList<>();
-	
+
 	@lombok.Builder.Default
 	private Set<@NotNull ObjectId> attachedFiles = new HashSet<>();
-	
+
 	/**
 	 * The format to use for the label.
 	 * <p>
@@ -357,7 +357,7 @@ protected boolean calculatePrices(InventoryItem item) {
 	@lombok.Builder.Default
 	@ValidStoredLabelFormat
 	private String labelFormat = null;
-	
+
 	/**
 	 * Label format to use if there is not one specified in this stored, or one in the item.
 	 *
@@ -365,13 +365,13 @@ protected boolean calculatePrices(InventoryItem item) {
 	 */
 	@JsonIgnore
 	protected abstract String getDefaultLabelFormat();
-	
+
 	@JsonProperty(access = JsonProperty.Access.READ_ONLY)
 	@Setter(AccessLevel.PRIVATE)
 	@lombok.Builder.Default
 	@Schema(required = false, description = "A generated label text.")
 	private String labelText = null;
-	
+
 	private void processLabel(InventoryItem item) {
 		String labelFormat = this.getLabelFormat();
 		if (labelFormat == null) {
@@ -380,10 +380,10 @@ private void processLabel(InventoryItem item) {
 		if (labelFormat == null) {
 			labelFormat = this.getDefaultLabelFormat();
 		}
-		
+
 		this.labelText = parseLabel(this, labelFormat);
 	}
-	
+
 	public void applyDefaultsFromItem(InventoryItem item) {
 		if (!this.getItem().equals(item.getId())) {
 			throw new IllegalArgumentException("Item ID's do not match");
@@ -391,7 +391,7 @@ public void applyDefaultsFromItem(InventoryItem item) {
 		this.calculatePrices(item);
 		this.processLabel(item);
 	}
-	
+
 	@Override
 	public int getSchemaVersion() {
 		return CUR_SCHEMA_VERSION;
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckinFullTransactionApplier.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckinFullTransactionApplier.java
index 093323194..1c20f6b65 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckinFullTransactionApplier.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckinFullTransactionApplier.java
@@ -24,12 +24,12 @@
 
 @ApplicationScoped
 public class CheckinFullTransactionApplier extends CheckinOutTransactionApplier<CheckinFullTransaction> {
-	
+
 	@Override
 	public TransactionType getTransactionType() {
 		return TransactionType.CHECKIN_FULL;
 	}
-	
+
 	@Override
 	public void apply(
 		String oqmDbIdOrName,
@@ -42,14 +42,14 @@ public void apply(
 		ClientSession cs
 	) {
 		ItemCheckout<?> checkout = this.getItemCheckoutService().get(oqmDbIdOrName, cs, transaction.getCheckoutId());
-		
+
 		if (!inventoryItem.getId().equals(checkout.getItem())) {
 			throw new IllegalArgumentException("Checkout is not associated with the item.");
 		}
 		switch (checkout.getType()) {
 			case AMOUNT -> {
 				ItemAmountCheckout iac = (ItemAmountCheckout) checkout;
-				
+
 				AmountStored amountStored;
 				if (transaction.getToStored() != null) {
 					amountStored = (AmountStored) this.getStoredService().get(oqmDbIdOrName, cs, transaction.getToStored());
@@ -69,54 +69,49 @@ public void apply(
 							}
 						}
 						case AMOUNT_LIST -> {
-							if (transaction.getToStored() == null) {
-								amountStored = AmountStored.builder()
-												   .item(inventoryItem.getId())
-												   .state(StoredInBlock.builder().storageBlock(transaction.getToBlock()).build())
-												   .amount(Quantities.getQuantity(0, inventoryItem.getUnit()))
-												   .build();
-								this.getStoredService().add(oqmDbIdOrName, cs, amountStored, interactingEntity);
-							} else {
-								amountStored = (AmountStored) this.getStoredService().get(oqmDbIdOrName, cs, transaction.getToStored());
-								
-								if(!amountStored.isState(StoredStateType.STORED)){
-									throw new IllegalArgumentException("Cannot check into stored that is not stored.");
-								}
-								
-								if (!((StoredInBlock)amountStored.getState()).getStorageBlock().equals(transaction.getToBlock())) {
-									throw new IllegalArgumentException("To Stored given does not exist in block.");
-								}
-							}
+							amountStored = AmountStored.builder()
+											   .item(inventoryItem.getId())
+											   .state(StoredInBlock.builder().storageBlock(transaction.getToBlock()).build())
+											   .amount(Quantities.getQuantity(0, inventoryItem.getUnit()))
+											   .build();
+							this.getStoredService().add(oqmDbIdOrName, cs, amountStored, interactingEntity);
 						}
 						default -> throw new IllegalArgumentException("Cannot add amount to unique item.");
 					}
 				} else {
 					throw new IllegalArgumentException("Must specify a stored or block to checkin into.");
 				}
-				
+
 				if(!amountStored.isState(StoredStateType.STORED)){
 					throw new IllegalArgumentException("Cannot check into stored that is not stored.");
 				}
-				
+
 				if (!inventoryItem.getId().equals(amountStored.getItem())) {
 					throw new IllegalArgumentException("Stored is not associated with the item.");
 				}
-				
+
 				amountStored.add(iac.getCheckedOut());
 				this.getStoredService().update(oqmDbIdOrName, cs, amountStored, interactingEntity, historyDetails);
 				affectedStored.add(amountStored);
 			}
 			case WHOLE -> {
 				Stored checkedOut = ((ItemWholeCheckout) checkout).getCheckedOut();
+
 				if (!inventoryItem.getId().equals(checkedOut.getItem())) {
 					throw new IllegalArgumentException("Stored is not associated with the item.");
 				}
-				
+
 				if(!checkedOut.isState(StoredStateType.STORED)){
 					throw new IllegalArgumentException("Cannot check in stored that is not stored in a block. This should bot happen, is bug.");
 				}
-				
-				((StoredInBlock)checkedOut.getState()).setStorageBlock(transaction.getToBlock());
+
+				ObjectId toBlock = transaction.getToBlock();
+
+				if(toBlock == null){
+					toBlock = ((StoredInBlock)checkedOut.getState()).getStorageBlock();
+				}
+
+				((StoredInBlock)checkedOut.getState()).setStorageBlock(toBlock);
 				this.getStoredService().add(oqmDbIdOrName, cs, checkedOut, interactingEntity, historyDetails);
 				affectedStored.add(checkedOut);
 			}
@@ -124,7 +119,7 @@ public void apply(
 				throw new IllegalArgumentException("Invalid checkout type.");
 			}
 		}
-		
+
 		checkout.setCheckInDetails(transaction.getDetails());
 		checkout.setCheckInTransaction(appliedTransactionId);
 		checkout.setCheckedInByEntity(interactingEntity.getId());
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/SetAmountTransactionApplier.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/SetAmountTransactionApplier.java
index 8df4c6b23..7286a7b94 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/SetAmountTransactionApplier.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/SetAmountTransactionApplier.java
@@ -20,12 +20,12 @@
 
 @ApplicationScoped
 public class SetAmountTransactionApplier extends TransactionApplier<SetAmountTransaction> {
-	
+
 	@Override
 	public TransactionType getTransactionType() {
 		return TransactionType.SET_AMOUNT;
 	}
-	
+
 	@Override
 	public void apply(
 		String oqmDbIdOrName,
@@ -67,11 +67,11 @@ public void apply(
 					throw new IllegalArgumentException("Must specify a stored to set the amount of.");
 				} else {
 					stored = (AmountStored) this.getStoredService().get(oqmDbIdOrName, cs, transaction.getStored());
-					
+
 					if(!stored.isState(StoredStateType.STORED)){
-						throw new IllegalArgumentException("Cannot subtract stored that is not stored in a block.");
+						throw new IllegalArgumentException("Cannot set amount of stored that is not stored in a block.");
 					}
-					
+
 					if (transaction.getBlock() != null && !((StoredInBlock)stored.getState()).getStorageBlock().equals(transaction.getBlock())) {
 						throw new IllegalArgumentException("To Stored given does not exist in block.");
 					}
@@ -81,13 +81,13 @@ public void apply(
 				throw new IllegalArgumentException("Cannot add an amount to a unique item.");
 			}
 		}
-		
+
 		if (!inventoryItem.getId().equals(stored.getItem())) {
 			throw new IllegalArgumentException("Stored is not associated with the item.");
 		}
-		
+
 		stored.setAmount(transaction.getAmount());
-		
+
 		affectedStored.add(stored);
 		this.getStoredService().update(oqmDbIdOrName, cs, stored, interactingEntity, historyDetails);
 	}

From a7ba7275814fd21bd38d89b6f56c5eb6a6249284 Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Thu, 21 May 2026 01:11:16 -0400
Subject: [PATCH 43/48] Lib - Core API for Quarkus - Now using real entity for
 interacting entity get

---
 .../restClient/OqmCoreApiClientService.java   | 191 +++++++++---------
 .../restClient/models/InteractingEntity.java  |  24 +++
 2 files changed, 120 insertions(+), 95 deletions(-)
 create mode 100644 software/libs/core-api-lib-quarkus/runtime/src/main/java/tech/ebp/oqm/lib/core/api/quarkus/runtime/restClient/models/InteractingEntity.java

diff --git a/software/libs/core-api-lib-quarkus/runtime/src/main/java/tech/ebp/oqm/lib/core/api/quarkus/runtime/restClient/OqmCoreApiClientService.java b/software/libs/core-api-lib-quarkus/runtime/src/main/java/tech/ebp/oqm/lib/core/api/quarkus/runtime/restClient/OqmCoreApiClientService.java
index c1880605e..c2db41601 100644
--- a/software/libs/core-api-lib-quarkus/runtime/src/main/java/tech/ebp/oqm/lib/core/api/quarkus/runtime/restClient/OqmCoreApiClientService.java
+++ b/software/libs/core-api-lib-quarkus/runtime/src/main/java/tech/ebp/oqm/lib/core/api/quarkus/runtime/restClient/OqmCoreApiClientService.java
@@ -12,6 +12,7 @@
 import tech.ebp.oqm.lib.core.api.quarkus.runtime.Constants;
 import tech.ebp.oqm.lib.core.api.quarkus.runtime.restClient.files.FileUploadBody;
 import tech.ebp.oqm.lib.core.api.quarkus.runtime.restClient.files.ImportBundleFileBody;
+import tech.ebp.oqm.lib.core.api.quarkus.runtime.restClient.models.InteractingEntity;
 import tech.ebp.oqm.lib.core.api.quarkus.runtime.restClient.otherQueries.DbExportQuery;
 import tech.ebp.oqm.lib.core.api.quarkus.runtime.restClient.searchObjects.*;
 
@@ -24,18 +25,18 @@
 
 @RegisterRestClient(configKey = Constants.CORE_API_CLIENT_NAME)
 public interface OqmCoreApiClientService {
-	
+
 	//<editor-fold desc="Info">
 	@GET
 	@Path("/q/health")
 	Uni<ObjectNode> getApiServerHealth();
-	
+
 	@GET
 	@Path(ROOT_API_ENDPOINT_V1 + "/info/currency")
 	@Produces(MediaType.APPLICATION_JSON)
 	Uni<Currency> getCurrency(@HeaderParam(Constants.AUTH_HEADER_NAME) String token);
 	//</editor-fold>
-	
+
 	//<editor-fold desc="ID Generators">
 	@GET
 	@Path(INV_DB_ROOT_ENDPOINT + "/identifiers/generator")
@@ -44,7 +45,7 @@ Uni<ObjectNode> idGeneratorSearch(
 		@PathParam("oqmDbIdOrName") String oqmDbIdOrName,
 		@BeanParam IdGeneratorSearch storageBlockSearch
 	);
-	
+
 	@POST
 	@Path(INV_DB_ROOT_ENDPOINT + "/identifiers/generator")
 	@Consumes(MediaType.APPLICATION_JSON)
@@ -54,7 +55,7 @@ Uni<ObjectNode> idGeneratorAdd(
 		@PathParam("oqmDbIdOrName") String oqmDbIdOrName,
 		ObjectNode newIdGenerator
 	);
-	
+
 	@GET
 	@Path(INV_DB_ROOT_ENDPOINT + "/identifiers/generator/{generatorId}")
 	Uni<ObjectNode> idGeneratorGet(
@@ -62,7 +63,7 @@ Uni<ObjectNode> idGeneratorGet(
 		@PathParam("oqmDbIdOrName") String oqmDbIdOrName,
 		@PathParam("generatorId") String storageBlockId
 	);
-	
+
 	@PUT
 	@Path(INV_DB_ROOT_ENDPOINT + "/identifiers/generator/{generatorId}")
 	Uni<ObjectNode> idGeneratorUpdate(
@@ -71,7 +72,7 @@ Uni<ObjectNode> idGeneratorUpdate(
 		@PathParam("generatorId") String generatorId,
 		ObjectNode updates
 	);
-	
+
 	@DELETE
 	@Path(INV_DB_ROOT_ENDPOINT + "/identifiers/generator/{generatorId}")
 	@Produces(MediaType.APPLICATION_JSON)
@@ -80,7 +81,7 @@ Uni<ObjectNode> idGeneratorDelete(
 		@PathParam("oqmDbIdOrName") String oqmDbIdOrName,
 		@PathParam("generatorId") String generatorId
 	);
-	
+
 	@GET
 	@Path(INV_DB_ROOT_ENDPOINT + "/identifiers/generator/{generatorId}/history")
 	Uni<ObjectNode> idGeneratorGetHistory(
@@ -89,7 +90,7 @@ Uni<ObjectNode> idGeneratorGetHistory(
 		@PathParam("generatorId") String storageBlockId,
 		@BeanParam HistorySearch historySearch
 	);
-	
+
 	@GET
 	@Path(INV_DB_ROOT_ENDPOINT + "/identifiers/generator/{generatorId}/generate")
 	@Produces(MediaType.APPLICATION_JSON)
@@ -99,69 +100,69 @@ Uni<ObjectNode> idGenerate(
 		@PathParam("generatorId") String generatorId,
 		@QueryParam("num") Integer numToGenerate
 	);
-	
+
 	//</editor-fold>
-	
+
 	//<editor-fold desc="Identifiers">
 	@GET
 	@Path(ROOT_API_ENDPOINT_V1 + "/identifiers/validate/{type}/{identifier}")
 	@Produces(MediaType.APPLICATION_JSON)
 	Uni<ObjectNode> identifierValidateGet(@HeaderParam(Constants.AUTH_HEADER_NAME) String token, @PathParam("type") String type, @PathParam("identifier") String code);
-	
+
 	@GET
 	@Path(ROOT_API_ENDPOINT_V1 + "/identifiers/getIdObject/{identifier}")
 	@Produces(MediaType.APPLICATION_JSON)
 	Uni<ObjectNode> identifierGetObj(@HeaderParam(Constants.AUTH_HEADER_NAME) String token, @PathParam("identifier") String code);
-	
+
 	@GET
 	@Path(ROOT_API_ENDPOINT_V1 + "/media/code/identifier/{type}/{value}/{label}")
 	@Produces("image/svg+xml")
 	Uni<String> identifierGetBarcodeImage(@HeaderParam(Constants.AUTH_HEADER_NAME) String token, @PathParam("type") String generalIdType, @PathParam("value") String data, @PathParam("label") String label);
 	//</editor-fold>
-	
+
 	//<editor-fold desc="Interacting Entity">
 	@GET
 	@Path(ROOT_API_ENDPOINT_V1 + "/interacting-entity")
 	Uni<ObjectNode> interactingEntitySearch(@HeaderParam(Constants.AUTH_HEADER_NAME) String token, @BeanParam InteractingEntitySearch entitySearch);
-	
+
 	@GET
 	@Path(ROOT_API_ENDPOINT_V1 + "/interacting-entity/{id}")
 	Uni<ObjectNode> interactingEntityGet(@HeaderParam(Constants.AUTH_HEADER_NAME) String token, @PathParam("id") String entityId);
-	
+
 	@GET
 	@Path(ROOT_API_ENDPOINT_V1 + "/interacting-entity/{id}/reference")
 	Uni<ObjectNode> interactingEntityGetReference(@HeaderParam(Constants.AUTH_HEADER_NAME) String token, @PathParam("id") String entityId);
-	
+
 	@GET
 	@Path(ROOT_API_ENDPOINT_V1 + "/interacting-entity/self")
-	Uni<ObjectNode> interactingEntityGetSelf(@HeaderParam(Constants.AUTH_HEADER_NAME) String token);
+	Uni<InteractingEntity> interactingEntityGetSelf(@HeaderParam(Constants.AUTH_HEADER_NAME) String token);
 	//</editor-fold>
-	
+
 	//<editor-fold desc="Units">
 	@GET
 	@Path(UNIT_ROOT_ENDPOINT)
 	@PermitAll
 	@Produces(MediaType.APPLICATION_JSON)
 	Uni<ObjectNode> unitGetAll(@HeaderParam(Constants.AUTH_HEADER_NAME) String token);
-	
+
 	@GET
 	@Path(UNIT_ROOT_ENDPOINT + "/dimensions")
 	@PermitAll
 	@Produces(MediaType.APPLICATION_JSON)
 	Uni<ArrayNode> unitGetDimensions(@HeaderParam(Constants.AUTH_HEADER_NAME) String token);
-	
+
 	@GET
 	@Path(UNIT_ROOT_ENDPOINT + "/deriveTypes")
 	@PermitAll
 	@Produces(MediaType.APPLICATION_JSON)
 	Uni<ArrayNode> unitGetDeriveTypes(@HeaderParam(Constants.AUTH_HEADER_NAME) String token);
-	
+
 	@GET
 	@Path(UNIT_ROOT_ENDPOINT + "/compatibility")
 	@PermitAll
 	@Produces(MediaType.APPLICATION_JSON)
 	Uni<ObjectNode> unitGetCompatibleMap(@HeaderParam(Constants.AUTH_HEADER_NAME) String token);
-	
+
 	@GET
 	@Path(UNIT_ROOT_ENDPOINT + "/compatibility/{unit}")
 	@PermitAll
@@ -170,14 +171,14 @@ Uni<ArrayNode> unitGetUnitCompatibleWith(
 		@HeaderParam(Constants.AUTH_HEADER_NAME) String token,
 		@PathParam("unit") String unitString
 	);
-	
+
 	@GET
 	@Path(UNIT_ROOT_ENDPOINT + "/custom")
 	@Produces(MediaType.APPLICATION_JSON)
 	Uni<ObjectNode> unitCustomGetAll(
 		@HeaderParam(Constants.AUTH_HEADER_NAME) String token
 	);
-	
+
 	@POST
 	@Path(UNIT_ROOT_ENDPOINT + "/custom")
 	@Consumes(MediaType.APPLICATION_JSON)
@@ -186,7 +187,7 @@ Uni<String> unitCreateCustomUnit(
 		@HeaderParam(Constants.AUTH_HEADER_NAME) String token,
 		ObjectNode ncur
 	);
-	
+
 	@PUT
 	@Path(UNIT_ROOT_ENDPOINT + "/convert")
 	@Consumes(MediaType.APPLICATION_JSON)
@@ -195,7 +196,7 @@ Uni<String> unitConvertQuantity(
 		JsonNode quantityConvertRequest
 	);
 	//</editor-fold>
-	
+
 	//<editor-fold desc="Storage Blocks">
 	@GET
 	@Path(STORAGE_BLOCK_ROOT_ENDPOINT)
@@ -204,19 +205,19 @@ Uni<ObjectNode> storageBlockSearch(
 		@PathParam("oqmDbIdOrName") String oqmDbIdOrName,
 		@BeanParam StorageBlockSearch storageBlockSearch
 	);
-	
+
 	@POST
 	@Path(STORAGE_BLOCK_ROOT_ENDPOINT)
 	@Consumes(MediaType.APPLICATION_JSON)
 	@Produces(MediaType.APPLICATION_JSON)
 	Uni<ObjectNode> storageBlockAdd(@HeaderParam(Constants.AUTH_HEADER_NAME) String token, @PathParam("oqmDbIdOrName") String oqmDbIdOrName, ObjectNode newStorageBlock);
-	
+
 	@POST
 	@Path(STORAGE_BLOCK_ROOT_ENDPOINT + "/bulk")
 	@Consumes(MediaType.APPLICATION_JSON)
 	@Produces(MediaType.APPLICATION_JSON)
 	Uni<String> storageBlockAddBulk(@HeaderParam(Constants.AUTH_HEADER_NAME) String token, @PathParam("oqmDbIdOrName") String oqmDbIdOrName, ArrayNode newStorageBlocks);
-	
+
 	@GET
 	@Path(STORAGE_BLOCK_ROOT_ENDPOINT + "/tree")
 	@Produces({MediaType.APPLICATION_JSON})
@@ -225,11 +226,11 @@ Uni<ObjectNode> storageBlockTree(
 		@PathParam("oqmDbIdOrName") String oqmDbIdOrName,
 		@QueryParam("onlyInclude") List<String> onlyInclude
 	);
-	
+
 	@GET
 	@Path(STORAGE_BLOCK_ROOT_ENDPOINT + "/stats")
 	Uni<ObjectNode> storageBlockCollectionStats(@HeaderParam(Constants.AUTH_HEADER_NAME) String token, @PathParam("oqmDbIdOrName") String oqmDbIdOrName);
-	
+
 	@GET
 	@Path(STORAGE_BLOCK_ROOT_ENDPOINT + "/{blockId}")
 	Uni<ObjectNode> storageBlockGet(
@@ -237,7 +238,7 @@ Uni<ObjectNode> storageBlockGet(
 		@PathParam("oqmDbIdOrName") String oqmDbIdOrName,
 		@PathParam("blockId") String storageBlockId
 	);
-	
+
 	@PUT
 	@Path(STORAGE_BLOCK_ROOT_ENDPOINT + "/{id}")
 	Uni<ObjectNode> storageBlockUpdate(
@@ -246,7 +247,7 @@ Uni<ObjectNode> storageBlockUpdate(
 		@PathParam("id") String storageBlockId,
 		ObjectNode updates
 	);
-	
+
 	@DELETE
 	@Path(STORAGE_BLOCK_ROOT_ENDPOINT + "/{id}")
 	@Produces(MediaType.APPLICATION_JSON)
@@ -255,7 +256,7 @@ Uni<ObjectNode> storageBlockDelete(
 		@PathParam("oqmDbIdOrName") String oqmDbIdOrName,
 		@PathParam("id") String storageBlockId
 	);
-	
+
 	@GET
 	@Path(STORAGE_BLOCK_ROOT_ENDPOINT + "/{blockId}/history")
 	Uni<ObjectNode> storageBlockGetHistory(
@@ -265,7 +266,7 @@ Uni<ObjectNode> storageBlockGetHistory(
 		@BeanParam HistorySearch historySearch
 	);
 	//</editor-fold>
-	
+
 	//<editor-fold desc="Item Categories">
 	@GET
 	@Path(ITEM_CAT_ROOT_ENDPOINT)
@@ -274,17 +275,17 @@ Uni<ObjectNode> itemCatSearch(
 		@PathParam("oqmDbIdOrName") String oqmDbIdOrName,
 		@BeanParam ItemCategorySearch itemCategorySearch
 	);
-	
+
 	@POST
 	@Path(ITEM_CAT_ROOT_ENDPOINT)
 	@Consumes(MediaType.APPLICATION_JSON)
 	@Produces(MediaType.APPLICATION_JSON)
 	Uni<ObjectNode> itemCatAdd(@HeaderParam(Constants.AUTH_HEADER_NAME) String token, @PathParam("oqmDbIdOrName") String oqmDbIdOrName, ObjectNode newItemCategory);
-	
+
 	@GET
 	@Path(ITEM_CAT_ROOT_ENDPOINT + "/{catId}")
 	Uni<ObjectNode> itemCatGet(@HeaderParam(Constants.AUTH_HEADER_NAME) String token, @PathParam("oqmDbIdOrName") String oqmDbIdOrName, @PathParam("catId") String itemCatId);
-	
+
 	@PUT
 	@Path(ITEM_CAT_ROOT_ENDPOINT + "/{catId}")
 	Uni<ObjectNode> itemCatUpdate(
@@ -293,12 +294,12 @@ Uni<ObjectNode> itemCatUpdate(
 		@PathParam("catId") String itemCatId,
 		ObjectNode updates
 	);
-	
+
 	@DELETE
 	@Path(ITEM_CAT_ROOT_ENDPOINT + "/{id}")
 	@Produces(MediaType.APPLICATION_JSON)
 	Uni<ObjectNode> itemCatDelete(@HeaderParam(Constants.AUTH_HEADER_NAME) String token, @PathParam("oqmDbIdOrName") String oqmDbIdOrName, @PathParam("id") String itemCatId);
-	
+
 	@GET
 	@Path(ITEM_CAT_ROOT_ENDPOINT + "/{catId}/history")
 	Uni<ObjectNode> itemCatGetHistory(
@@ -307,7 +308,7 @@ Uni<ObjectNode> itemCatGetHistory(
 		@PathParam("catId") String catId,
 		@BeanParam HistorySearch historySearch
 	);
-	
+
 	@GET
 	@Path(ITEM_CAT_ROOT_ENDPOINT + "/tree")
 	@Produces(MediaType.APPLICATION_JSON)
@@ -316,9 +317,9 @@ Uni<ObjectNode> itemCatTree(
 		@PathParam("oqmDbIdOrName") String oqmDbIdOrName,
 		@QueryParam("onlyInclude") List<String> onlyInclude
 	);
-	
+
 	//</editor-fold>
-	
+
 	//<editor-fold desc="Inventory Items">
 	@POST
 	@Path(INV_ITEM_ROOT_ENDPOINT)
@@ -329,7 +330,7 @@ Uni<ObjectNode> invItemCreate(
 		@PathParam("oqmDbIdOrName") String oqmDbIdOrName,
 		ObjectNode item
 	);
-	
+
 	@Path(INV_ITEM_ROOT_ENDPOINT + "/stats")
 	@GET
 	@Produces(MediaType.APPLICATION_JSON)
@@ -337,7 +338,7 @@ Uni<ObjectNode> invItemCollectionStats(
 		@HeaderParam(Constants.AUTH_HEADER_NAME) String token,
 		@PathParam("oqmDbIdOrName") String oqmDbIdOrName
 	);
-	
+
 	@GET
 	@Path(INV_ITEM_ROOT_ENDPOINT)
 	@Produces(MediaType.APPLICATION_JSON)
@@ -347,7 +348,7 @@ Uni<ObjectNode> invItemSearch(
 		//for actual queries
 		@BeanParam InventoryItemSearch itemSearch
 	);
-	
+
 	@GET
 	@Path(INV_ITEM_ROOT_ENDPOINT + "/{itemId}")
 	@Produces(MediaType.APPLICATION_JSON)
@@ -356,7 +357,7 @@ Uni<ObjectNode> invItemGet(
 		@PathParam("oqmDbIdOrName") String oqmDbIdOrName,
 		@PathParam("itemId") String id
 	);
-	
+
 	@PUT
 	@Path(INV_ITEM_ROOT_ENDPOINT + "/{itemId}")
 	@Produces(MediaType.APPLICATION_JSON)
@@ -366,7 +367,7 @@ Uni<ObjectNode> invItemUpdate(
 		@PathParam("itemId") String id,
 		ObjectNode updates
 	);
-	
+
 	@DELETE
 	@Path(INV_ITEM_ROOT_ENDPOINT + "/{itemId}")
 	@Produces(MediaType.APPLICATION_JSON)
@@ -375,7 +376,7 @@ Uni<ObjectNode> invItemDelete(
 		@PathParam("oqmDbIdOrName") String oqmDbIdOrName,
 		@PathParam("itemId") String id
 	);
-	
+
 	@GET
 	@Path(INV_ITEM_ROOT_ENDPOINT + "/{id}/history")
 	@Produces(MediaType.APPLICATION_JSON)
@@ -385,7 +386,7 @@ Uni<ObjectNode> invItemGetHistoryForObject(
 		@PathParam("id") String id,
 		@BeanParam HistorySearch searchObject
 	);
-	
+
 	@GET
 	@Path(INV_ITEM_ROOT_ENDPOINT + "/history")
 	@Produces(MediaType.APPLICATION_JSON)
@@ -394,7 +395,7 @@ Uni<ObjectNode> invItemSearchHistory(
 		@PathParam("oqmDbIdOrName") String oqmDbIdOrName,
 		@BeanParam HistorySearch searchObject
 	);
-	
+
 	@GET
 	@Path(INV_ITEM_ROOT_ENDPOINT + "/{itemId}/block/{storageBlockId}/stored")
 	@Produces(MediaType.APPLICATION_JSON)
@@ -405,7 +406,7 @@ Uni<ObjectNode> invItemStoredInBlockSearch(
 		@PathParam("storageBlockId") String storageBlockId,
 		@BeanParam StoredSearch storedSearch
 	);
-	
+
 	@GET
 	@Path(INV_ITEM_ROOT_ENDPOINT + "/{itemId}/stored")
 	@Produces(MediaType.APPLICATION_JSON)
@@ -415,7 +416,7 @@ Uni<ObjectNode> invItemStoredSearch(
 		@PathParam("itemId") String itemId,
 		@BeanParam StoredSearch storedSearch
 	);
-	
+
 	@GET
 	@Path(INV_ITEM_ROOT_ENDPOINT + "/{itemId}/stored/{storedId}/history")
 	@Produces(MediaType.APPLICATION_JSON)
@@ -426,7 +427,7 @@ Uni<ObjectNode> invItemStoredSearchHistory(
 		@PathParam("storedId") String storedId,
 		HistorySearch search
 	);
-	
+
 	@GET
 	@Path(INV_ITEM_ROOT_ENDPOINT + "/{itemId}/stored/{storedId}")
 	@Produces(MediaType.APPLICATION_JSON)
@@ -436,7 +437,7 @@ Uni<ObjectNode> invItemStoredGet(
 		@PathParam("itemId") String itemId,
 		@PathParam("storedId") String storedId
 	);
-	
+
 	@PUT
 	@Path(INV_ITEM_ROOT_ENDPOINT + "/{itemId}/stored/{storedId}")
 	@Produces(MediaType.APPLICATION_JSON)
@@ -447,7 +448,7 @@ Uni<ObjectNode> invItemStoredUpdate(
 		@PathParam("storedId") String storedId,
 		ObjectNode updateObject
 	);
-	
+
 	@GET
 	@Path(INV_ITEM_ROOT_ENDPOINT + "/{itemId}/stored/history")
 	@Produces(MediaType.APPLICATION_JSON)
@@ -457,7 +458,7 @@ Uni<ObjectNode> invItemStoredSearchAllHistory(
 		@PathParam("itemId") String itemId,
 		HistorySearch search
 	);
-	
+
 	@POST
 	@Path(INV_ITEM_ROOT_ENDPOINT + "/{itemId}/stored/transaction")
 	@Produces(MediaType.APPLICATION_JSON)
@@ -467,7 +468,7 @@ Uni<ObjectNode> invItemStoredTransact(
 		@PathParam("itemId") String itemId,
 		ObjectNode transaction
 	);
-	
+
 	@GET
 	@Path(INV_ITEM_ROOT_ENDPOINT + "/{itemId}/stored/transaction")
 	@Produces(MediaType.APPLICATION_JSON)
@@ -477,7 +478,7 @@ Uni<ObjectNode> invItemStoredTransactionSearch(
 		@PathParam("itemId") String itemId,
 		AppliedTransactionSearch search
 	);
-	
+
 	@GET
 	@Path(INV_ITEM_ROOT_ENDPOINT + "/{itemId}/stored/transaction/{transactionId}")
 	@Produces(MediaType.APPLICATION_JSON)
@@ -524,9 +525,9 @@ Uni<ObjectNode> invItemStoredSearchAllHistory(
 		@PathParam("oqmDbIdOrName") String oqmDbIdOrName,
 		HistorySearch search
 	);
-	
+
 	//</editor-fold>
-	
+
 	//<editor-fold desc="Images">
 	@GET
 	@Path(IMAGE_ROOT_ENDPOINT)
@@ -536,7 +537,7 @@ Uni<ObjectNode> imageSearch(
 		@PathParam("oqmDbIdOrName") String oqmDbIdOrName,
 		@BeanParam ImageSearch searchObject
 	);
-	
+
 	@POST
 	@Path(IMAGE_ROOT_ENDPOINT)
 	@Consumes(MediaType.MULTIPART_FORM_DATA)
@@ -546,7 +547,7 @@ Uni<ObjectNode> imageAdd(
 		@PathParam("oqmDbIdOrName") String oqmDbIdOrName,
 		@BeanParam FileUploadBody body
 	);
-	
+
 	@Path(IMAGE_ROOT_ENDPOINT + "/{id}")
 	@GET
 	@Produces(MediaType.APPLICATION_JSON)
@@ -555,7 +556,7 @@ Uni<ObjectNode> imageGet(
 		@PathParam("oqmDbIdOrName") String oqmDbIdOrName,
 		@PathParam("id") String id
 	);
-	
+
 	@PUT
 	@Path(IMAGE_ROOT_ENDPOINT + "/{id}")
 	@Consumes(MediaType.MULTIPART_FORM_DATA)
@@ -566,7 +567,7 @@ Uni<Integer> imageUpdateFile(
 		@PathParam("id") String id,
 		@BeanParam FileUploadBody body
 	);
-	
+
 	@PUT
 	@Path(IMAGE_ROOT_ENDPOINT + "/{id}")
 	@Consumes(MediaType.APPLICATION_JSON)
@@ -578,7 +579,7 @@ Uni<ObjectNode> imageUpdateObj(
 		String id,
 		ObjectNode updates
 	);
-	
+
 	@Path(IMAGE_ROOT_ENDPOINT + "/{id}/revision/{rev}")
 	@GET
 	@Produces(MediaType.APPLICATION_JSON)
@@ -590,7 +591,7 @@ Uni<ObjectNode> imageGetRevision(
 		@PathParam("rev")
 		String revision
 	);
-	
+
 	@Path(IMAGE_ROOT_ENDPOINT + "/{id}/revision/{rev}/data")
 	@GET
 	@Produces("*/*")
@@ -602,7 +603,7 @@ Uni<InputStream> imageGetRevisionData(
 		@PathParam("rev")
 		String revision
 	);
-	
+
 	@GET
 	@Path(IMAGE_ROOT_ENDPOINT + "/{id}/history")
 	@Produces(MediaType.APPLICATION_JSON)
@@ -612,7 +613,7 @@ Uni<ObjectNode> imageGetHistoryForObject(
 		@PathParam("id") String id,
 		@BeanParam HistorySearch searchObject
 	);
-	
+
 	@GET
 	@Path(IMAGE_ROOT_ENDPOINT + "/history")
 	@Produces(MediaType.APPLICATION_JSON)
@@ -621,7 +622,7 @@ Uni<ObjectNode> imageSearchHistory(
 		@PathParam("oqmDbIdOrName") String oqmDbIdOrName,
 		@BeanParam HistorySearch searchObject
 	);
-	
+
 	//TODO:: what return datatype?
 	@GET
 	@Path(IMAGE_ROOT_ENDPOINT + "/for/{type}/{id}")
@@ -636,7 +637,7 @@ Uni<InputStream> imageForObject(
 		@PathParam("id") String objId
 	);
 	//</editor-fold>
-	
+
 	//<editor-fold desc="File Attachments">
 	@GET
 	@Path(FILE_ATTACHMENT_ROOT_ENDPOINT)
@@ -646,7 +647,7 @@ Uni<ObjectNode> fileAttachmentSearch(
 		@PathParam("oqmDbIdOrName") String oqmDbIdOrName,
 		@BeanParam FileAttachmentSearch searchObject
 	);
-	
+
 	@POST
 	@Path(FILE_ATTACHMENT_ROOT_ENDPOINT)
 	@Consumes(MediaType.MULTIPART_FORM_DATA)
@@ -656,7 +657,7 @@ Uni<ObjectNode> fileAttachmentAdd(
 		@PathParam("oqmDbIdOrName") String oqmDbIdOrName,
 		@BeanParam FileUploadBody body
 	);
-	
+
 	@Path(FILE_ATTACHMENT_ROOT_ENDPOINT + "/{id}")
 	@GET
 	@Produces(MediaType.APPLICATION_JSON)
@@ -665,7 +666,7 @@ Uni<ObjectNode> fileAttachmentGet(
 		@PathParam("oqmDbIdOrName") String oqmDbIdOrName,
 		@PathParam("id") String id
 	);
-	
+
 	@PUT
 	@Path(FILE_ATTACHMENT_ROOT_ENDPOINT + "/{id}")
 	@Consumes(MediaType.MULTIPART_FORM_DATA)
@@ -676,7 +677,7 @@ Uni<Integer> fileAttachmentUpdateFile(
 		@PathParam("id") String id,
 		@BeanParam FileUploadBody body
 	);
-	
+
 	@PUT
 	@Path(FILE_ATTACHMENT_ROOT_ENDPOINT + "/{id}")
 	@Consumes(MediaType.APPLICATION_JSON)
@@ -688,7 +689,7 @@ Uni<ObjectNode> fileAttachmentUpdateObj(
 		String id,
 		ObjectNode updates
 	);
-	
+
 	@GET
 	@Path(FILE_ATTACHMENT_ROOT_ENDPOINT + "/{id}/revision/{rev}")
 	@Produces(MediaType.APPLICATION_JSON)
@@ -700,7 +701,7 @@ Uni<ObjectNode> fileAttachmentGetRevision(
 		@PathParam("rev")
 		String revision
 	);
-	
+
 	@GET
 	@Path(FILE_ATTACHMENT_ROOT_ENDPOINT + "/{id}/revision/{rev}/data")
 	@Produces("*/*")
@@ -712,7 +713,7 @@ Uni<InputStream> fileAttachmentGetRevisionData(
 		@PathParam("rev")
 		String revision
 	);
-	
+
 	@Path(FILE_ATTACHMENT_ROOT_ENDPOINT + "/{id}")
 	@DELETE
 	@Produces(MediaType.APPLICATION_JSON)
@@ -722,7 +723,7 @@ Uni<ObjectNode> fileAttachmentRemove(
 		@PathParam("id")
 		String id
 	);
-	
+
 	@GET
 	@Path(FILE_ATTACHMENT_ROOT_ENDPOINT + "/{id}/history")
 	@Produces(MediaType.APPLICATION_JSON)
@@ -732,7 +733,7 @@ Uni<ObjectNode> fileAttachmentGetHistoryForObject(
 		@PathParam("id") String id,
 		@BeanParam HistorySearch searchObject
 	);
-	
+
 	@GET
 	@Path(FILE_ATTACHMENT_ROOT_ENDPOINT + "/history")
 	@Produces(MediaType.APPLICATION_JSON)
@@ -742,7 +743,7 @@ Uni<SearchObject> fileAttachmentSearchHistory(
 		@BeanParam HistorySearch searchObject
 	);
 	//</editor-fold>
-	
+
 	//<editor-fold desc="Item Checkouts">
 	@GET
 	@Path(ITEM_CHECKOUT_ROOT_ENDPOINT)
@@ -752,7 +753,7 @@ Uni<ObjectNode> itemCheckoutSearch(
 		@PathParam("oqmDbIdOrName") String oqmDbIdOrName,
 		@BeanParam ItemCheckoutSearch itemCheckoutSearch
 	);
-	
+
 	@Path(ITEM_CHECKOUT_ROOT_ENDPOINT + "/{id}")
 	@GET
 	@Produces(MediaType.APPLICATION_JSON)
@@ -761,7 +762,7 @@ Uni<ObjectNode> itemCheckoutGet(
 		@PathParam("oqmDbIdOrName") String oqmDbIdOrName,
 		@PathParam("id") String id
 	);
-	
+
 	@PUT
 	@Path(ITEM_CHECKOUT_ROOT_ENDPOINT + "/{id}")
 	@Produces(MediaType.APPLICATION_JSON)
@@ -771,7 +772,7 @@ Uni<ObjectNode> itemCheckoutUpdate(
 		@PathParam("id") String id,
 		ObjectNode updates
 	);
-	
+
 	@GET
 	@Path(ITEM_CHECKOUT_ROOT_ENDPOINT + "/{id}/history")
 	@Produces(MediaType.APPLICATION_JSON)
@@ -781,7 +782,7 @@ Uni<ObjectNode> itemCheckoutGetHistoryForObject(
 		@PathParam("id") String id,
 		@BeanParam HistorySearch searchObject
 	);
-	
+
 	@GET
 	@Path(ITEM_CHECKOUT_ROOT_ENDPOINT + "/history")
 	@Produces(MediaType.APPLICATION_JSON)
@@ -791,9 +792,9 @@ Uni<ObjectNode> itemCheckoutSearchHistory(
 		@BeanParam HistorySearch searchObject
 	);
 	//</editor-fold>
-	
-	
-	
+
+
+
 	//<editor-fold desc="Inventory Management">
 	@GET
 	@Path(INVENTORY_MANAGE_ROOT_ENDPOINT + "/db/export")
@@ -802,7 +803,7 @@ Uni<Response> manageExportData(
 		@HeaderParam(Constants.AUTH_HEADER_NAME) String token,
 		@BeanParam DbExportQuery exportQuery
 	);
-	
+
 	@POST
 	@Path(INVENTORY_MANAGE_ROOT_ENDPOINT + "/db/import/file/bundle")
 	@Consumes(MediaType.MULTIPART_FORM_DATA)
@@ -811,7 +812,7 @@ Uni<ObjectNode> manageImportData(
 		@HeaderParam(Constants.AUTH_HEADER_NAME) String token,
 		@BeanParam ImportBundleFileBody body
 	);
-	
+
 	@POST
 	@Path(INVENTORY_MANAGE_ROOT_ENDPOINT + "/db")
 	@Consumes(MediaType.APPLICATION_JSON)
@@ -820,20 +821,20 @@ Uni<String> manageDbAdd(
 		@HeaderParam(Constants.AUTH_HEADER_NAME) String token,
 		ObjectNode newDb
 	);
-	
+
 	@GET
 	@Path(INVENTORY_MANAGE_ROOT_ENDPOINT + "/db")
 	@Consumes(MediaType.APPLICATION_JSON)
 	@Produces(MediaType.APPLICATION_JSON)
 	Uni<ArrayNode> manageDbList(@HeaderParam(Constants.AUTH_HEADER_NAME) String token);
-	
+
 	@DELETE
 	@Path(INVENTORY_MANAGE_ROOT_ENDPOINT + "/db/clearAllDbs")
 	@Produces(MediaType.APPLICATION_JSON)
 	Uni<ArrayNode> manageDbClearAll(
 		@HeaderParam(Constants.AUTH_HEADER_NAME) String token
 	);
-	
+
 	@DELETE
 	@Path(INVENTORY_MANAGE_ROOT_ENDPOINT + "/db/clear/{oqmDbIdOrName}")
 	@Produces(MediaType.APPLICATION_JSON)
@@ -842,7 +843,7 @@ Uni<ObjectNode> manageDbClear(
 		@PathParam("oqmDbIdOrName")
 		String oqmDbIdOrName
 	);
-	
+
 	//	@GET
 	//	@Path("processExpiry")
 	//	public Response triggerSearchAndProcessExpiring() {
diff --git a/software/libs/core-api-lib-quarkus/runtime/src/main/java/tech/ebp/oqm/lib/core/api/quarkus/runtime/restClient/models/InteractingEntity.java b/software/libs/core-api-lib-quarkus/runtime/src/main/java/tech/ebp/oqm/lib/core/api/quarkus/runtime/restClient/models/InteractingEntity.java
new file mode 100644
index 000000000..deacc8d5e
--- /dev/null
+++ b/software/libs/core-api-lib-quarkus/runtime/src/main/java/tech/ebp/oqm/lib/core/api/quarkus/runtime/restClient/models/InteractingEntity.java
@@ -0,0 +1,24 @@
+package tech.ebp.oqm.lib.core.api.quarkus.runtime.restClient.models;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class InteractingEntity {
+	private String id;
+	private String idFromAuthProvider;
+	private String authProvider;
+	private String name;
+	private String email;
+	private String type;
+	private Set<String> roles;
+	private List<String> keywords;
+	private Map<String, String> attributes;
+}

From e12be24e3a7834dcdd5cd666e6b62b3306b75bd6 Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Thu, 21 May 2026 01:22:10 -0400
Subject: [PATCH 44/48] Core - Base Station - Fixing getting user info properly

---
 .../interfaces/ui/pages/UiProvider.java       | 53 ++++++++++---------
 .../templates/webui/mainWebPageTemplate.html  | 40 +++++++-------
 2 files changed, 46 insertions(+), 47 deletions(-)

diff --git a/software/core/oqm-core-base-station/src/main/java/tech/ebp/oqm/core/baseStation/interfaces/ui/pages/UiProvider.java b/software/core/oqm-core-base-station/src/main/java/tech/ebp/oqm/core/baseStation/interfaces/ui/pages/UiProvider.java
index c9a3feae9..db32c3dca 100644
--- a/software/core/oqm-core-base-station/src/main/java/tech/ebp/oqm/core/baseStation/interfaces/ui/pages/UiProvider.java
+++ b/software/core/oqm-core-base-station/src/main/java/tech/ebp/oqm/core/baseStation/interfaces/ui/pages/UiProvider.java
@@ -1,5 +1,6 @@
 package tech.ebp.oqm.core.baseStation.interfaces.ui.pages;
 
+import com.fasterxml.jackson.databind.node.ArrayNode;
 import com.fasterxml.jackson.databind.node.ObjectNode;
 import io.opentelemetry.api.trace.Span;
 import io.quarkus.qute.Template;
@@ -25,21 +26,21 @@ public abstract class UiProvider extends RestInterface {
 	@Getter
 	@HeaderParam("x-forwarded-prefix")
 	Optional<String> forwardedPrefix;
-	
+
 	@Inject
 	Span span;
-	
+
 	@Inject
 	OqmCoreCharacteristicsService oqmCoreCharacteristicsService;
-	
+
 	protected String getRootPrefix(){
 		return this.forwardedPrefix.orElse("");
 	}
-	
+
 	protected int getDefaultPageSize(){
 		return 25;
 	}
-	
+
 	protected void ensureSearchDefaults(SearchObject searchObject){
 		if(searchObject.getPageNum() == null || searchObject.getPageNum() < 1){
 			searchObject.setPageNum(1);
@@ -48,62 +49,62 @@ protected void ensureSearchDefaults(SearchObject searchObject){
 			searchObject.setPageSize(this.getDefaultPageSize());
 		}
 	}
-	
+
 	protected abstract Template getPageTemplate();
-	
+
 	protected TemplateInstance setupPageTemplate(Template template) {
 		return template
 				   .data("rootPrefix", this.getRootPrefix())
-				   .data("userInfo", this.getUserInfo())
 				   .data("userToken", this.getUserTokenStr())
 				   .data("oqmDbs", this.getOqmDatabases())
 				   .data("selectedOqmDb", this.getSelectedDb())
 				   .data("traceId", this.span.getSpanContext().getTraceId())
 				   ;
 	}
-	
+
 	protected TemplateInstance setupPageTemplate() {
 		return this.setupPageTemplate(this.getPageTemplate());
 	}
-	
+
 	protected Uni<Response> getUni(TemplateInstance pageTemplate, Map<String, Uni> uniMap) {
 //		Uni<Object> userInfoUni = this.getOqmCoreApiClient().interactingEntityGetSelf(this.getBearerHeaderStr())
 //										.map((ObjectNode userInfoJs)->{
 //											return getUserInfo().setId(userInfoJs.get("id").toString().replaceAll("\"", ""));
 //										});
-		
+
 //		uniMap.put("characteristics", this.oqmCoreCharacteristicsService.allInfo());
-		
+
 //		if(uniMap.isEmpty()){
 //			return Uni.createFrom().item(Response.ok(
 //				pageTemplate,
 //				MediaType.TEXT_HTML_TYPE
 //			).build());
 //		}
-		
+
 		HashMap<String, Uni> uniMapCopy = new HashMap<>(uniMap);
-		
+
+		uniMapCopy.put("userInfo", this.getOqmCoreApiClient().interactingEntityGetSelf(this.getBearerHeaderStr()));
 		uniMapCopy.put("characteristics", this.oqmCoreCharacteristicsService.allInfo());
-		
-		
+
+
 		TreeSet<String> keys = new TreeSet<>(uniMapCopy.keySet());
-		
+
 		UniJoin.Builder<Object> uniJoinBuilder = Uni.join().builder();
-		
-		
+
+
 		for(String key : keys){
 			uniJoinBuilder.add(uniMapCopy.get(key));
 		}
 		// add after others, to ensure we get it done.
 //		uniJoinBuilder.add(userInfoUni);
-		
+
 		return uniJoinBuilder.joinAll()
 				   .andCollectFailures()
 				   .map(resultList->{
 					   {
 						   Iterator<String> keyIt = keys.iterator();
 						   Iterator<Object> resultIt = resultList.iterator();
-						   
+
 						   while(keyIt.hasNext() && resultIt.hasNext()){
 							   String key = keyIt.next();
 							   Object val = resultIt.next();
@@ -111,14 +112,14 @@ protected Uni<Response> getUni(TemplateInstance pageTemplate, Map<String, Uni> u
 							   pageTemplate.data(key, val);
 						   }
 					   }
-					   
+
 					   return Response.ok(
 						   pageTemplate,
 						   MediaType.TEXT_HTML_TYPE
 					   ).build();
 				   });
 	}
-	
+
 	protected Uni<Response> getUni(Map<String, Uni> uniMap) {
 		return this.getUni(
 			this.setupPageTemplate(),
@@ -130,17 +131,17 @@ protected Uni<Response> getUni() {
 			Map.of()
 		);
 	}
-	
+
 	protected Uni<Response> getUni(TemplateInstance pageTemplate) {
 		return this.getUni(
 			pageTemplate,
 			Map.of()
 		);
 	}
-	
+
 	@FunctionalInterface
 	public interface ObjGetMethod {
 		public Uni<ObjectNode> get(String one, String two, String three);
 	}
-	
+
 }
diff --git a/software/core/oqm-core-base-station/src/main/resources/templates/webui/mainWebPageTemplate.html b/software/core/oqm-core-base-station/src/main/resources/templates/webui/mainWebPageTemplate.html
index e9d6b1ea5..e149e66f9 100644
--- a/software/core/oqm-core-base-station/src/main/resources/templates/webui/mainWebPageTemplate.html
+++ b/software/core/oqm-core-base-station/src/main/resources/templates/webui/mainWebPageTemplate.html
@@ -1,4 +1,3 @@
-{@tech.ebp.oqm.core.baseStation.model.UserInfo userInfo}
 {! @com.gjs.taskTimekeeper.webServer.server.config.ServerInfoBean serverInfo !}
 {!
 Main webpage template
@@ -20,10 +19,10 @@
 	<!-- Required meta tags -->
 	<meta charset="utf-8">
 	<meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
-	
+
 	<link rel="shortcut icon" href="{rootPrefix}/favicon.ico"/>
 	<title>{#if title??}{title} - {/if}{config:['service.nameFull']}</title>
-	
+
 	<!-- CSS -->
 	<link href="{rootPrefix}/lib/bootstrap/5.3.8/bootswatch.yeti.min.css" rel="stylesheet">
 	<link rel="stylesheet" href="{rootPrefix}/lib/bootstrap-icons/1.13.1/bootstrap-icons.min.css">
@@ -99,7 +98,7 @@
 						{/if}
 					</a>
 				</li>
-				
+
 				<li class="nav-item dropdown">
 					<a class="nav-link dropdown-toggle ps-0 {#if page is 'itemLists' || page is 'categories' || page is 'itemCheckout' }active{/if}" data-bs-toggle="dropdown" href="#" role="button"
 						aria-haspopup="true" aria-expanded="false">&nbsp;</a>
@@ -169,7 +168,7 @@
 					</div>
 				</li>
 			</ul>
-			
+
 			<form class="d-flex me-auto" method="get" action="{rootPrefix}/items" id="navSearchForm">
 				<div class="input-group">
 					<input class="form-control" id="navSearchInput" type="text" placeholder="Search" name="name" style="max-width:150px;">
@@ -193,19 +192,19 @@
 								{#icons/icon icon='box-arrow-in-up-left' /}
 								Home
 							</a>
-							
+
 							{#page/serviceDropdownCategory rootPrefix=rootPrefix uis=uis category='core' categoryName='Core' /}
 							{#page/serviceDropdownCategory rootPrefix=rootPrefix uis=uis category='plugin' categoryName='Plugins' /}
 							{#page/serviceDropdownCategory rootPrefix=rootPrefix uis=uis category='infra' categoryName='Infra' /}
 							{#page/serviceDropdownCategory rootPrefix=rootPrefix uis=uis category='metrics' categoryName='Metrics' /}
-							
+
 						{/let}
 					</div>
 				</li>
 				<li class="nav-item dropstart">
 					<a class="nav-link dropdown-toggle" data-bs-toggle="dropdown" href="#" role="button" aria-haspopup="true" aria-expanded="false">
 						{#icons/user /}
-						<span id="userNameDisplay" data-userId="{userInfo.getId()}">{userInfo.getName()}</span>
+						<span id="userNameDisplay" data-userid="{userInfo.getId()}">{userInfo.getName()}</span>
 					</a>
 					<div class="dropdown-menu">
 						<a class="dropdown-item" href="{rootPrefix}/you" id="youLink">
@@ -248,7 +247,7 @@
 			aria-controls="mainNavBar" aria-expanded="false" aria-label="Toggle navigation">
 			<span class="navbar-toggler-icon"></span>
 		</button>
-		
+
 		<div class="collapse navbar-collapse" id="mainNavBar">
 			<ul class="navbar-nav me-auto">
 				<li class="nav-item">
@@ -257,7 +256,7 @@
 					</a>
 				</li>
 			</ul>
-		
+
 		</div>
 	</div>
 	{/if}
@@ -268,7 +267,7 @@
 	{#if showTitle}
 	<h1>{#icons/pageIcon page=page addSpace=true}{/icons/pageIcon} {title}</h1>
 	{#insert additionalTitleContent}{/}
-	
+
 	<div id="messageDiv">
 	</div>
 	<hr/>
@@ -276,7 +275,7 @@ <h1>{#icons/pageIcon page=page addSpace=true}{/icons/pageIcon} {title}</h1>
 	<div id="messageDiv">
 	</div>
 	{/if}
-	
+
 	<main class="" role="main">
 		{#insert pageContent}<h1>No body!</h1>{/}
 	</main>
@@ -288,15 +287,14 @@ <h1>{#icons/pageIcon page=page addSpace=true}{/icons/pageIcon} {title}</h1>
 		<div class="col-sm-4">
 			<span class="h5">Open QuarterMaster Base Station</span><br/>
 			
-			
 			Version <b>{config:['service.version']}</b>,
 			<a href="{config:['service.gitLink']}" target="_blank">{#icons/github /} Github</a>
 			<br/>
-			
+
 			&copy; 2026 <a href="https://epic-breakfast-productions.tech/" title="Epic Breakfast Productions" target="_blank">EBP <img src="{rootPrefix}/media/EBP-logo-icon.svg" style="max-height:1.2em;" alt="EBP Logo"/></a>,
 			Released under the <a href="https://github.com/Epic-Breakfast-Productions/OpenQuarterMaster/blob/main/LICENSE" target="_blank">GPL v3.0 License</a>
 			<br/>
-			
+
 			<div class="dropup color-modes" id="theme-picker">
 				<button class="btn btn-link p-0 text-decoration-none dropdown-toggle"
 					id="bd-theme"
@@ -377,7 +375,7 @@ <h1>{#icons/pageIcon page=page addSpace=true}{/icons/pageIcon} {title}</h1>
 				{/if}
 				{#if characterValues.hasRunBy()}
 					{#let runBy=characterValues.getRunBy()}
-				
+
 						{#if runBy.hasValues()}
 							<span class="h6">Run by:</span>
 							{#if runBy.hasName()}
@@ -387,7 +385,7 @@ <h1>{#icons/pageIcon page=page addSpace=true}{/icons/pageIcon} {title}</h1>
 								<img src="{rootPrefix}/api/passthrough/characteristics/runBy/logo" style="max-height:1.2em;" alt="Run By Logo"/>
 							{/if}
 							<br/>
-							
+
 							{#if runBy.hasWebsite()}
 								<a href="{runBy.getWebsite()}">
 									{#icons/icon icon='globe' /}
@@ -395,10 +393,10 @@ <h1>{#icons/pageIcon page=page addSpace=true}{/icons/pageIcon} {title}</h1>
 								</a>
 								<br/>
 							{/if}
-				
+
 							{#if runBy.hasContactInfo()}
 								<span class="h6">Contact Info:</span><br/>
-				
+
 								{#if runBy.hasEmail()}
 									<a href="mailto:{runBy.getEmail()}">
 										{#icons/icon icon='envelope' /}
@@ -450,7 +448,7 @@ <h1>{#icons/pageIcon page=page addSpace=true}{/icons/pageIcon} {title}</h1>
 	import { DselectUtils } from '{rootPrefix}/res/js/DselectUtils.js';
 	import { TimeUtils } from '{rootPrefix}/res/js/TimeUtils.js';
 	import { TextCopyUtils } from "{rootPrefix}/res/js/TextCopyUtils.js";
-	
+
 	// init necessary modules
 	PageMessageUtils.init();
 	Icons.init();
@@ -458,7 +456,7 @@ <h1>{#icons/pageIcon page=page addSpace=true}{/icons/pageIcon} {title}</h1>
 	OqmDbUtils.init();
 	TimeUtils.init();
 	TextCopyUtils.init();
-	
+
 	console.log("Main modules loaded.");
 </script>
 

From 87562ab5893a88460d6352c1c4f44d76a7dc6f1d Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Thu, 21 May 2026 01:24:08 -0400
Subject: [PATCH 45/48] Core - API - Cleanup of unused api

---
 .../interfaces/endpoints/info/RunByUtils.java | 88 -------------------
 1 file changed, 88 deletions(-)
 delete mode 100644 software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/interfaces/endpoints/info/RunByUtils.java

diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/interfaces/endpoints/info/RunByUtils.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/interfaces/endpoints/info/RunByUtils.java
deleted file mode 100644
index edb12b0db..000000000
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/interfaces/endpoints/info/RunByUtils.java
+++ /dev/null
@@ -1,88 +0,0 @@
-package tech.ebp.oqm.core.api.interfaces.endpoints.info;
-
-import jakarta.annotation.security.PermitAll;
-import jakarta.enterprise.context.RequestScoped;
-import jakarta.ws.rs.GET;
-import jakarta.ws.rs.Path;
-import jakarta.ws.rs.PathParam;
-import jakarta.ws.rs.Produces;
-import jakarta.ws.rs.core.Response;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.io.FilenameUtils;
-import org.eclipse.microprofile.config.inject.ConfigProperty;
-import org.eclipse.microprofile.openapi.annotations.Operation;
-import org.eclipse.microprofile.openapi.annotations.media.Content;
-import org.eclipse.microprofile.openapi.annotations.responses.APIResponse;
-import org.eclipse.microprofile.openapi.annotations.tags.Tag;
-import org.eclipse.microprofile.openapi.annotations.tags.Tags;
-import tech.ebp.oqm.core.api.interfaces.endpoints.EndpointProvider;
-
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileNotFoundException;
-
-@Slf4j
-@Path(EndpointProvider.ROOT_API_ENDPOINT_V1 + "/media/runBy")
-@Tags({@Tag(name = "Media", description = "Endpoints for media CRUD")})
-@RequestScoped
-public class RunByUtils extends EndpointProvider {
-	
-	@ConfigProperty(name = "service.runBy.logo", defaultValue = "/")
-	File runByLogo;
-	@ConfigProperty(name = "service.runBy.banner", defaultValue = "/")
-	File runByBanner;
-	
-	//TODO:: contemplate caching this?
-	private static Response getImage(File image) throws FileNotFoundException {
-		
-		if (!image.exists() || !image.isFile()) {
-			//			log.info("PWD: {}", System.getProperty("user.dir"));
-			log.info("Image isFile? {}  Exists? {}", image.isFile(), image.exists());
-			return Response.status(Response.Status.NOT_FOUND).entity("No valid file set for image.").build();
-		}
-		
-		//TODO:: restrict to only image types, throw 500 if not valid
-		
-		String imageExt = FilenameUtils.getExtension(image.getName());
-		
-		if(imageExt.toLowerCase().equals("svg")){
-			imageExt = "svg+xml";
-		}
-		
-		return Response.status(Response.Status.OK)
-					   .entity(new FileInputStream(image))
-					   .type("image/" + imageExt)
-					   .build();
-	}
-	
-	@GET
-	@Path("{image}")
-	@Operation(
-		summary = "Gets a particular image's data string for use in html images."
-	)
-	@APIResponse(
-		responseCode = "200",
-		description = "Image retrieved.",
-		content = @Content(mediaType = "image/*")
-	)
-	@APIResponse(
-		responseCode = "404",
-		description = "Bad request given. No runBy image.",
-		content = @Content(mediaType = "text/plain")
-	)
-	@PermitAll
-	@Produces({"image/*", "text/plain"})
-	public Response getImageData(
-		@PathParam("image") String runByImage
-	) throws FileNotFoundException {
-		log.info("Getting image data for {}", runByImage);
-		
-		switch (runByImage) {
-			case "logo":
-				return getImage(this.runByLogo);
-			case "banner":
-				return getImage(this.runByBanner);
-		}
-		return Response.status(Response.Status.NOT_FOUND).build();
-	}
-}

From a9ada780905fdee62dae49059b99ecc90cf6d66a Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Thu, 21 May 2026 12:25:47 -0400
Subject: [PATCH 46/48] Core - API - Improvements from review

---
 .../mutex/MutexNotRegisteredException.java    |  4 +-
 .../mutex/MutexWaitInterruptedException.java  |  4 +-
 .../core/api/health/ConfigHealthCheck.java    | 37 ++++++++++++-------
 .../items/stored/state/StoredInBlock.java     |  3 +-
 .../appliers/AddAmountTransactionApplier.java | 20 ++++++----
 .../CheckoutAmountTransactionApplier.java     | 24 ++++++------
 6 files changed, 52 insertions(+), 40 deletions(-)

diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/exception/mutex/MutexNotRegisteredException.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/exception/mutex/MutexNotRegisteredException.java
index c2a755578..4aaeee976 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/exception/mutex/MutexNotRegisteredException.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/exception/mutex/MutexNotRegisteredException.java
@@ -1,9 +1,7 @@
 package tech.ebp.oqm.core.api.exception.mutex;
 
 /**
- * Exception to use when a wait for a mutex lock has timed out.
- *
- * TODO:: add mutex specific data
+ * Exception to use when a lock is attempted on a non registered mutex.
  */
 public class MutexNotRegisteredException extends IllegalStateException {
 	public MutexNotRegisteredException(String mutexId) {
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/exception/mutex/MutexWaitInterruptedException.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/exception/mutex/MutexWaitInterruptedException.java
index d27bf66eb..5c4363f4e 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/exception/mutex/MutexWaitInterruptedException.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/exception/mutex/MutexWaitInterruptedException.java
@@ -1,9 +1,7 @@
 package tech.ebp.oqm.core.api.exception.mutex;
 
 /**
- * Exception to use when a wait for a mutex lock has timed out.
- *
- * TODO:: add mutex specific data
+ * Exception to use when a wait for a mutex lock has been interrupted.
  */
 public class MutexWaitInterruptedException extends IllegalStateException {
 	public MutexWaitInterruptedException(InterruptedException e) {
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/health/ConfigHealthCheck.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/health/ConfigHealthCheck.java
index 70c84512a..bdfc53561 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/health/ConfigHealthCheck.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/health/ConfigHealthCheck.java
@@ -2,6 +2,8 @@
 
 import jakarta.enterprise.context.ApplicationScoped;
 import jakarta.inject.Inject;
+import lombok.AccessLevel;
+import lombok.Getter;
 import lombok.extern.slf4j.Slf4j;
 import org.eclipse.microprofile.config.ConfigProvider;
 import org.eclipse.microprofile.config.inject.ConfigProperty;
@@ -9,6 +11,7 @@
 import org.eclipse.microprofile.health.HealthCheckResponse;
 import org.eclipse.microprofile.health.HealthCheckResponseBuilder;
 import org.eclipse.microprofile.health.Startup;
+import tech.ebp.oqm.core.api.config.MutexConfig;
 import tech.ebp.oqm.core.api.exception.InvalidConfigException;
 import tech.ebp.oqm.core.api.service.TempFileService;
 
@@ -25,42 +28,50 @@
 @Startup
 @ApplicationScoped
 public class ConfigHealthCheck implements HealthCheck {
-	
+
 	private static final String HEALTH_CHECK_NAME = "Config Sanity health check";
-	
+
+	@Inject
+	@Getter(AccessLevel.PRIVATE)
+	MutexConfig mutexConfig;
+
 	@ConfigProperty(name = "service.tempDir")
 	Path tempDir;
-	
+
 	private Map<String, String> checkRunningInfoConfig() {
 		Map<String, String> invalidConfigs = new HashMap<>();
-		
+
 		try{
 			TempFileService.checkDir(tempDir);
 		} catch (InvalidConfigException e){
 			invalidConfigs.put("service.tempDir", "Specified temporary directory not suitable for temp file usage: " + e.getMessage());
 		}
-		
+
+		if(mutexConfig.await().loopPauseMin().compareTo(mutexConfig.await().loopPauseMax()) > 0){
+			invalidConfigs.put("service.mutex.await.loopPauseMin", "loopPauseMin must be less than loopPauseMax");
+		}
+
 		return invalidConfigs;
 	}
-	
-	
+
+
 	@Override
 	public HealthCheckResponse call() {
 		Map<String, String> invalidConfigs = new HashMap<>();
-		
+
 		invalidConfigs.putAll(checkRunningInfoConfig());
-		
+
 		if (invalidConfigs.isEmpty()) {
 			return HealthCheckResponse.up(HEALTH_CHECK_NAME);
 		}
 		HealthCheckResponseBuilder builder = HealthCheckResponse.named(HEALTH_CHECK_NAME);
-		
+
 		builder.down();
-		
+
 		for (Map.Entry<String, String> curInv : invalidConfigs.entrySet()) {
 			builder.withData(curInv.getKey(), curInv.getValue());
 		}
-		
+
 		return builder.build();
 	}
-}
\ No newline at end of file
+}
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/state/StoredInBlock.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/state/StoredInBlock.java
index 090d50faa..72a36aaad 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/state/StoredInBlock.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/model/object/storage/items/stored/state/StoredInBlock.java
@@ -10,6 +10,7 @@
 import lombok.NoArgsConstructor;
 import lombok.NonNull;
 import lombok.ToString;
+import lombok.experimental.SuperBuilder;
 import org.bson.types.ObjectId;
 import org.eclipse.microprofile.openapi.annotations.media.Schema;
 import tech.ebp.oqm.core.api.model.object.storage.storageBlock.StorageBlock;
@@ -17,7 +18,7 @@
 @EqualsAndHashCode(callSuper = true)
 @ToString(callSuper = true)
 @Data
-@Builder
+@SuperBuilder(toBuilder = true)
 @AllArgsConstructor
 @NoArgsConstructor
 @Schema(title = "StoredInBlock", description = "The state to specify this stored is actually stored in a storage block.")
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/AddAmountTransactionApplier.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/AddAmountTransactionApplier.java
index 1caa59dcf..99be4e934 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/AddAmountTransactionApplier.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/AddAmountTransactionApplier.java
@@ -24,12 +24,12 @@
  */
 @ApplicationScoped
 public class AddAmountTransactionApplier extends TransactionApplier<AddAmountTransaction> {
-	
+
 	@Override
 	public TransactionType getTransactionType() {
 		return TransactionType.ADD_AMOUNT;
 	}
-	
+
 	@Override
 	public void apply(
 		String oqmDbIdOrName,
@@ -68,6 +68,10 @@ public void apply(
 			}
 			case AMOUNT_LIST -> {
 				if (transaction.getToStored() == null) {
+					if(transaction.getToBlock() == null){
+						throw new IllegalArgumentException("Must specify a block or stored to add to.");
+					}
+
 					stored = AmountStored.builder()
 								 .item(inventoryItem.getId())
 								 .state(StoredInBlock.builder().storageBlock(transaction.getToBlock()).build())
@@ -76,11 +80,11 @@ public void apply(
 					this.getStoredService().add(oqmDbIdOrName, cs, stored, interactingEntity);
 				} else {
 					stored = (AmountStored) this.getStoredService().get(oqmDbIdOrName, cs, transaction.getToStored());
-					
+
 					if(!stored.isState(StoredStateType.STORED)){
 						throw new IllegalArgumentException("Cannot add to stored that is not stored in a block.");
 					}
-					
+
 					if (
 						transaction.getToBlock() != null &&
 						!((StoredInBlock)(stored.getState())).getStorageBlock().equals(transaction.getToBlock())
@@ -93,17 +97,17 @@ public void apply(
 				throw new IllegalArgumentException("Cannot add an amount to a unique item.");
 			}
 		}
-		
+
 		if (!inventoryItem.getId().equals(stored.getItem())) {
 			throw new IllegalArgumentException("Stored is not associated with the item.");
 		}
-		
+
 		if(!stored.isState(StoredStateType.STORED)){
 			throw new IllegalArgumentException("Cannot add to stored that is not stored in a block.");
 		}
-		
+
 		stored.add(transaction.getAmount());
-		
+
 		affectedStored.add(stored);
 		this.getStoredService().update(oqmDbIdOrName, cs, stored, interactingEntity, historyDetails);
 	}
diff --git a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckoutAmountTransactionApplier.java b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckoutAmountTransactionApplier.java
index 128bf1606..4eed7d759 100644
--- a/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckoutAmountTransactionApplier.java
+++ b/software/core/oqm-core-api/src/main/java/tech/ebp/oqm/core/api/service/mongo/transactions/appliers/CheckoutAmountTransactionApplier.java
@@ -27,12 +27,12 @@
 @Slf4j
 @ApplicationScoped
 public class CheckoutAmountTransactionApplier extends CheckinOutTransactionApplier<CheckoutAmountTransaction> {
-	
+
 	@Override
 	public TransactionType getTransactionType() {
 		return TransactionType.CHECKOUT_AMOUNT;
 	}
-	
+
 	@Override
 	public void apply(
 		String oqmDbIdOrName,
@@ -45,7 +45,7 @@ public void apply(
 		ClientSession cs
 	) {
 		AmountStored stored;
-		
+
 		switch (inventoryItem.getStorageType()) {
 			case BULK -> {
 				if (transaction.getFromBlock() != null) {
@@ -64,35 +64,35 @@ public void apply(
 			}
 			default -> throw new IllegalArgumentException("Cannot checkout an amount from a unique type.");
 		}
-		
+
 		if (!inventoryItem.getId().equals(stored.getItem())) {
 			throw new IllegalArgumentException("Stored is not associated with the item.");
 		}
-		
+
 		if(!stored.isState(StoredStateType.STORED)){
-			throw new IllegalArgumentException("Cannot subtract stored that is not stored in a block.");
+			throw new IllegalArgumentException("Cannot checkout from stored that is not stored in a block.");
 		}
-		
+
 		if (transaction.getFromBlock() != null && !((StoredInBlock)stored.getState()).getStorageBlock().equals(transaction.getFromBlock())) {
 			throw new IllegalArgumentException("From Storage block given mismatched stored's block.");
 		}
-		
+
 		if (transaction.getAmount() == null && !transaction.isAll()) {
 			throw new IllegalArgumentException("Must specify amount to checkout or specify checking out all in stored.");
 		}
 		if (transaction.getAmount() != null && transaction.isAll()) {
 			throw new IllegalArgumentException("Must specify only one of amount to checkout or checking out all in stored.");
 		}
-		
+
 		Quantity amount = null;
-		
+
 		if (transaction.getAmount() != null) {
 			amount = transaction.getAmount();
 		}
 		if (transaction.isAll()) {
 			amount = stored.getAmount();
 		}
-		
+
 		ItemCheckout.ItemCheckoutBuilder<?, ?, ?> checkoutBuilder = ItemAmountCheckout.builder()
 															.checkedOutByEntity(interactingEntity.getId())
 															.item(inventoryItem.getId())
@@ -101,7 +101,7 @@ public void apply(
 															.fromBlock(((StoredInBlock)stored.getState()).getStorageBlock())
 															.checkedOut(amount)
 															.checkOutTransaction(appliedTransactionId);
-		
+
 		stored.subtract(amount);
 		affectedStored.add(stored);
 		this.getStoredService().update(oqmDbIdOrName, cs, stored, interactingEntity, historyDetails);

From 05ce88b9a6ebbd75f9058e602637b1062aee7214 Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Thu, 21 May 2026 12:48:06 -0400
Subject: [PATCH 47/48] Core - Characteristics - Fixing potential issue in
 parsing ui entries

---
 .../core/oqm-core-characteristics/app/UIs.py  | 44 +++++++++----------
 1 file changed, 22 insertions(+), 22 deletions(-)

diff --git a/software/core/oqm-core-characteristics/app/UIs.py b/software/core/oqm-core-characteristics/app/UIs.py
index 5c4482597..e0aefdd62 100644
--- a/software/core/oqm-core-characteristics/app/UIs.py
+++ b/software/core/oqm-core-characteristics/app/UIs.py
@@ -35,7 +35,7 @@ class UiCache:
 	baseUri: str
 	icon: CachedImage | None
 	endpoints: UiEndpoints
-	
+
 	def to_response(self) -> UiResponse | None:
 		return UiResponse(
 			order=self.order,
@@ -64,7 +64,7 @@ class UisCache:
 	plugin: list[UiCache] = field(default_factory=list)
 	metrics: list[UiCache] = field(default_factory=list)
 	infra: list[UiCache] = field(default_factory=list)
-	
+
 	def to_response(self) -> UisResponse:
 		return UisResponse(
 			self.home,
@@ -73,7 +73,7 @@ def to_response(self) -> UisResponse:
 			list(map(lambda c: c.to_response(), self.metrics)),
 			list(map(lambda c: c.to_response(), self.infra)),
 		)
-	
+
 	def getCategory(self, category: str):
 		if category == "core":
 			return self.core
@@ -89,18 +89,18 @@ def getCategory(self, category: str):
 class UiUtils:
 	ui_dir = os.getenv('CHARACTERISTICS_UI_DIR', '/data/uis/')
 	ui_cache = None
-	
+
 	@classmethod
 	def __get_ui_endpoints(cls, uiRaw) -> UiEndpoints:
 		return UiEndpoints(
 			uiRaw["monitorEndpoint"],
 			uiRaw["item"] if "item" in uiRaw else None,
 		)
-	
+
 	@classmethod
 	def __get_ui(cls, uiRaw) -> UiCache:
 		return UiCache(
-			uiRaw["order"],
+			uiRaw["order"] if "order" in uiRaw else 999,
 			uiRaw["id"] if "id" in uiRaw else None,
 			uiRaw["name"],
 			uiRaw["description"],
@@ -111,7 +111,7 @@ def __get_ui(cls, uiRaw) -> UiCache:
 			) if "icon" in uiRaw else None,
 			cls.__get_ui_endpoints(uiRaw)
 		)
-	
+
 	@classmethod
 	def validate_ui_list(cls, uiList: list[UiCache]) -> None:
 		# ensure id uniqueness
@@ -127,28 +127,28 @@ def validate_ui_list(cls, uiList: list[UiCache]) -> None:
 				)
 			if len(filtered_list) != 1:
 				raise Exception("Invalid UI ID (duplicates): " + uiCache.id)
-	
+
 	@classmethod
 	def get_uis_cache(cls) -> UisCache:
 		if cls.ui_cache is not None:
 			return cls.ui_cache
-		
+
 		directory = os.getenv('UIS_DATA_DIR', "/data/uis/")
-		
+
 		uisRawData: list[dict] = list()
-		
+
 		for file in os.listdir(directory):
 			filename = os.path.basename(file)
 			if filename.endswith(".json"):
 				curUiFileLoc = os.path.join(directory, filename)
 				with open(curUiFileLoc) as curUiFile:
 					uisRawData.append(json.load(curUiFile))
-		
+
 		output: UisCache = UisCache(os.getenv('UIS_HOME_URL', " "))
-		
+
 		for rawUi in uisRawData:
 			uiCache = cls.__get_ui(rawUi)
-			
+
 			if rawUi["type"].casefold() == "core":
 				output.core.append(uiCache)
 			elif rawUi["type"].casefold() == "plugins":
@@ -159,25 +159,25 @@ def get_uis_cache(cls) -> UisCache:
 				output.infra.append(uiCache)
 			else:
 				print("WARN:: invalid type: " + rawUi["type"].casefold())
-		
+
 		cls.validate_ui_list(output.core)
 		cls.validate_ui_list(output.metrics)
 		cls.validate_ui_list(output.infra)
 		cls.validate_ui_list(output.plugin)
-		
+
 		output.core = sorted(output.core, key=lambda c: c.order)
 		output.metrics = sorted(output.metrics, key=lambda c: c.order)
 		output.infra = sorted(output.infra, key=lambda c: c.order)
 		output.plugin = sorted(output.plugin, key=lambda c: c.order)
-		
+
 		cls.ui_cache = output
-		
+
 		return output
-	
+
 	@classmethod
 	def get_uis_return(cls) -> UisResponse:
 		return cls.get_uis_cache().to_response()
-	
+
 	@classmethod
 	def get_ui_icon(cls, category: str, uiId: str) -> StreamingResponse:
 		try:
@@ -190,9 +190,9 @@ def get_ui_icon(cls, category: str, uiId: str) -> StreamingResponse:
 			)
 		except ValueError as e:
 			raise HTTPException(status_code=404, detail="Invalid UI category: " + category)
-		
+
 		if len(ui) == 0:
 			raise HTTPException(status_code=404, detail="Invalid UI ID: " + uiId)
 		ui = ui[0]
-		
+
 		return ImageUtils.get_image_response(ui.icon)

From 253ad1e2bee4512f95eaf595b661acab213235d4 Mon Sep 17 00:00:00 2001
From: GregJohnStewart <contact@gjstewart.net>
Date: Thu, 21 May 2026 13:07:44 -0400
Subject: [PATCH 48/48] Core - Base Station - Fixing the display, or rather not
 displaying, also stored in list for unique single item viewing

---
 .../resources/res/js/obj/item/ItemView.js     | 41 ++++++-------------
 .../templates/webui/mainWebPageTemplate.html  |  2 +-
 2 files changed, 14 insertions(+), 29 deletions(-)

diff --git a/software/core/oqm-core-base-station/src/main/resources/META-INF/resources/res/js/obj/item/ItemView.js b/software/core/oqm-core-base-station/src/main/resources/META-INF/resources/res/js/obj/item/ItemView.js
index 71f5726c1..ab272c66d 100644
--- a/software/core/oqm-core-base-station/src/main/resources/META-INF/resources/res/js/obj/item/ItemView.js
+++ b/software/core/oqm-core-base-station/src/main/resources/META-INF/resources/res/js/obj/item/ItemView.js
@@ -453,12 +453,16 @@ export class ItemView extends PageUtility {
 							Getters.StoredItem.getSingleStoredForItem(itemId, async function (stored) {
 								let promises = [];
 								let storageLabel = $(`
-									<h3>
-										Stored in: <span class="uniqueItemStoredInLabel"></span>
-									</h3>
-									<p class="uniqueItemStoredAlsoInContainer">
-										Also found in: <span class="uniqueItemStoredAlsoInLabel"></span>
-									</p>`);
+									<div>
+										<h3>
+											Stored in: <span class="uniqueItemStoredInLabel"></span>
+										</h3>
+										<p class="uniqueItemStoredAlsoInContainer">
+											Also found in: <span class="uniqueItemStoredAlsoInLabel"></span>
+										</p>
+									</div>
+									`);
+								let alsoInLabel = storageLabel.find(".uniqueItemStoredAlsoInLabel");
 
 								itemData.storageBlocks.forEach(function (curBlock) {
 									promises.push(Getters.StorageBlock.getStorageBlockLabel(curBlock, function (labelText) {
@@ -467,7 +471,7 @@ export class ItemView extends PageUtility {
 										if (curBlock === stored.state.storageBlock) {
 											storageLabel.find(".uniqueItemStoredInLabel").append(newLink);
 										} else {
-											storageLabel.find(".uniqueItemStoredAlsoInLabel").append(newLink);
+											alsoInLabel.append(newLink);
 										}
 									}));
 								});
@@ -482,9 +486,8 @@ export class ItemView extends PageUtility {
 										})
 								);
 								await Promise.all(promises);
-								if (storageLabel.find(".uniqueItemStoredAlsoInLabel").children().length === 0) {
-									// storageLabel.find(".uniqueItemStoredAlsoInContainer").remove();//for some reason this doesn't work ("find" doesn't work)
-									storageLabel.get(1).remove()
+								if (alsoInLabel.children().length === 0) {
+									storageLabel.find(".uniqueItemStoredAlsoInContainer").hide();
 								}
 								ItemView.storedSingleContainer.show();
 							})
@@ -584,24 +587,6 @@ export class ItemView extends PageUtility {
 
 				console.log("Setting up view of stored.");
 
-				// let numStorageBlocks = itemData.stats.numStored;// Object.keys(itemData.storageBlocks).length;
-				//TODO:: show storage blocks associated
-				// if (numStorageBlocks === 0) {
-				// 	console.log("None stored.");
-				// 	ItemView.storedNonePresentContainer.show();
-				// 	//TODO:: if storage blocks present, prompt to edit item to add block(s)
-				// 	//TODO:: prompt to add stored item
-				// } else {
-				// 	//TODO:: display right; bulk vs multi vs single display
-				// 	console.log(numStorageBlocks + " stored.");
-				// 	ItemView.itemViewStoredNum.text(numStorageBlocks);
-				// 	ItemView.itemViewStored.show();
-				//
-				// 	ItemView.allStoredSearchFormItemInputName.val(itemData.name);
-				// 	ItemView.allStoredSearchFormItemInputId.val(itemId);
-				// 	ItemView.allStoredSearchForm.submit();
-				// }
-
 				ItemView.checkoutSearchFormItemNameInput.val(itemData.name);
 				ItemView.checkoutSearchFormItemIdInput.val(itemId);
 				ItemView.checkoutSearchForm.submit();
diff --git a/software/core/oqm-core-base-station/src/main/resources/templates/webui/mainWebPageTemplate.html b/software/core/oqm-core-base-station/src/main/resources/templates/webui/mainWebPageTemplate.html
index e149e66f9..37aa328cf 100644
--- a/software/core/oqm-core-base-station/src/main/resources/templates/webui/mainWebPageTemplate.html
+++ b/software/core/oqm-core-base-station/src/main/resources/templates/webui/mainWebPageTemplate.html
@@ -286,7 +286,7 @@ <h1>{#icons/pageIcon page=page addSpace=true}{/icons/pageIcon} {title}</h1>
 	<div class="row">
 		<div class="col-sm-4">
 			<span class="h5">Open QuarterMaster Base Station</span><br/>
-			
+
 			Version <b>{config:['service.version']}</b>,
 			<a href="{config:['service.gitLink']}" target="_blank">{#icons/github /} Github</a>
 			<br/>