public PostgreSQLEventEntitySaver(
BatchOperator <EventEntity> .Factory batchOperatorFactory,
IMasterOrSelfIdentity identity,
IDbFactory dbFactory,
IPostgreSQLEventStoreOptions options,
IBatchOperatorContainer batchOperatorContainer)
{
var(connectionName, schemaName, eventTableName) =
options.RelationalEventStoreLocator.GetNames(identity.Identity);
_connectionName = connectionName;
_schemaName = schemaName;
_eventTableName = eventTableName;
var operatorKey = new BatchOperatorKey()
.With(nameof(PostgreSQLEventEntitySaver))
.With(_connectionName)
.With(_schemaName)
.With(_eventTableName);
_batchOperator = (IBatchOperator <EventEntity>)batchOperatorContainer.GetOrAdd(
operatorKey, () => batchOperatorFactory.Invoke(
new BatchOperatorOptions <EventEntity>(options)
{
DoManyFunc = (entities, cacheData) => SaveManyCoreMany(dbFactory, entities)
}));
}
public void SaveOperator(BatchOperator batchOperator)
{
ITransaction adder = new AddBatchOperatorTransaction(new Entity <BatchOperator>(batchOperator), sqliteStore);
adder.Execute();
UpdateOperatorRepository();
}
public SQLiteStateEntitySaver(
BatchOperator <StateEntity> .Factory batchOperatorFactory,
IClaptrapIdentity identity,
ISQLiteDbFactory sqLiteDbFactory,
ISQLiteStateStoreOptions options,
ISqlTemplateCache sqlTemplateCache,
IBatchOperatorContainer batchOperatorContainer)
{
_sqlTemplateCache = sqlTemplateCache;
var locator = options.RelationalStateStoreLocator;
var stateTableName = locator.GetStateTableName(identity);
_stateTableName = stateTableName;
_connectionName = locator.GetConnectionName(identity);
var operatorKey = new BatchOperatorKey()
.With(nameof(SQLiteStateEntitySaver))
.With(_connectionName)
.With(stateTableName);
_batchOperator = (IBatchOperator <StateEntity>)batchOperatorContainer.GetOrAdd(
operatorKey, () => batchOperatorFactory.Invoke(
new BatchOperatorOptions <StateEntity>(options)
{
DoManyFunc = (entities, cacheData) =>
SaveManyCoreMany(sqLiteDbFactory, entities, (string[])cacheData ![UpsertSqlKey]),
public MqSender(
string exchange,
IReadOnlyDictionary <string, string> topics,
IConnection connection,
IEventStringSerializer eventStringSerializer,
IMessageSerializer messageSerializer,
BatchOperator <IEvent> .Factory batchOperatorFactory,
IBatchOperatorContainer batchOperatorContainer,
ILogger <MqSender> logger,
IOptions <ClaptrapServerOptions> options)
{
_exchange = exchange;
_topics = topics;
_connection = connection;
_eventStringSerializer = eventStringSerializer;
_messageSerializer = messageSerializer;
_logger = logger;
_options = options;
var operatorKey = new BatchOperatorKey()
.With(nameof(MqSender))
.With(exchange);
_batchOperator = (IBatchOperator <IEvent>)batchOperatorContainer.GetOrAdd(
operatorKey, () => batchOperatorFactory.Invoke(
new BatchOperatorOptions <IEvent>
{
BufferTime = TimeSpan.FromMilliseconds(10),
BufferCount = 100,
DoManyFunc = (events, cacheData) => SendMany(events)
}));
}
public MySqlStateEntitySaver(
BatchOperator <StateEntity> .Factory batchOperatorFactory,
IClaptrapIdentity identity,
IDbFactory dbFactory,
IRelationalStateStoreLocatorOptions options,
ISqlTemplateCache sqlTemplateCache,
IBatchOperatorContainer batchOperatorContainer)
{
var locator = options.RelationalStateStoreLocator;
_connectionName = locator.GetConnectionName(identity);
_schemaName = locator.GetSchemaName(identity);
_tableName = locator.GetStateTableName(identity);
_sqlTemplateCache = sqlTemplateCache;
var operatorKey = new BatchOperatorKey()
.With(nameof(MySqlStateEntitySaver))
.With(_connectionName)
.With(_tableName);
_batchOperator = (IBatchOperator <StateEntity>)batchOperatorContainer.GetOrAdd(
operatorKey, () => batchOperatorFactory.Invoke(
new BatchOperatorOptions <StateEntity>(options)
{
DoManyFunc = (entities, cacheData) =>
SaveManyCoreMany(dbFactory, entities),
}));
}
public void SelectedOperatorUponCommitIsAssignedToAllReceivedBatchesInSessionLedger()
{
int expectedStartingSessionLedgerCount = 1;
int expectedDataSourceCountAfterCommitting = 2;
InjectTwoOperatorsIntoRepository();
BatchOperator originalOperator = operatorSource.FindBatchOperator(1);
BatchOperator expectedOperator = operatorSource.FindBatchOperator(2);
SetupValidReceivedBatchInViewModel();
AddReceivedBatchToSessionLedger();
Assert.AreEqual(expectedStartingSessionLedgerCount, viewModel.SessionLedger.Count);
foreach (ReceivedBatch batch in viewModel.SessionLedger)
{
Assert.AreEqual(originalOperator.FullName, batch.ReceivingOperator.FullName);
}
SetupValidReceivedBatchInViewModel();
viewModel.ReceivingOperatorComboBoxIndex = 1;
AddReceivedBatchToSessionLedger();
command.Execute(null);
Assert.AreEqual(expectedDataSourceCountAfterCommitting, receivingSource.ReceivedBatchRepository.Count);
foreach (ReceivedBatch batch in receivingSource.ReceivedBatchRepository)
{
Assert.AreEqual(expectedOperator.FullName, batch.ReceivingOperator.FullName);
}
}
public void UpdateOperator(int id, BatchOperator batchOperator)
{
ITransaction updater = new UpdateBatchOperatorTransaction(id, batchOperator, sqliteStore);
updater.Execute();
UpdateOperatorRepository();
}
public MongoDBEventEntitySaver(
IMongoDBEventStoreOptions options,
BatchOperator <EventEntity> .Factory batchOperatorFactory,
IDbFactory dbFactory,
IClaptrapIdentity identity,
IBatchOperatorContainer batchOperatorContainer)
{
var locator = options.MongoDBEventStoreLocator;
_connectionName = locator.GetConnectionName(identity);
_databaseName = locator.GetDatabaseName(identity);
_eventCollectionName = locator.GetEventCollectionName(identity);
var operatorKey = new BatchOperatorKey()
.With(nameof(MongoDBEventEntitySaver))
.With(_connectionName)
.With(_databaseName)
.With(_eventCollectionName);
_batchOperator = (IBatchOperator <EventEntity>)batchOperatorContainer.GetOrAdd(
operatorKey, () => batchOperatorFactory.Invoke(
new BatchOperatorOptions <EventEntity>(options)
{
DoManyFunc = (entities, cacheData) => SaveManyCoreMany(dbFactory, entities)
}));
}
public void GetOperatorInitials()
{
string initials = "JD";
dispenseOperator = new BatchOperator(firstName, lastName);
Assert.AreEqual(initials, dispenseOperator.GetInitials());
}
public void ImplementBatchFromInventoryToImplementationLedger()
{
string selectedBatchNumber = GetBatchNumberOfSelectedInventoryItem();
BatchOperator selectedBatchOperator = GetBatchOperatorFromSelectedItem();
implementedBatchSource.AddBatchToImplementationLedger(selectedBatchNumber, (DateTime)ImplementationDateTime, selectedBatchOperator);
UpdateAverageBatchList();
NotifyPropertyChanged("TotalInventoryCount");
}
public void SavingBatchOperatorResultsInRepositoryWithNewBatchOperatorAtLatestId()
{
int targetCollectionId = 0;
BatchOperator batchOperator = helper.GetJaneDoeOperator();
operatorSource.SaveOperator(batchOperator);
Assert.AreEqual(batchOperator.FirstName, operatorSource.OperatorRepository[targetCollectionId].FirstName);
Assert.AreEqual(batchOperator.LastName, operatorSource.OperatorRepository[targetCollectionId].LastName);
}
void ImplementAllButOneBatch(string batchNumber)
{
BatchOperator batchOperator = batchOperatorHelper.GetJaneDoeOperator();
DateTime date = DateTime.Today;
for (int i = 0; i < 4; i++)
{
implementedBatchSource.AddBatchToImplementationLedger(batchNumber, date, batchOperator);
date = date.AddDays(i);
}
}
public BatchOperatorViewModel(IBatchOperatorSource operatorSource)
{
this.operatorSource = operatorSource;
OperatorRepository = operatorSource.OperatorRepository;
SelectedBatchOperatorFromListBoxIndex = -1;
validator = new BatchOperatorValidator();
BatchOperator = new BatchOperator("", "");
SaveBatchOperator = new SaveBatchOperatorCommand(this);
DeleteSelectedBatchOperator = new DeleteSelectedBatchOperatorCommand(this);
BatchOperatorComboBoxChanged = new BatchOperatorComboBoxChangedCommand(this);
BatchOperatorListBoxChanged = new BatchOperatorListBoxChangedCommand(this);
}
public void CommandCanNotExecuteIfOperatorBelongsToImplementedBatch()
{
ReceivedBatchTestHelper helper = new ReceivedBatchTestHelper(operatorSource);
BatchOperatorTestHelper operatorHelper = new BatchOperatorTestHelper(operatorSource);
ReceivedBatch receivedBatch = helper.GetUniqueBatch1();
BatchOperator implementingOperator = operatorHelper.GetJohnDoeOperator();
receivedBatchSource.SaveReceivedBatch(receivedBatch);
implementedBatchSource.AddBatchToImplementationLedger(receivedBatch.BatchNumber, DateTime.Now, operatorSource.FindBatchOperator(2));
viewModel.SelectedBatchOperatorFromListBoxIndex = 1;
Assert.False(command.CanExecute(null));
}
public void SavingBatchOperatorAndRetrievingFromIdResultsInTheSameOperatorInfo()
{
int targetCollectionId = 0;
BatchOperator batchOperator = helper.GetJaneDoeOperator();
operatorSource.SaveOperator(batchOperator);
int targetId = operatorSource.BatchOperatorIdMappings[targetCollectionId];
BatchOperator found = operatorSource.FindBatchOperator(targetId);
Assert.AreEqual(batchOperator.FirstName, found.FirstName);
Assert.AreEqual(batchOperator.LastName, found.LastName);
}
public void SetUp()
{
dbHelper = new SQLiteDatabaseHelper();
dbHelper.CreateTestDatabase();
sqliteStore = new SQLiteStoreContext(dbHelper.DatabaseFile);
operatorSource = new SQLiteBatchOperatorSource(sqliteStore);
inventorySource = new SQLiteActiveInventorySource(sqliteStore);
receivedBatchSource = new SQLiteReceivedBatchSource(sqliteStore, inventorySource);
implementedBatchSource = new SQLiteImplementedBatchSource(sqliteStore, inventorySource);
operatorHelper = new BatchOperatorTestHelper(operatorSource);
viewModel = new MainWindowViewModel(inventorySource, receivedBatchSource, implementedBatchSource, operatorSource);
batchOperator = operatorHelper.GetJaneDoeOperator();
}
public void CommandWillExecuteIfOverallQuantityIsGreaterThanAmountAlreadyImplemented()
{
BatchOperator batchOperator = operatorSource.FindBatchOperator(originalBatchOperatorId);
implementedBatchSource.AddBatchToImplementationLedger(whiteBatch, DateTime.Now, batchOperator);
implementedBatchSource.AddBatchToImplementationLedger(whiteBatch, DateTime.Now, batchOperator);
implementedBatchSource.AddBatchToImplementationLedger(whiteBatch, DateTime.Now, batchOperator);
viewModel.ReceivedBatchesSelectedIndex = 0;
viewModel.Quantity = "6";
Assert.True(command.CanExecute(null));
}
void InsertThreeUniqueBatchesIntoDataSource()
{
BatchOperator batchOperator = operatorSource.FindBatchOperator(originalBatchOperatorId);
activityDate = DateTime.Today;
ReceivedBatch batch1 = new ReceivedBatch("White", whiteBatch, activityDate, 5, originalPONumber, batchOperator);
ReceivedBatch batch2 = new ReceivedBatch("Black", blackBatch, activityDate, 5, originalPONumber, batchOperator);
ReceivedBatch batch3 = new ReceivedBatch("Yellow", yellowBatch, activityDate, 5, originalPONumber, batchOperator);
receivedBatchSource.SaveReceivedBatch(batch1);
receivedBatchSource.SaveReceivedBatch(batch2);
receivedBatchSource.SaveReceivedBatch(batch3);
}
public void ExecutedCommandWithDecreaseInQuantityWillDeductAppropriateAmountInInventoryLedger()
{
viewModel.ReceivedBatchesSelectedIndex = 0;
string batchNumber = viewModel.ReceivedBatches[viewModel.ReceivedBatchesSelectedIndex].BatchNumber;
int expectedQuantity = 3;
BatchOperator batchOperator = viewModel.ReceivedBatches[viewModel.ReceivedBatchesSelectedIndex].ReceivingOperator;
implementedBatchSource.AddBatchToImplementationLedger(batchNumber, DateTime.Now, batchOperator);
viewModel.PopulateSelectedReceivedRecord();
viewModel.Quantity = "4";
command.Execute(null);
Assert.AreEqual(expectedQuantity, inventorySource.FindInventoryBatchByBatchNumber(batchNumber).Quantity);
}
public void UpdatingBatchOperatorAtIdThatDoesNotExistResultsInNoChanges()
{
int targetCollectionId = 0;
BatchOperator batchOperator = helper.GetUnsavedJaneDoeOperator();
operatorSource.SaveOperator(batchOperator);
int originalSize = operatorSource.OperatorRepository.Count;
int validId = operatorSource.BatchOperatorIdMappings[targetCollectionId];
operatorSource.UpdateOperator(validId + 1, helper.GetUnsavedJohnDoeOperator());
Assert.AreEqual(originalSize, operatorSource.OperatorRepository.Count);
}
public void ExecutedCommandWillCallIViewShowViewMethod()
{
int targetPO = 11111;
ReceivedBatch receivedBatch = helper.GetBatchWithSpecificPO(targetPO);
BatchOperator batchOperator = receivedBatch.ReceivingOperator;
operatorSource.SaveOperator(batchOperator);
receivedBatchSource.SaveReceivedBatch(receivedBatch);
viewModel.PurchaseOrderEditorViewer = new IViewTestStub();
viewModel.SpecificPONumber = targetPO.ToString();
viewModel.FetchReceivingRecordsByPONumber();
Assert.DoesNotThrow(() => command.Execute(null));
}
public void CommandWillExecuteIfViewIsSetAndCanShowItselfAndARetrievedRecordIsSet()
{
int targetPO = 11111;
ReceivedBatch receivedBatch = helper.GetBatchWithSpecificPO(targetPO);
BatchOperator batchOperator = receivedBatch.ReceivingOperator;
operatorSource.SaveOperator(batchOperator);
receivedBatchSource.SaveReceivedBatch(receivedBatch);
viewModel.PurchaseOrderEditorViewer = new PassableIViewTestStub();
viewModel.SpecificPONumber = targetPO.ToString();
viewModel.FetchReceivingRecordsByPONumber();
Assert.True(command.CanExecute(null));
}
public void ExecutedCommandWillRemoveOnlyReceivingQuantityFromActiveInventory()
{
int expectedCount = 3;
int expectedQty = 3;
BatchOperator batchOperator = operatorSource.FindBatchOperator(originalBatchOperatorId);
ReceivedBatch newBatchWithSameBatchNumber = new ReceivedBatch("White", whiteBatch, DateTime.Now, expectedQty, 22222, batchOperator);
receivedBatchSource.SaveReceivedBatch(newBatchWithSameBatchNumber);
viewModel.ReceivedBatchesSelectedIndex = 0;
command.Execute(null);
Assert.AreEqual(expectedCount, inventorySource.CurrentInventory.Count);
Assert.AreEqual(expectedQty, inventorySource.FindInventoryBatchByBatchNumber(whiteBatch).Quantity);
}
public void ExecutedCommandWithChangedColorUpdatesAllLedgers()
{
viewModel.ReceivedBatchesSelectedIndex = 0;
string batchNumber = viewModel.ReceivedBatches[viewModel.ReceivedBatchesSelectedIndex].BatchNumber;
string expectedColorName = "Red";
BatchOperator batchOperator = viewModel.ReceivedBatches[viewModel.ReceivedBatchesSelectedIndex].ReceivingOperator;
implementedBatchSource.AddBatchToImplementationLedger(batchNumber, DateTime.Now, batchOperator);
viewModel.PopulateSelectedReceivedRecord();
viewModel.SelectedColorIndex = 3;
command.Execute(null);
Assert.AreEqual(expectedColorName, receivedBatchSource.GetReceivedBatchesByBatchNumber(batchNumber)[0].ColorName);
Assert.AreEqual(expectedColorName, implementedBatchSource.GetImplementedBatchesByBatchNumber(batchNumber)[0].ColorName);
Assert.AreEqual(expectedColorName, inventorySource.FindInventoryBatchByBatchNumber(batchNumber).ColorName);
}
List <IEntity> ProcessBatchOperators(SQLiteDataReader reader)
{
List <IEntity> entities = new List <IEntity>();
if (reader.HasRows)
{
while (reader.Read())
{
BatchOperator batchOperator = new BatchOperator(reader.GetString(1), reader.GetString(2));
Entity <BatchOperator> entity = new Entity <BatchOperator>(reader.GetInt32(0), batchOperator);
entities.Add(entity);
}
}
return(entities);
}
public void UpdatingBatchOperatorAtIdResultsInNewBatchOperatorInfoWhenLookedUp()
{
int targetCollectionId = 0;
string expectedFirstName = "John";
string expectedLastName = "Doe";
BatchOperator batchOperator = helper.GetUnsavedJaneDoeOperator();
operatorSource.SaveOperator(batchOperator);
int targetId = operatorSource.BatchOperatorIdMappings[targetCollectionId];
operatorSource.UpdateOperator(targetId, helper.GetUnsavedJohnDoeOperator());
BatchOperator found = operatorSource.FindBatchOperator(targetId);
Assert.AreEqual(expectedFirstName, found.FirstName);
Assert.AreEqual(expectedLastName, found.LastName);
}
public void PersistBatchOperator()
{
BatchOperator batchOperator = new BatchOperator(FirstName, LastName);
if (SelectedBatchOperatorFromComboBoxIndex > 0)
{
int targetId = operatorSource.BatchOperatorIdMappings[SelectedBatchOperatorFromComboBoxIndex - 1];
operatorSource.UpdateOperator(targetId, batchOperator);
}
else
{
operatorSource.SaveOperator(batchOperator);
}
ResetBatchOperator();
SelectedBatchOperatorFromComboBoxIndex = -1;
NotifyPropertyChanged("OperatorNames");
}
public void ExecutedCommandWithDecreaseInQuantityResultingInZeroInventoryWillRemoveRecordFromActiveInventory()
{
viewModel.ReceivedBatchesSelectedIndex = 0;
string batchNumber = viewModel.ReceivedBatches[viewModel.ReceivedBatchesSelectedIndex].BatchNumber;
int expectedBeforeCount = 3;
int expectedAfterCount = 2;
BatchOperator batchOperator = viewModel.ReceivedBatches[viewModel.ReceivedBatchesSelectedIndex].ReceivingOperator;
implementedBatchSource.AddBatchToImplementationLedger(batchNumber, DateTime.Now, batchOperator);
viewModel.PopulateSelectedReceivedRecord();
viewModel.Quantity = "1";
Assert.AreEqual(expectedBeforeCount, inventorySource.CurrentInventory.Count);
command.Execute(null);
Assert.AreEqual(expectedAfterCount, inventorySource.CurrentInventory.Count);
}
public void ExecutedCommandWillAddBatchToImplementationLedgerAndRemoveFromInventory()
{
ReceivedBatch receivedBatch = SetupReceivedBatchWithQuantityOfTwo();
BatchOperator implementingOperator = operatorHelper.GetJaneDoeOperator();
int expectedQuantity = 1;
int expectedLedgerCount = 1;
int expectedInventoryCount = 1;
SetupInventoryStateToImplementBatch();
SetupViewModelStateToImplementBatch();
command.Execute(null);
InventoryBatch inventoryBatch = viewModel.CurrentInventory[0];
Assert.AreEqual(expectedQuantity, inventoryBatch.Quantity);
Assert.AreEqual(expectedLedgerCount, viewModel.ImplementedBatchLedger.Count);
Assert.AreEqual(expectedInventoryCount, viewModel.TotalInventoryCount);
}
public void SavingReceivedBatchWithSameBatchNumberAcrossMultipleDateWillMergeRecordsIfTheyExistInInventory()
{
int expectedQuantityAfterFirst = 1;
int expectedQuantityAfterSecond = 4;
string batchNumber = "872890302902";
BatchOperator batchOperator = new BatchOperator("Jane", "Doe");
ReceivedBatch firstBatch = new ReceivedBatch(
"White", batchNumber, new DateTime(2019, 9, 16), 1, 44614, batchOperator
);
ReceivedBatch secondBatch = new ReceivedBatch(
"White", batchNumber, new DateTime(2019, 9, 23), 3, 44663, batchOperator
);
receivedBatchSource.SaveReceivedBatch(firstBatch);
Assert.AreEqual(expectedQuantityAfterFirst, inventorySource.FindInventoryBatchByBatchNumber(batchNumber).Quantity);
receivedBatchSource.SaveReceivedBatch(secondBatch);
Assert.AreEqual(expectedQuantityAfterSecond, inventorySource.FindInventoryBatchByBatchNumber(batchNumber).Quantity);
}