/// <summary>
/// Gets and filters materials.
/// </summary>
/// <param name="partialName">A string to filter material names with.</param>
/// <param name="partialManufacturerName">A string to filter manufacturers with.</param>
/// <param name="type">The type to filter with.</param>
/// <returns>
/// Returns the matching materials.
/// </returns>
public IEnumerable <Material> GetFilteredMaterials(string partialName = null, string partialManufacturerName = null, Plastic type = null)
{
// Build where clause
string whereClause = "";
if (partialName != null)
{
partialName = $"%{partialName}%";
whereClause += "m.name ILIKE @Name ";
}
if (partialManufacturerName != null)
{
if (whereClause != "")
{
whereClause += "AND ";
}
partialManufacturerName = $"%{partialManufacturerName}%";
whereClause += "m.manufacturer ILIKE @Manufacturer ";
}
if (type != null)
{
if (whereClause != "")
{
whereClause += "AND ";
}
whereClause += $"m.type=@Type ";
}
if (whereClause != "")
{
whereClause = $" WHERE {whereClause}";
}
// Query
return(GetMaterials(whereClause, new
{
Name = partialName,
Manufacturer = partialManufacturerName,
Type = type?.Id
}));
}
/// <summary>
/// Creates a new material.
/// </summary>
/// <param name="name">The new material's name.</param>
/// <param name="manufacturerName">Name of the manufacturer.</param>
/// <param name="manufacturerSpecificId">The manufacturer's ID for this material.</param>
/// <param name="plastic">Type of the material.</param>
/// <returns>Retursn the newly created material.</returns>
public Material CreateMaterial(string name, string manufacturerName, string manufacturerSpecificId, Plastic plastic)
{
return(MaterialsRepository.CreateMaterial(name, manufacturerName, manufacturerSpecificId, plastic));
}
public void TestTransactionRepository()
{
// Create prerequisite entities
Plastic plastic = PlasticsRepository.CreatePlastic("PP", "Polypropylene");
Material material = MaterialsRepository.CreateMaterial("m", "m", "m", plastic);
StorageSite site = LocationsRepository.CreateStorageSite("site");
StorageArea area = LocationsRepository.CreateStorageArea(site, "area");
StorageLocation location = new StorageLocation()
{
StorageSiteId = site.Id,
StorageAreaId = area.Id,
StorageSiteName = site.Name,
StorageAreaName = area.Name
};
MaterialBatch batch = BatchRepository.CreateMaterialBatch(material, DateTime.Today.AddDays(3), location, 42, 42, new Dictionary <Guid, string>(), false);
(string password, byte[] salt) = new PasswordHashingService(new LoggerFactory()).HashAndSaltPassword("test");
User user = UserRepository.CreateUser("alex", "Alex", password, salt, Role.Administrator);
// Create transactions
Repository.LogTransaction(new Transaction()
{
Id = Guid.NewGuid(),
MaterialBatchId = batch.Id,
Quantity = -3,
Timestamp = DateTime.Today.AddDays(-3),
UserId = user.Id
});
Repository.LogTransaction(new Transaction()
{
Id = Guid.NewGuid(),
MaterialBatchId = batch.Id,
Quantity = -2,
Timestamp = DateTime.Today.AddDays(-2),
UserId = user.Id
});
Guid lastId = Guid.NewGuid();
Repository.LogTransaction(new Transaction()
{
Id = lastId,
MaterialBatchId = batch.Id,
Quantity = -1,
Timestamp = DateTime.Today.AddDays(-1),
UserId = user.Id
});
// Check with getAll
IEnumerable <Transaction> transactions = Repository.GetTransactionsForBatch(batch.Id);
Assert.Equal(3, transactions.Count());
Assert.Single(transactions, t => t.Quantity == -3);
Assert.Single(transactions, t => t.Quantity == -2);
Assert.Single(transactions, t => t.Quantity == -1);
// Check get last
Transaction transaction = Repository.GetLastTransactionForBatch(batch.Id);
Assert.Equal(batch.Id, transaction.MaterialBatchId);
Assert.Equal(lastId, transaction.Id);
Assert.Equal(-1, transaction.Quantity);
// Test transaction update
transaction.Quantity = 200;
Repository.UpdateTransaction(transaction);
transaction = Repository.GetLastTransactionForBatch(batch.Id);
Assert.Equal(lastId, transaction.Id);
Assert.Equal(200, transaction.Quantity);
}
/// <summary>
/// Creates a new material.
/// </summary>
/// <param name="name">The new material's name.</param>
/// <param name="manufacturerName">Name of the manufacturer.</param>
/// <param name="manufacturerSpecificId">The manufacturer's ID for this material.</param>
/// <param name="type"></param>
/// <returns>
/// Retursn the newly created material.
/// </returns>
public Material CreateMaterial(string name, string manufacturerName, string manufacturerSpecificId, Plastic type)
{
IEnumerable <Material> materials = null;
using (IDbConnection connection = GetNewConnection())
{
int id = connection.QuerySingle <int>("INSERT INTO materials (name, manufacturer, manufacturer_specific_id, type) VALUES (@Name, @Manufacturer, @ManufacturerSpecificId, @Type) RETURNING id",
param: new
{
Name = name,
Manufacturer = manufacturerName,
ManufacturerSpecificId = manufacturerSpecificId,
Type = type.Id
});
materials = GetMaterials("WHERE m.id=@Id", new { id });
}
return(materials.First());
}
public Toy(Plastic material)
{
Material = material;
}
public Toy(Plastic plasticMaterial)
{
Material = plasticMaterial;
}
public Material CreateMaterial(string name, string manufacturerName, string manufacturerSpecificId, Plastic plastic)
{
Material material = new Material()
{
Id = GetNextId(),
Name = name,
Manufacturer = manufacturerName,
ManufacturerSpecificId = manufacturerSpecificId,
Type = plastic,
CustomProps = new List <CustomMaterialPropValue>()
};
Materials.Add(material.Id, material);
return(material);
}
public IEnumerable <Material> GetFilteredMaterials(string partialName, string partialManufacturerName, Plastic plastic)
{
IEnumerable <Material> materials = Materials.Values;
if (partialName != null)
{
materials = materials.Where(m => m.Name.ToLowerInvariant().Contains(partialName.ToLowerInvariant()));
}
if (partialManufacturerName != null)
{
materials = materials.Where(m => m.Manufacturer.ToLowerInvariant().Contains(partialManufacturerName.ToLowerInvariant()));
}
if (plastic != null)
{
materials = materials.Where(m => m.Type.Id == plastic.Id);
}
return(materials.Select(m =>
{
m.CustomProps = CustomMaterialPropValueRepository.PropValues.Where(pv => pv.MaterialId == m.Id).ToList();
return m;
}));
}
public void UpdatePlastic(Plastic plastic)
{
Plastics[plastic.Id] = plastic;
}
public void TestMaterialBatchRepository()
{
Assert.Empty(Repository.GetAllMaterialBatches());
// Create prerequisite entities
Plastic pp = PlasticsRepository.CreatePlastic("PP", "Polypropylene");
Plastic ep = PlasticsRepository.CreatePlastic("EP", "Epoxy");
Material pp1 = MaterialsRepository.CreateMaterial("pp-1", "Umbrella Corp.", "pp-1", pp);
Material ep1 = MaterialsRepository.CreateMaterial("ep-1", "Umbrella Corp.", "ep-1", ep);
StorageSite site = LocationsRepository.CreateStorageSite("Test Site");
StorageArea area = LocationsRepository.CreateStorageArea(site, "Test Area");
StorageLocation loc = new StorageLocation()
{
StorageSiteId = site.Id,
StorageAreaId = area.Id,
StorageSiteName = site.Name,
StorageAreaName = area.Name
};
// Create batch and check return
DateTime expDate = DateTime.Today.AddDays(5);
MaterialBatch batch = Repository.CreateMaterialBatch(pp1, expDate, loc, 1, 125.0, new Dictionary <Guid, string>(), false);
Assert.Equal(pp1.Id, batch.Material.Id);
Assert.Equal(expDate, batch.ExpirationDate);
Assert.Equal(area.Id, batch.StorageLocation.StorageAreaId);
Assert.Equal(site.Id, batch.StorageLocation.StorageSiteId);
Assert.Equal(1, batch.BatchNumber);
Assert.Equal(125.0, batch.Quantity);
Assert.Empty(batch.CustomProps);
Assert.False(batch.IsLocked);
Assert.False(batch.IsArchived);
// Check get all batches
IEnumerable <MaterialBatch> batches = Repository.GetAllMaterialBatches();
Assert.Single(batches);
batch = batches.Single();
Assert.Equal(pp1.Id, batch.Material.Id);
Assert.Equal(expDate, batch.ExpirationDate);
Assert.Equal(area.Id, batch.StorageLocation.StorageAreaId);
Assert.Equal(site.Id, batch.StorageLocation.StorageSiteId);
Assert.Equal(1, batch.BatchNumber);
Assert.Equal(125.0, batch.Quantity);
Assert.Empty(batch.CustomProps);
Assert.False(batch.IsLocked);
Assert.False(batch.IsArchived);
// Check get single batch
batch = Repository.GetMaterialBatch(batch.Id);
Assert.Equal(pp1.Id, batch.Material.Id);
Assert.Equal(expDate, batch.ExpirationDate);
Assert.Equal(area.Id, batch.StorageLocation.StorageAreaId);
Assert.Equal(site.Id, batch.StorageLocation.StorageSiteId);
Assert.Equal(1, batch.BatchNumber);
Assert.Equal(125.0, batch.Quantity);
Assert.Empty(batch.CustomProps);
Assert.False(batch.IsLocked);
Assert.False(batch.IsArchived);
// Check filters
batches = Repository.GetMaterialBatches(pp1.Id);
Assert.Single(batches);
batch = batches.Single();
Assert.Equal(pp1.Id, batch.Material.Id);
batches = Repository.GetMaterialBatches(siteId: site.Id);
Assert.Single(batches);
batch = batches.Single();
Assert.Equal(pp1.Id, batch.Material.Id);
batches = Repository.GetMaterialBatches(pp1.Id, site.Id);
Assert.Single(batches);
batch = batches.Single();
Assert.Equal(pp1.Id, batch.Material.Id);
batches = Repository.GetMaterialBatches(99999, site.Id);
Assert.Empty(batches);
batches = Repository.GetMaterialBatches(pp1.Id, area.Id);
Assert.Empty(batches);
// Create another batch and test filters again
Repository.CreateMaterialBatch(ep1, expDate, loc, 33, 25.5, new Dictionary <Guid, string>(), false);
batches = Repository.GetMaterialBatches(ep1.Id, site.Id);
Assert.Single(batches);
batch = batches.Single();
Assert.Equal(ep1.Id, batch.Material.Id);
batches = Repository.GetMaterialBatches(siteId: site.Id);
Assert.Equal(2, batches.Count());
Assert.Single(batches, b => b.Material.Id == pp1.Id);
Assert.Single(batches, b => b.Material.Id == ep1.Id);
// Test updating a batch
batch = batches.Single(b => b.Material.Id == ep1.Id);
Assert.Equal(33, batch.BatchNumber);
Assert.Equal(25.5, batch.Quantity);
Assert.False(batch.IsLocked);
batch.BatchNumber = 333;
batch.Quantity = 203.1;
batch.IsLocked = true;
Repository.UpdateMaterialBatch(batch);
batch = Repository.GetMaterialBatch(batch.Id);
Assert.Equal(333, batch.BatchNumber);
Assert.Equal(203.1, batch.Quantity);
Assert.True(batch.IsLocked);
// Test archiving
Guid archivedId = batch.Id;
batch.IsArchived = true;
Repository.UpdateMaterialBatch(batch);
batches = Repository.GetAllMaterialBatches();
Assert.Single(batches);
batch = batches.Single();
Assert.Equal(pp1.Id, batch.Material.Id);
// Still directly gettable by ID
batch = Repository.GetMaterialBatch(archivedId);
Assert.Equal(ep1.Id, batch.Material.Id);
}
/// <summary>
/// Determines whether a plastics ID is taken.
/// </summary>
/// <param name="id">The ID to check.</param>
/// <returns>Returns whether the ID is taken.</returns>
private bool IsPlasticsIdTaken(string id)
{
Plastic plastic = PlasticsRepository.GetPlastic(id);
return(plastic != null);
}
