public async Task Update(PadSeries series)
{
using (var conn = OpenConnection()) {
using (var t = conn.BeginTransaction()) {
// Pull in the OG record. useful to see what was created or updated.
var old = (await FindById(series.Id)) !;
// Update parent record.
await conn.ExecuteAsync(
@"update pad_series set brand_id = @BrandId, name = @Name, polisher_types = @PolisherTypes where id = @Id;",
new PadSeriesRow()
{
Id = series.Id,
BrandId = series.BrandId,
Name = series.Name,
PolisherTypes = series.PolisherTypes.Flatten()
}
);
await UpdatePadSizes(conn, series.Id, old.Sizes, series.Sizes);
await UpdatePads(conn, series.Id, old.Pads, series.Pads);
t.Commit();
}
}
}
public async Task RejectsNoSizes()
{
var s = new PadSeries("Name", Guid.NewGuid());
var res = await new PadSeriesHasSizesSpecification().Check(s);
Assert.IsFalse(res.IsSatisfied);
}
public async Task RejectsPadsWithNoOptions()
{
var s = new PadSeries("Name", Guid.NewGuid());
s.Pads.Add(new Pad("Color", PadCategory.Cutting, PadMaterial.Foam, PadTexture.Dimpled, PadColor.Red, false));
var satisified = await new PadSeriesHasOptionsForEveryPadSpecification().Check(s);
Assert.IsFalse(satisified.IsSatisfied);
}
public async Task AcceptsSizes()
{
var s = new PadSeries("Name", Guid.NewGuid());
s.Sizes.Add(new PadSize(new Measurement(1, MeasurementUnit.Inches)));
var res = await new PadSeriesHasSizesSpecification().Check(s);
Assert.IsTrue(res.IsSatisfied);
}
public async Task Delete(PadSeries series)
{
using (var conn = OpenConnection()) {
using (var t = conn.BeginTransaction()) {
// Thank you cascade
await conn.ExecuteAsync(@"delete from pad_series where id = @Id;", series);
t.Commit();
}
}
}
public async Task AcceptsPadsWithOption()
{
var s = new PadSeries("Name", Guid.NewGuid());
s.Pads.Add(new Pad("Color", PadCategory.Cutting, PadMaterial.Foam, PadTexture.Dimpled, PadColor.Red, false));
s.Pads[0].Options.Add(new PadOption(Guid.NewGuid()));
var res = await new PadSeriesHasOptionsForEveryPadSpecification().Check(s);
Assert.IsTrue(res.IsSatisfied);
}
public async Task RejectsOptionsOnSameColorWithTheSameSize()
{
var s = new PadSeries("Name", Guid.NewGuid());
s.Pads.Add(new Pad("Color", PadCategory.Cutting, PadMaterial.Foam, PadTexture.Dimpled, PadColor.Red, false));
var sizeId = Guid.NewGuid();
s.Pads[0].Options.Add(new PadOption(sizeId));
s.Pads[0].Options.Add(new PadOption(sizeId));
var res = await new PadSeriesOptionsAreUniqueBySizesSpecification().Check(s);
Assert.IsFalse(res.IsSatisfied);
}
public async Task AcceptsOptionsWithSameSizeOnDifferentColors()
{
var s = new PadSeries("Name", Guid.NewGuid());
s.Pads.Add(new Pad("Color1", PadCategory.Cutting, PadMaterial.Foam, PadTexture.Dimpled, PadColor.Red, false));
s.Pads.Add(new Pad("Color2", PadCategory.Finishing, PadMaterial.Foam, PadTexture.Dimpled, PadColor.Red, false));
var sizeId = Guid.NewGuid();
s.Pads[0].Options.Add(new PadOption(sizeId));
s.Pads[1].Options.Add(new PadOption(sizeId));
var res = await new PadSeriesOptionsAreUniqueBySizesSpecification().Check(s);
Assert.IsTrue(res.IsSatisfied);
}
public async override Task <Guid> Execute(PadSeriesCreateCommand command, User?user)
{
var sizes = command.Sizes.Select(s => new PadSize(s.Diameter, s.Thickness)).OrderByDescending(s => s.Diameter).ToList();
var colors = command.Pads.Select(c => {
ProcessedImage?image = null;
if (c.Image != null)
{
var dataUrlImage = c.Image.Right(); // Crash and burn if Guid passed. (Theoretically) this should be impossible since they're new pads.
image = imageProcessor.Process(dataUrlImage.Name, dataUrlImage.Data);
}
List <PadOption> options = new();
foreach (var optionCreate in c.Options)
{
PadOption option;
option = new PadOption(sizes[optionCreate.PadSizeIndex].Id);
option.PartNumbers.AddRange(optionCreate.PartNumbers.Select(pn => new PartNumber(pn.Id, pn.Value, pn.Notes)));
options.Add(option);
}
// Sort options
options = options.OrderByDescending(o => sizes.Find(s => s.Id == o.PadSizeId) !.Diameter).ToList();
return(new Pad(c.Name, c.Category, c.Material, c.Texture, c.Color, c.HasCenterHole, image, options));
}).OrderBy(c => c.Name).ToList();
var series = new PadSeries(
command.Name,
command.BrandId,
command.PolisherTypes,
sizes,
colors
);
await spec.CheckAndThrow(series);
await repo.Add(series);
return(series.Id);
}
public async Task Add(PadSeries series)
{
using (var conn = OpenConnection()) {
using (var t = conn.BeginTransaction()) {
await conn.ExecuteAsync(
@"insert into pad_series (id, brand_id, name, polisher_types) values (@Id, @BrandId, @Name, @PolisherTypes);",
new PadSeriesRow()
{
Id = series.Id,
BrandId = series.BrandId,
Name = series.Name,
PolisherTypes = series.PolisherTypes.Flatten()
}
);
await conn.ExecuteAsync(
@"insert into pad_sizes (id, pad_series_id, diameter_amount, diameter_unit, thickness_amount, thickness_unit) values (@Id, @PadSeriesId, @DiameterAmount, @DiameterUnit, @ThicknessAmount, @ThicknessUnit);",
series.Sizes.Select(s => new PadSizeRow()
{
Id = s.Id,
PadSeriesId = series.Id,
DiameterAmount = s.Diameter.Amount,
DiameterUnit = s.Diameter.Unit.Serialize(),
ThicknessAmount = s.Thickness?.Amount,
ThicknessUnit = s.Thickness?.Unit.Serialize()
}).ToList()
);
List <PadImageRow> imageRelations = new();
List <ImageRow> images = new();
foreach (var pad in series.Pads)
{
if (pad.Image == null)
{
continue;
}
imageRelations.Add(new() { ImageId = pad.Image.Id, PadId = pad.Id });
images.Add(new() {
Id = pad.Image.Id,
FileName = pad.Image.FileName,
MimeType = pad.Image.MimeType,
ImageData = ImageUtils.ToBinary(pad.Image.Full),
ThumbnailData = ImageUtils.ToBinary(pad.Image.Thumbnail)
});
}
if (images.Count > 0)
{
await conn.ExecuteAsync(
@"insert into images(id, file_name, mime_type, image_data, thumbnail_data) values (@Id, @FileName, @MimeType, @ImageData, @ThumbnailData);",
images
);
}
await conn.ExecuteAsync(
@"insert into pads (id, pad_series_id, category, material, texture, color, has_center_hole, name) values (@Id, @PadSeriesId, @Category, @Material, @Texture, @Color, @HasCenterHole, @Name);",
series.Pads.Select(c => new PadRow()
{
Id = c.Id,
PadSeriesId = series.Id,
Category = c.Category.Flatten(),
Material = c.Material?.Serialize(),
Texture = c.Texture?.Serialize(),
Color = c.Color?.Serialize(),
HasCenterHole = c.HasCenterHole,
Name = c.Name,
}).ToList()
);
if (imageRelations.Count > 0)
{
await conn.ExecuteAsync(
@"insert into pad_images (pad_id, image_id) values (@PadId, @ImageId);",
imageRelations
);
}
List <PadOptionRow> padOptionRows = new();
List <PadOptionPartNumberRow> padOptionPartNumberRows = new();
List <PartNumberRow> partNumberRows = new();
foreach (var color in series.Pads)
{
foreach (var option in color.Options)
{
var optionRow = new PadOptionRow()
{
Id = Guid.NewGuid(),
PadId = color.Id,
PadSizeId = option.PadSizeId,
};
padOptionRows.Add(optionRow);
foreach (var partNumber in option.PartNumbers)
{
var partNumberRow = new PartNumberRow()
{
Id = Guid.NewGuid(),
Value = partNumber.Value,
Notes = partNumber.Notes
};
padOptionPartNumberRows.Add(new PadOptionPartNumberRow()
{
PadOptionId = optionRow.Id,
PartNumberId = partNumberRow.Id,
});
partNumberRows.Add(partNumberRow);
}
}
}
await conn.ExecuteAsync(@"insert into pad_options (id, pad_id, pad_size_id) values (@Id, @PadId, @PadSizeId);", padOptionRows);
await conn.ExecuteAsync(@"insert into part_numbers (id, value, notes) values (@Id, @Value, @Notes);", partNumberRows);
await conn.ExecuteAsync(@"insert into pad_option_part_numbers (pad_option_id, part_number_id) values (@PadOptionId, @PartNumberId);", padOptionPartNumberRows);
t.Commit();
}
}
}
