/// <summary>
/// Testdata
/// </summary>
/// <returns>TestValues</returns>
public static List <TestValue> TestValuesOkRetentionAverage(BabyDiaperTestValue expected)
=> new List <TestValue>
{
new TestValue
{
TestValueType = TestValueType.Average,
ArticleTestType = ArticleType.BabyDiaper,
BabyDiaperTestValue = new BabyDiaperTestValue {
TestType = TestTypeBabyDiaper.RewetAndPenetrationTime
}
},
new TestValue
{
TestValueType = TestValueType.Average,
ArticleTestType = ArticleType.BabyDiaper,
BabyDiaperTestValue = expected
},
new TestValue
{
TestValueType = TestValueType.Average,
ArticleTestType = ArticleType.BabyDiaper,
BabyDiaperTestValue = new BabyDiaperTestValue {
TestType = TestTypeBabyDiaper.Rewet, Rewet210Rw = RwType.Ok, Rewet140Rw = RwType.Ok
}
}
};
/// <summary>
/// Testdata
/// </summary>
/// <returns>TestValues</returns>
public static List <TestValue> TestValuesOkPenetrationTimeSingle(BabyDiaperTestValue expected)
=> new List <TestValue>
{
new TestValue
{
TestValueType = TestValueType.Single,
ArticleTestType = ArticleType.BabyDiaper,
BabyDiaperTestValue = new BabyDiaperTestValue {
TestType = TestTypeBabyDiaper.Rewet
}
},
new TestValue
{
TestValueType = TestValueType.Single,
ArticleTestType = ArticleType.BabyDiaper,
BabyDiaperTestValue = expected
},
new TestValue
{
TestValueType = TestValueType.Single,
ArticleTestType = ArticleType.BabyDiaper,
BabyDiaperTestValue = new BabyDiaperTestValue {
TestType = TestTypeBabyDiaper.Retention
}
}
};
/// <summary>
/// Testdata
/// </summary>
/// <returns>TestValues</returns>
public static List <TestValue> TestValuesOkRewetStandardDeviation(BabyDiaperTestValue expected)
=> new List <TestValue>
{
new TestValue
{
TestValueType = TestValueType.StandardDeviation,
ArticleTestType = ArticleType.BabyDiaper,
BabyDiaperTestValue = new BabyDiaperTestValue {
TestType = TestTypeBabyDiaper.RewetAndPenetrationTime
}
},
new TestValue
{
TestValueType = TestValueType.StandardDeviation,
ArticleTestType = ArticleType.BabyDiaper,
BabyDiaperTestValue = expected
},
new TestValue
{
TestValueType = TestValueType.StandardDeviation,
ArticleTestType = ArticleType.BabyDiaper,
BabyDiaperTestValue = new BabyDiaperTestValue {
TestType = TestTypeBabyDiaper.Retention
}
}
};
/// <summary>
/// Creates an new TestValue from the view model
/// </summary>
/// <param name="viewModel">the data from the view</param>
/// <returns>The created test value</returns>
public TestValue SaveNewRewetTest(BabyDiaperRewetEditViewModel viewModel)
{
var testValue = TestServiceHelper.CreateNewTestValue(viewModel.TestSheetId, viewModel.TestPerson, viewModel.ProductionCodeDay, viewModel.Notes);
testValue.ArticleTestType = ArticleType.BabyDiaper;
var babyDiaperTestValue = new BabyDiaperTestValue
{
DiaperCreatedTime = viewModel.ProductionCodeTime,
WeightDiaperDry = viewModel.DiaperWeight,
Rewet140Value = viewModel.RewetAfter140,
Rewet210Value = viewModel.RewetAfter210,
StrikeTroughValue = viewModel.StrikeThrough,
DistributionOfTheStrikeTrough = viewModel.Distribution,
PenetrationTimeAdditionFirst = viewModel.PenetrationTime1,
PenetrationTimeAdditionSecond = viewModel.PenetrationTime2,
PenetrationTimeAdditionThird = viewModel.PenetrationTime3,
PenetrationTimeAdditionFourth = viewModel.PenetrationTime4,
TestType = viewModel.TestType
};
if (babyDiaperTestValue.TestType == TestTypeBabyDiaper.Rewet)
{
babyDiaperTestValue.PenetrationTimeAdditionFirst = 0;
babyDiaperTestValue.PenetrationTimeAdditionSecond = 0;
babyDiaperTestValue.PenetrationTimeAdditionThird = 0;
babyDiaperTestValue.PenetrationTimeAdditionFourth = 0;
}
babyDiaperTestValue = CalculateBabyDiaperRewetValues(babyDiaperTestValue, viewModel.TestSheetId);
testValue.BabyDiaperTestValue = babyDiaperTestValue;
TestBll.SaveNewTestValue(testValue);
return(testValue);
}
/// <summary>
/// Creates the BabyDiaperRewet TestValue from diffrent input data
/// </summary>
/// <param name="rewet">the baby diaper test value containing the rewet data</param>
/// <param name="testPerson">the person who did the test</param>
/// <param name="prodCode">the diaper production code</param>
/// <param name="testValueId">the id of the testvalue</param>
/// <returns></returns>
public BabyDiaperRewetTestValue ToRewetTestValue(BabyDiaperTestValue rewet, String testPerson, String prodCode, Int32 testValueId)
{
var vm = new BabyDiaperRewetTestValue
{
BabyDiaperTestInfo = ToTestInfo(testPerson, prodCode, rewet.WeightDiaperDry, testValueId),
BabyDiaperRewet = ToRewet(rewet)
};
return(vm);
}
/// <summary>
/// Creates the BabyDiaperPenetrationTime TestValue from diffrent input data
/// </summary>
/// <param name="penetrationTime">the baby diaper test value containing the penetration time data</param>
/// <param name="testPerson">the person who did the test</param>
/// <param name="prodCode">the diaper production code</param>
/// <param name="testValueId">the id of the test value</param>
/// <returns></returns>
public BabyDiaperPenetrationTimeTestValue ToPenetrationTimeTestValue(BabyDiaperTestValue penetrationTime, String testPerson, String prodCode, Int32 testValueId)
{
var vm = new BabyDiaperPenetrationTimeTestValue
{
BabyDiaperTestInfo = ToTestInfo(testPerson, prodCode, penetrationTime.WeightDiaperDry, testValueId),
BabyDiaperPenetrationTime = ToPenetrationTime(penetrationTime)
};
return(vm);
}
/// <summary>
/// Creates the RetentionTestValues from diffrent input data
/// </summary>
/// <param name="retention">the baby diaper test value containing the retention data</param>
/// <param name="testPerson">the person who did the test</param>
/// <param name="prodCode">the diaper production code</param>
/// <param name="testValueId">the id of the testvalue</param>
/// <returns></returns>
public BabyDiaperRetentionTestValue ToRetentionTestValue(BabyDiaperTestValue retention, String testPerson, String prodCode, Int32 testValueId)
{
var vm = new BabyDiaperRetentionTestValue
{
BabyDiaperTestInfo = ToTestInfo(testPerson, prodCode, retention.WeightDiaperDry, testValueId),
BabyDiaperRetention = ToRetention(retention)
};
return(vm);
}
/// <summary>
/// Calculates all values for the baby diaper rewet test
/// </summary>
/// <param name="babyDiaperTestValue">the test value</param>
/// <param name="testSheetId">the test sheet id</param>
/// <returns></returns>
private BabyDiaperTestValue CalculateBabyDiaperRewetValues(BabyDiaperTestValue babyDiaperTestValue,
Int32 testSheetId)
{
var testSheet = TestBll.GetTestSheetInfo(testSheetId);
var productionOrder = TestBll.GetProductionOrder(testSheet.FaNr);
babyDiaperTestValue.Rewet140Rw = GetRewet140RwType(babyDiaperTestValue.Rewet140Value, productionOrder);
babyDiaperTestValue.Rewet210Rw = GetRewet210RwType(babyDiaperTestValue.Rewet210Value, productionOrder);
babyDiaperTestValue.PenetrationRwType = GetPenetrationRwType(babyDiaperTestValue.PenetrationTimeAdditionFourth, productionOrder);
return(babyDiaperTestValue);
}
/// <summary>
/// Sets the values for the BabyDiaperRetention View Model out of the BabyDiaperTestValue Model
/// </summary>
/// <param name="retention">the Baby Diaper Test value with the retention data</param>
/// <returns>The BabyDiaperRetention View Model with the data collected from the model</returns>
public BabyDiaperRetention ToRetention(BabyDiaperTestValue retention)
{
ValidateRequiredItem(retention.RetentionRw, "retention rw");
return(new BabyDiaperRetention
{
SapNr = retention.SapNr,
RetentionAfterZentrifugeValue = Round(retention.RetentionAfterZentrifugeValue),
SapType = retention.SapType,
RetentionRw = retention.RetentionRw.GetValueOrDefault(),
RetentionWetWeight = Round(retention.RetentionWetWeight),
RetentionAfterZentrifugePercent = Round(retention.RetentionAfterZentrifugePercent),
SapGHoewiValue = Round(retention.SapGHoewiValue)
});
}
/// <summary>
/// Sets the values for the Penetration Time View Model out of the BabyDiaperTestValue Model
/// </summary>
/// <param name="penetrationTime">the Baby Diaper Test value with the penetration time data</param>
/// <returns>The Penetration Time View Model with the data collected from the model</returns>
public BabyDiaperPenetrationTime ToPenetrationTime(BabyDiaperTestValue penetrationTime)
{
ValidateRequiredItem(penetrationTime.PenetrationRwType, "penetration rw");
return(new BabyDiaperPenetrationTime
{
PenetrationTimeAdditionFourth = Round(penetrationTime.PenetrationTimeAdditionFourth),
PenetrationTimeAdditionSecond = Round(penetrationTime.PenetrationTimeAdditionSecond),
PenetrationTimeAdditionFirst = Round(penetrationTime.PenetrationTimeAdditionFirst),
PenetrationTimeAdditionThird = Round(penetrationTime.PenetrationTimeAdditionThird),
PenetrationTimeAdditionFourthRwType = penetrationTime.PenetrationRwType.GetValueOrDefault()
}
);
}
/// <summary>
/// Sets the values for the BabyDiaperRewet View Model out of the BabyDiaperTestValue Model
/// </summary>
/// <param name="rewet">the Baby Diaper Test value with the rewet data</param>
/// <returns>The rewet View Model with the data collected from the model</returns>
public BabyDiaperRewet ToRewet(BabyDiaperTestValue rewet)
{
ValidateRequiredItem(rewet.Rewet210Rw, "rewet 210 rw");
ValidateRequiredItem(rewet.Rewet140Rw, "rewet 140 rw");
return
(new BabyDiaperRewet
{
Rewet210Rw = rewet.Rewet210Rw.GetValueOrDefault(),
StrikeThroughValue = Round(rewet.StrikeTroughValue),
DistributionOfTheStrikeTrough = Round(rewet.DistributionOfTheStrikeTrough),
Rewet210Value = Round(rewet.Rewet210Value),
Rewet140Rw = rewet.Rewet140Rw.GetValueOrDefault(),
Rewet140Value = Round(rewet.Rewet140Value)
});
}
/// <summary>
/// Creates an new TestValue from the view model
/// </summary>
/// <param name="viewModel">the data from the view</param>
/// <returns>The created test value</returns>
public TestValue SaveNewRetentionTest(BabyDiaperRetentionEditViewModel viewModel)
{
var testValue = TestServiceHelper.CreateNewTestValue(viewModel.TestSheetId, viewModel.TestPerson, viewModel.ProductionCodeDay, viewModel.Notes);
testValue.ArticleTestType = ArticleType.BabyDiaper;
var babyDiaperTestValue = new BabyDiaperTestValue
{
DiaperCreatedTime = viewModel.ProductionCodeTime,
WeightDiaperDry = viewModel.DiaperWeight,
RetentionWetWeight = viewModel.WeightRetentionWet,
TestType = TestTypeBabyDiaper.Retention
};
babyDiaperTestValue = CalculateBabyDiaperRetentionValues(babyDiaperTestValue, viewModel.TestSheetId);
testValue.BabyDiaperTestValue = babyDiaperTestValue;
testValue = TestBll.SaveNewTestValue(testValue);
return(testValue);
}
private void UpdateRetentionAvg(TestSheet testSheet, TestValue retentionTestAvg)
{
var productionOrder = TestBll.GetProductionOrder(testSheet.FaNr);
var tempBabyDiaper = new BabyDiaperTestValue {
RetentionRw = RwType.Ok
};
var counter = 0;
foreach (
var testValue in
testSheet.TestValues.Where(
testValue => (testValue.TestValueType == TestValueType.Single) && (testValue.BabyDiaperTestValue.TestType == TestTypeBabyDiaper.Retention))
)
{
tempBabyDiaper.WeightDiaperDry += testValue.BabyDiaperTestValue.WeightDiaperDry;
tempBabyDiaper.RetentionWetWeight += testValue.BabyDiaperTestValue.RetentionWetWeight;
tempBabyDiaper.RetentionAfterZentrifugeValue += testValue.BabyDiaperTestValue.RetentionAfterZentrifugeValue;
tempBabyDiaper.RetentionAfterZentrifugePercent += testValue.BabyDiaperTestValue.RetentionAfterZentrifugePercent;
if (testValue.BabyDiaperTestValue.RetentionRw == RwType.Worse)
{
tempBabyDiaper.RetentionRw = RwType.SomethingWorse;
}
tempBabyDiaper.SapGHoewiValue += testValue.BabyDiaperTestValue.SapGHoewiValue;
counter++;
}
if (counter == 0)
{
counter = 1;
}
retentionTestAvg.BabyDiaperTestValue.WeightDiaperDry = tempBabyDiaper.WeightDiaperDry / counter;
retentionTestAvg.BabyDiaperTestValue.RetentionWetWeight = tempBabyDiaper.RetentionWetWeight / counter;
retentionTestAvg.BabyDiaperTestValue.RetentionAfterZentrifugeValue = tempBabyDiaper.RetentionAfterZentrifugeValue / counter;
retentionTestAvg.BabyDiaperTestValue.RetentionAfterZentrifugePercent = tempBabyDiaper.RetentionAfterZentrifugePercent / counter;
if ((GetRetentionRwType(retentionTestAvg.BabyDiaperTestValue.RetentionAfterZentrifugeValue, productionOrder) == RwType.Worse) &&
(tempBabyDiaper.RetentionRw != RwType.Ok))
{
tempBabyDiaper.RetentionRw = RwType.Worse;
}
retentionTestAvg.BabyDiaperTestValue.RetentionRw = tempBabyDiaper.RetentionRw;
retentionTestAvg.BabyDiaperTestValue.SapGHoewiValue = tempBabyDiaper.SapGHoewiValue / counter;
}
private static void UpdatePenetrationStDev(TestSheet testSheet, TestValue penetrationTestAvg, TestValue penetrationTestStDev)
{
var tempBabyDiaper = new BabyDiaperTestValue();
var counter = 0;
foreach (
var testValue in
testSheet.TestValues.Where(
testValue =>
(testValue.TestValueType == TestValueType.Single) && (testValue.BabyDiaperTestValue.TestType == TestTypeBabyDiaper.RewetAndPenetrationTime))
)
{
tempBabyDiaper.WeightDiaperDry += Math.Pow(testValue.BabyDiaperTestValue.WeightDiaperDry - penetrationTestAvg.BabyDiaperTestValue.WeightDiaperDry, 2);
tempBabyDiaper.PenetrationTimeAdditionFirst +=
Math.Pow(testValue.BabyDiaperTestValue.PenetrationTimeAdditionFirst - penetrationTestAvg.BabyDiaperTestValue.PenetrationTimeAdditionFirst, 2);
tempBabyDiaper.PenetrationTimeAdditionSecond +=
Math.Pow(testValue.BabyDiaperTestValue.PenetrationTimeAdditionSecond - penetrationTestAvg.BabyDiaperTestValue.PenetrationTimeAdditionSecond, 2);
tempBabyDiaper.PenetrationTimeAdditionThird +=
Math.Pow(testValue.BabyDiaperTestValue.PenetrationTimeAdditionThird - penetrationTestAvg.BabyDiaperTestValue.PenetrationTimeAdditionThird, 2);
tempBabyDiaper.PenetrationTimeAdditionFourth +=
Math.Pow(testValue.BabyDiaperTestValue.PenetrationTimeAdditionFourth - penetrationTestAvg.BabyDiaperTestValue.PenetrationTimeAdditionFourth, 2);
counter++;
}
if (counter < 2)
{
penetrationTestStDev.BabyDiaperTestValue.WeightDiaperDry = 0;
penetrationTestStDev.BabyDiaperTestValue.PenetrationTimeAdditionFirst = 0;
penetrationTestStDev.BabyDiaperTestValue.PenetrationTimeAdditionSecond = 0;
penetrationTestStDev.BabyDiaperTestValue.PenetrationTimeAdditionThird = 0;
penetrationTestStDev.BabyDiaperTestValue.PenetrationTimeAdditionFourth = 0;
}
else
{
counter--;
penetrationTestStDev.BabyDiaperTestValue.WeightDiaperDry = Math.Sqrt(tempBabyDiaper.WeightDiaperDry / counter);
penetrationTestStDev.BabyDiaperTestValue.PenetrationTimeAdditionFirst = Math.Sqrt(tempBabyDiaper.PenetrationTimeAdditionFirst / counter);
penetrationTestStDev.BabyDiaperTestValue.PenetrationTimeAdditionSecond = Math.Sqrt(tempBabyDiaper.PenetrationTimeAdditionSecond / counter);
penetrationTestStDev.BabyDiaperTestValue.PenetrationTimeAdditionThird = Math.Sqrt(tempBabyDiaper.PenetrationTimeAdditionThird / counter);
penetrationTestStDev.BabyDiaperTestValue.PenetrationTimeAdditionFourth = Math.Sqrt(tempBabyDiaper.PenetrationTimeAdditionFourth / counter);
}
}
private void UpdatePenetrationAvg(TestSheet testSheet, TestValue penetrationTestAvg)
{
var productionOrder = TestBll.GetProductionOrder(testSheet.FaNr);
var tempBabyDiaper = new BabyDiaperTestValue {
PenetrationRwType = RwType.Ok
};
var counter = 0;
foreach (
var testValue in
testSheet.TestValues.Where(
testValue =>
(testValue.TestValueType == TestValueType.Single) && (testValue.BabyDiaperTestValue.TestType == TestTypeBabyDiaper.RewetAndPenetrationTime))
)
{
tempBabyDiaper.WeightDiaperDry += testValue.BabyDiaperTestValue.WeightDiaperDry;
tempBabyDiaper.PenetrationTimeAdditionFirst += testValue.BabyDiaperTestValue.PenetrationTimeAdditionFirst;
tempBabyDiaper.PenetrationTimeAdditionSecond += testValue.BabyDiaperTestValue.PenetrationTimeAdditionSecond;
tempBabyDiaper.PenetrationTimeAdditionThird += testValue.BabyDiaperTestValue.PenetrationTimeAdditionThird;
tempBabyDiaper.PenetrationTimeAdditionFourth += testValue.BabyDiaperTestValue.PenetrationTimeAdditionFourth;
if (testValue.BabyDiaperTestValue.PenetrationRwType == RwType.Worse)
{
tempBabyDiaper.PenetrationRwType = RwType.SomethingWorse;
}
counter++;
}
if (counter == 0)
{
counter = 1;
}
penetrationTestAvg.BabyDiaperTestValue.WeightDiaperDry = tempBabyDiaper.WeightDiaperDry / counter;
penetrationTestAvg.BabyDiaperTestValue.PenetrationTimeAdditionFirst = tempBabyDiaper.PenetrationTimeAdditionFirst / counter;
penetrationTestAvg.BabyDiaperTestValue.PenetrationTimeAdditionSecond = tempBabyDiaper.PenetrationTimeAdditionSecond / counter;
penetrationTestAvg.BabyDiaperTestValue.PenetrationTimeAdditionThird = tempBabyDiaper.PenetrationTimeAdditionThird / counter;
penetrationTestAvg.BabyDiaperTestValue.PenetrationTimeAdditionFourth = tempBabyDiaper.PenetrationTimeAdditionFourth / counter;
if (GetPenetrationRwType(penetrationTestAvg.BabyDiaperTestValue.PenetrationTimeAdditionFourth, productionOrder) == RwType.Worse)
{
tempBabyDiaper.PenetrationRwType = RwType.Worse;
}
penetrationTestAvg.BabyDiaperTestValue.PenetrationRwType = tempBabyDiaper.PenetrationRwType;
}
/// <summary>
/// Calculates all values for the baby diaper retention test
/// </summary>
/// <param name="babyDiaperTestValue">the test value</param>
/// <param name="testSheetId">the test sheet id</param>
/// <returns></returns>
private BabyDiaperTestValue CalculateBabyDiaperRetentionValues(BabyDiaperTestValue babyDiaperTestValue,
Int32 testSheetId)
{
var testSheet = TestBll.GetTestSheetInfo(testSheetId);
var productionOrder = TestBll.GetProductionOrder(testSheet.FaNr);
babyDiaperTestValue.RetentionAfterZentrifugeValue = babyDiaperTestValue.RetentionWetWeight -
babyDiaperTestValue.WeightDiaperDry;
if (Math.Abs(babyDiaperTestValue.WeightDiaperDry) > 0.1)
{
babyDiaperTestValue.RetentionAfterZentrifugePercent = (babyDiaperTestValue.RetentionWetWeight -
babyDiaperTestValue.WeightDiaperDry) * 100.0 /
babyDiaperTestValue.WeightDiaperDry;
}
babyDiaperTestValue.RetentionRw = GetRetentionRwType(babyDiaperTestValue.RetentionAfterZentrifugeValue, productionOrder);
babyDiaperTestValue.SapType = testSheet.SAPType;
babyDiaperTestValue.SapNr = testSheet.SAPNr;
babyDiaperTestValue.SapGHoewiValue = (babyDiaperTestValue.RetentionWetWeight - babyDiaperTestValue.WeightDiaperDry - productionOrder.Component.PillowRetentWithoutSAP)
/ productionOrder.Component.SAP;
return(babyDiaperTestValue);
}
private static void UpdateRewetStDev(TestSheet testSheet, TestValue rewetTestAvg, TestValue rewetTestStDev)
{
var tempBabyDiaper = new BabyDiaperTestValue();
var counter = 0;
foreach (
var testValue in
testSheet.TestValues.Where(
testValue =>
(testValue.TestValueType == TestValueType.Single) &&
((testValue.BabyDiaperTestValue.TestType == TestTypeBabyDiaper.Rewet) ||
(testValue.BabyDiaperTestValue.TestType == TestTypeBabyDiaper.RewetAndPenetrationTime)))
)
{
tempBabyDiaper.WeightDiaperDry += Math.Pow(testValue.BabyDiaperTestValue.WeightDiaperDry - rewetTestAvg.BabyDiaperTestValue.WeightDiaperDry, 2);
tempBabyDiaper.Rewet140Value += Math.Pow(testValue.BabyDiaperTestValue.Rewet140Value - rewetTestAvg.BabyDiaperTestValue.Rewet140Value, 2);
tempBabyDiaper.Rewet210Value += Math.Pow(testValue.BabyDiaperTestValue.Rewet210Value - rewetTestAvg.BabyDiaperTestValue.Rewet210Value, 2);
tempBabyDiaper.StrikeTroughValue += Math.Pow(testValue.BabyDiaperTestValue.StrikeTroughValue - rewetTestAvg.BabyDiaperTestValue.StrikeTroughValue, 2);
tempBabyDiaper.DistributionOfTheStrikeTrough +=
Math.Pow(testValue.BabyDiaperTestValue.DistributionOfTheStrikeTrough - rewetTestAvg.BabyDiaperTestValue.DistributionOfTheStrikeTrough, 2);
counter++;
}
if (counter < 2)
{
rewetTestStDev.BabyDiaperTestValue.WeightDiaperDry = 0;
rewetTestStDev.BabyDiaperTestValue.Rewet140Value = 0;
rewetTestStDev.BabyDiaperTestValue.Rewet210Value = 0;
rewetTestStDev.BabyDiaperTestValue.StrikeTroughValue = 0;
rewetTestStDev.BabyDiaperTestValue.DistributionOfTheStrikeTrough = 0;
}
else
{
counter--;
rewetTestStDev.BabyDiaperTestValue.WeightDiaperDry = Math.Sqrt(tempBabyDiaper.WeightDiaperDry / counter);
rewetTestStDev.BabyDiaperTestValue.Rewet140Value = Math.Sqrt(tempBabyDiaper.Rewet140Value / counter);
rewetTestStDev.BabyDiaperTestValue.Rewet210Value = Math.Sqrt(tempBabyDiaper.Rewet210Value / counter);
rewetTestStDev.BabyDiaperTestValue.StrikeTroughValue = Math.Sqrt(tempBabyDiaper.StrikeTroughValue / counter);
rewetTestStDev.BabyDiaperTestValue.DistributionOfTheStrikeTrough = Math.Sqrt(tempBabyDiaper.DistributionOfTheStrikeTrough / counter);
}
}
private static void UpdateRetentionStDev(TestSheet testSheet, TestValue retentionTestAvg, TestValue retentionTestStDev)
{
var tempBabyDiaper = new BabyDiaperTestValue();
var counter = 0;
foreach (
var testValue in
testSheet.TestValues.Where(
testValue => (testValue.TestValueType == TestValueType.Single) && (testValue.BabyDiaperTestValue.TestType == TestTypeBabyDiaper.Retention))
)
{
tempBabyDiaper.WeightDiaperDry += Math.Pow(testValue.BabyDiaperTestValue.WeightDiaperDry - retentionTestAvg.BabyDiaperTestValue.WeightDiaperDry, 2);
tempBabyDiaper.RetentionWetWeight += Math.Pow(testValue.BabyDiaperTestValue.RetentionWetWeight - retentionTestAvg.BabyDiaperTestValue.RetentionWetWeight, 2);
tempBabyDiaper.RetentionAfterZentrifugeValue +=
Math.Pow(testValue.BabyDiaperTestValue.RetentionAfterZentrifugeValue - retentionTestAvg.BabyDiaperTestValue.RetentionAfterZentrifugeValue, 2);
tempBabyDiaper.RetentionAfterZentrifugePercent +=
Math.Pow(testValue.BabyDiaperTestValue.RetentionAfterZentrifugePercent - retentionTestAvg.BabyDiaperTestValue.RetentionAfterZentrifugePercent, 2);
tempBabyDiaper.SapGHoewiValue += Math.Pow(testValue.BabyDiaperTestValue.SapGHoewiValue - retentionTestAvg.BabyDiaperTestValue.SapGHoewiValue, 2);
counter++;
}
if (counter < 2)
{
retentionTestStDev.BabyDiaperTestValue.WeightDiaperDry = 0;
retentionTestStDev.BabyDiaperTestValue.RetentionWetWeight = 0;
retentionTestStDev.BabyDiaperTestValue.RetentionAfterZentrifugeValue = 0;
retentionTestStDev.BabyDiaperTestValue.RetentionAfterZentrifugePercent = 0;
retentionTestStDev.BabyDiaperTestValue.SapGHoewiValue = 0;
}
else
{
counter--;
retentionTestStDev.BabyDiaperTestValue.WeightDiaperDry = Math.Sqrt(tempBabyDiaper.WeightDiaperDry / counter);
retentionTestStDev.BabyDiaperTestValue.RetentionWetWeight = Math.Sqrt(tempBabyDiaper.RetentionWetWeight / counter);
retentionTestStDev.BabyDiaperTestValue.RetentionAfterZentrifugeValue = Math.Sqrt(tempBabyDiaper.RetentionAfterZentrifugeValue / counter);
retentionTestStDev.BabyDiaperTestValue.RetentionAfterZentrifugePercent = Math.Sqrt(tempBabyDiaper.RetentionAfterZentrifugePercent / counter);
retentionTestStDev.BabyDiaperTestValue.SapGHoewiValue = Math.Sqrt(tempBabyDiaper.SapGHoewiValue / counter);
}
}
protected override void Seed(LaborContext context)
{
var error1 = new Error
{
ErrorCode = "080",
Value = "Fixtape fehlt"
};
var error2 = new Error
{
ErrorCode = "411",
Value = "Saugkissen hinten zu kurz"
};
var error3 = new Error
{
ErrorCode = "023",
Value = "Zu wenig Inhalt"
};
var error4 = new Error
{
ErrorCode = "802",
Value = "Linke Seite reisst auf"
};
context.Errors.AddOrUpdate(e => e.ErrorId, error1, error2, error3, error4);
var machine1 = new Machine
{
MachineNr = "M10"
};
var machine2 = new Machine
{
MachineNr = "M11"
};
var machine3 = new Machine
{
MachineNr = "M49"
};
context.Machines.AddOrUpdate(m => m.MachineId, machine1, machine2, machine3);
var article1 = new Article
{
ArticleNr = "10401",
Name = "Babydream Maxi-Plus",
ArticleType = ArticleType.BabyDiaper,
Rewet140Max = 0.4,
Rewet210Max = 0.5,
MinRetention = 350,
MaxRetention = 380,
MaxPenetrationAfter4Time = 250
};
var article2 = new Article
{
ArticleNr = "10412",
Name = "Inko Extra",
ArticleType = ArticleType.IncontinencePad,
SizeName = "Inko Extra"
};
context.Articles.AddOrUpdate(a => a.ArticleId, article1);
context.Articles.AddOrUpdate(a => a.ArticleId, article2);
var productionOrderComponent1 = new ProductionOrderComponent
{
SAP = 32.7,
PillowRetentWithoutSAP = 31.2,
PillowWeightWithoutSAP = 26.0,
CelluloseRetention = 1.2,
ComponentType = "EKX",
ComponentNr = "EN67"
};
var productionOrder1 = new ProductionOrder
{
FaNr = "FA123456",
StartDateTime = new DateTime(2016, 1, 1),
EndDateTime = new DateTime(2018, 1, 1),
Machine = machine2,
Component = productionOrderComponent1,
Article = article1
};
productionOrderComponent1.ProductionOrder = productionOrder1;
context.ProductionOrderComponent.AddOrUpdate(p => p.ProductionOrderComponentId, productionOrderComponent1);
context.ProductionOrders.AddOrUpdate(p => p.FaId, productionOrder1);
////////////////////////////////////////////////////
var inkoArticle1 = new Article
{
ArticleNr = "10501",
Name = "Cresta Extra Inko Extra",
ArticleType = ArticleType.IncontinencePad,
MaxInkoRewet = 0.5,
MinInkoRetention = 180,
MaxHyTec1 = 20,
MaxHyTec2 = 60,
MaxHyTec3 = 85,
MaxInkoRewetAfterAquisition = 2
};
var productionOrder2 = new ProductionOrder
{
FaNr = "FA654321",
StartDateTime = new DateTime(2016, 1, 1),
EndDateTime = new DateTime(2018, 1, 1),
Machine = machine3,
Article = inkoArticle1
};
context.Articles.AddOrUpdate(a => a.ArticleId, inkoArticle1);
context.ProductionOrders.AddOrUpdate(p => p.FaId, productionOrder2);
////////////////////////////////////////////////////
var shift1 = new ShiftSchedule
{
Name = "Mo Nacht",
ShiftType = ShiftType.Night,
StartDay = DayOfWeek.Sunday,
EndDay = DayOfWeek.Monday,
StartTime = new TimeSpan(22, 00, 00),
EndTime = new TimeSpan(04, 59, 59)
};
var shift2 = new ShiftSchedule
{
Name = "Mo Morgen",
ShiftType = ShiftType.Morning,
StartDay = DayOfWeek.Monday,
EndDay = DayOfWeek.Monday,
StartTime = new TimeSpan(05, 00, 00),
EndTime = new TimeSpan(13, 59, 59)
};
var shift3 = new ShiftSchedule
{
Name = "Mo Spät",
ShiftType = ShiftType.Late,
StartDay = DayOfWeek.Monday,
EndDay = DayOfWeek.Monday,
StartTime = new TimeSpan(14, 00, 00),
EndTime = new TimeSpan(22, 59, 59)
};
var shift4 = new ShiftSchedule
{
Name = "Di Nacht",
ShiftType = ShiftType.Night,
StartDay = DayOfWeek.Monday,
EndDay = DayOfWeek.Tuesday,
StartTime = new TimeSpan(22, 00, 00),
EndTime = new TimeSpan(04, 59, 59)
};
var shift5 = new ShiftSchedule
{
Name = "Di Morgen",
ShiftType = ShiftType.Morning,
StartDay = DayOfWeek.Tuesday,
EndDay = DayOfWeek.Tuesday,
StartTime = new TimeSpan(05, 00, 00),
EndTime = new TimeSpan(13, 59, 59)
};
var shift6 = new ShiftSchedule
{
Name = "Di Spät",
ShiftType = ShiftType.Late,
StartDay = DayOfWeek.Tuesday,
EndDay = DayOfWeek.Tuesday,
StartTime = new TimeSpan(14, 00, 00),
EndTime = new TimeSpan(22, 59, 59)
};
var shift7 = new ShiftSchedule
{
Name = "Mi Nacht",
ShiftType = ShiftType.Night,
StartDay = DayOfWeek.Tuesday,
EndDay = DayOfWeek.Wednesday,
StartTime = new TimeSpan(22, 00, 00),
EndTime = new TimeSpan(04, 59, 59)
};
var shift8 = new ShiftSchedule
{
Name = "Mi Morgen",
ShiftType = ShiftType.Morning,
StartDay = DayOfWeek.Wednesday,
EndDay = DayOfWeek.Wednesday,
StartTime = new TimeSpan(05, 00, 00),
EndTime = new TimeSpan(13, 59, 59)
};
var shift9 = new ShiftSchedule
{
Name = "Mi Spät",
ShiftType = ShiftType.Late,
StartDay = DayOfWeek.Wednesday,
EndDay = DayOfWeek.Wednesday,
StartTime = new TimeSpan(14, 00, 00),
EndTime = new TimeSpan(22, 59, 59)
};
var shift10 = new ShiftSchedule
{
Name = "Do Nacht",
ShiftType = ShiftType.Night,
StartDay = DayOfWeek.Wednesday,
EndDay = DayOfWeek.Thursday,
StartTime = new TimeSpan(22, 00, 00),
EndTime = new TimeSpan(04, 59, 59)
};
var shift11 = new ShiftSchedule
{
Name = "Do Morgen",
ShiftType = ShiftType.Morning,
StartDay = DayOfWeek.Thursday,
EndDay = DayOfWeek.Thursday,
StartTime = new TimeSpan(05, 00, 00),
EndTime = new TimeSpan(13, 59, 59)
};
var shift12 = new ShiftSchedule
{
Name = "Do Spät",
ShiftType = ShiftType.Late,
StartDay = DayOfWeek.Thursday,
EndDay = DayOfWeek.Thursday,
StartTime = new TimeSpan(14, 00, 00),
EndTime = new TimeSpan(22, 59, 59)
};
var shift13 = new ShiftSchedule
{
Name = "Fr Nacht",
ShiftType = ShiftType.Night,
StartDay = DayOfWeek.Thursday,
EndDay = DayOfWeek.Friday,
StartTime = new TimeSpan(22, 00, 00),
EndTime = new TimeSpan(04, 59, 59)
};
var shift14 = new ShiftSchedule
{
Name = "Fr Morgen",
ShiftType = ShiftType.Morning,
StartDay = DayOfWeek.Friday,
EndDay = DayOfWeek.Friday,
StartTime = new TimeSpan(05, 00, 00),
EndTime = new TimeSpan(13, 59, 59)
};
var shift15 = new ShiftSchedule
{
Name = "Fr Spät",
ShiftType = ShiftType.Late,
StartDay = DayOfWeek.Friday,
EndDay = DayOfWeek.Friday,
StartTime = new TimeSpan(14, 00, 00),
EndTime = new TimeSpan(22, 59, 59)
};
var shift16 = new ShiftSchedule
{
Name = "Sa Nacht",
ShiftType = ShiftType.Night,
StartDay = DayOfWeek.Friday,
EndDay = DayOfWeek.Saturday,
StartTime = new TimeSpan(22, 00, 00),
EndTime = new TimeSpan(04, 59, 59)
};
context.ShiftSchedules.AddOrUpdate(s => s.Name, shift1);
context.ShiftSchedules.AddOrUpdate(s => s.Name, shift2);
context.ShiftSchedules.AddOrUpdate(s => s.Name, shift3);
context.ShiftSchedules.AddOrUpdate(s => s.Name, shift4);
context.ShiftSchedules.AddOrUpdate(s => s.Name, shift5);
context.ShiftSchedules.AddOrUpdate(s => s.Name, shift6);
context.ShiftSchedules.AddOrUpdate(s => s.Name, shift7);
context.ShiftSchedules.AddOrUpdate(s => s.Name, shift8);
context.ShiftSchedules.AddOrUpdate(s => s.Name, shift9);
context.ShiftSchedules.AddOrUpdate(s => s.Name, shift10);
context.ShiftSchedules.AddOrUpdate(s => s.Name, shift11);
context.ShiftSchedules.AddOrUpdate(s => s.Name, shift12);
context.ShiftSchedules.AddOrUpdate(s => s.Name, shift13);
context.ShiftSchedules.AddOrUpdate(s => s.Name, shift14);
context.ShiftSchedules.AddOrUpdate(s => s.Name, shift15);
context.ShiftSchedules.AddOrUpdate(s => s.Name, shift16);
////////////////////////////////////////////////////
var testSheet = new TestSheet
{
TestSheetId = 1,
FaNr = "FA123456",
CreatedDateTime = new DateTime(2016, 11, 2, 1, 50, 0),
ShiftType = ShiftType.Night,
MachineNr = "M11",
SAPType = "EKX",
SAPNr = "EN67",
ProductName = "Babydream",
SizeName = "Maxi-Plus",
ArticleType = ArticleType.BabyDiaper
};
var babyDiapersRewetTestValue1 = new TestValue
{
TestValueId = 1,
CreatedDateTime = new DateTime(2016, 11, 2, 1, 50, 0),
LastEditedDateTime = new DateTime(2016, 11, 2, 1, 50, 0),
DayInYearOfArticleCreation = 307,
CreatedPerson = "Hans",
LastEditedPerson = "Hans",
ArticleTestType = ArticleType.BabyDiaper,
TestValueType = TestValueType.Single,
TestSheetId = 1
};
var babyDiapersRetentionTestValueAverage = new TestValue
{
TestValueId = 2,
CreatedDateTime = new DateTime(2016, 11, 2, 1, 50, 0),
LastEditedDateTime = new DateTime(2016, 11, 2, 1, 50, 0),
CreatedPerson = "Hans",
LastEditedPerson = "Hans",
ArticleTestType = ArticleType.BabyDiaper,
TestValueType = TestValueType.Average,
TestSheetId = 1
};
var babyDiapersRetentionTestValueStandardDeviation = new TestValue
{
TestValueId = 3,
CreatedDateTime = new DateTime(2016, 11, 2, 1, 50, 0),
LastEditedDateTime = new DateTime(2016, 11, 2, 1, 50, 0),
CreatedPerson = "Hans",
LastEditedPerson = "Hans",
ArticleTestType = ArticleType.BabyDiaper,
TestValueType = TestValueType.StandardDeviation,
TestSheetId = 1
};
var babyDiapersRewetTestValueAverage = new TestValue
{
TestValueId = 4,
CreatedDateTime = new DateTime(2016, 11, 2, 1, 50, 0),
LastEditedDateTime = new DateTime(2016, 11, 2, 1, 50, 0),
CreatedPerson = "Hans",
LastEditedPerson = "Hans",
ArticleTestType = ArticleType.BabyDiaper,
TestValueType = TestValueType.Average,
TestSheetId = 1
};
var babyDiapersRewetTestValueStandardDeviation = new TestValue
{
TestValueId = 5,
CreatedDateTime = new DateTime(2016, 11, 2, 1, 50, 0),
LastEditedDateTime = new DateTime(2016, 11, 2, 1, 50, 0),
CreatedPerson = "Hans",
LastEditedPerson = "Hans",
ArticleTestType = ArticleType.BabyDiaper,
TestValueType = TestValueType.StandardDeviation,
TestSheetId = 1
};
var babyDiapersPenetrationTimeTestValueAverage = new TestValue
{
TestValueId = 6,
CreatedDateTime = new DateTime(2016, 11, 2, 1, 50, 0),
LastEditedDateTime = new DateTime(2016, 11, 2, 1, 50, 0),
CreatedPerson = "Hans",
LastEditedPerson = "Hans",
ArticleTestType = ArticleType.BabyDiaper,
TestValueType = TestValueType.Average,
TestSheetId = 1
};
var babyDiapersPenetrationTimeTestValueStandardDeviation = new TestValue
{
TestValueId = 7,
CreatedDateTime = new DateTime(2016, 11, 2, 1, 50, 0),
LastEditedDateTime = new DateTime(2016, 11, 2, 1, 50, 0),
CreatedPerson = "Hans",
LastEditedPerson = "Hans",
ArticleTestType = ArticleType.BabyDiaper,
TestValueType = TestValueType.StandardDeviation,
TestSheetId = 1
};
var babyDiapersRewetTest1 = new BabyDiaperTestValue
{
BabyDiaperTestValueId = 1,
DiaperCreatedTime = new TimeSpan(1, 38, 0),
WeightDiaperDry = 32.9,
Rewet140Value = 0.1,
Rewet210Value = 0.18,
StrikeTroughValue = 0.28,
DistributionOfTheStrikeTrough = 240,
Rewet140Rw = RwType.Ok,
Rewet210Rw = RwType.Ok,
TestType = TestTypeBabyDiaper.Rewet
};
var babyDiapersRewetTestAverage = new BabyDiaperTestValue
{
BabyDiaperTestValueId = 2,
DiaperCreatedTime = new TimeSpan(1, 38, 0),
WeightDiaperDry = 32.9,
Rewet140Value = 0.1,
Rewet210Value = 0.18,
StrikeTroughValue = 0.28,
DistributionOfTheStrikeTrough = 240,
Rewet140Rw = RwType.Ok,
Rewet210Rw = RwType.Ok,
TestType = TestTypeBabyDiaper.Rewet
};
var babyDiapersRewetTestStandardDeviation = new BabyDiaperTestValue
{
BabyDiaperTestValueId = 3,
DiaperCreatedTime = new TimeSpan(1, 38, 0),
WeightDiaperDry = 32.9,
Rewet140Value = 0.1,
Rewet210Value = 0.18,
StrikeTroughValue = 0.28,
DistributionOfTheStrikeTrough = 240,
Rewet140Rw = RwType.Ok,
Rewet210Rw = RwType.Ok,
TestType = TestTypeBabyDiaper.Rewet
};
babyDiapersRewetTestValue1.BabyDiaperTestValue = babyDiapersRewetTest1;
var testNote = new TestValueNote
{
Error = error2,
Message = "Testnotiz"
};
var babyDiapersRetentionTestValue1 = new TestValue
{
TestValueId = 2,
CreatedDateTime = new DateTime(2016, 11, 2, 1, 51, 0),
LastEditedDateTime = new DateTime(2016, 11, 2, 1, 51, 0),
DayInYearOfArticleCreation = 307,
CreatedPerson = "Hans",
LastEditedPerson = "Hans",
ArticleTestType = ArticleType.BabyDiaper,
TestValueType = TestValueType.Single,
TestSheetId = 1,
TestValueNote = new List <TestValueNote> {
testNote
}
};
testNote.TestValue = babyDiapersRetentionTestValue1;
var babyDiapersRetentionTest1 = new BabyDiaperTestValue
{
BabyDiaperTestValueId = 2,
DiaperCreatedTime = new TimeSpan(1, 38, 0),
WeightDiaperDry = 33.0,
RetentionWetWeight = 414.0,
RetentionAfterZentrifugeValue = 381.0,
RetentionAfterZentrifugePercent = 1155,
RetentionRw = RwType.Better,
SapType = "EKX",
SapNr = "EN67",
SapGHoewiValue = 10.70,
TestType = TestTypeBabyDiaper.Retention
};
babyDiapersRetentionTestValue1.BabyDiaperTestValue = babyDiapersRetentionTest1;
var babyDiapersRetentionTestAverage = new BabyDiaperTestValue
{
BabyDiaperTestValueId = 4,
DiaperCreatedTime = new TimeSpan(0, 0, 0),
WeightDiaperDry = 0,
RetentionRw = RwType.Ok,
RetentionAfterZentrifugeValue = 0,
RetentionWetWeight = 0,
RetentionAfterZentrifugePercent = 0,
TestType = TestTypeBabyDiaper.Retention
};
var babyDiapersRetentionTestStandardDeviation = new BabyDiaperTestValue
{
BabyDiaperTestValueId = 5,
DiaperCreatedTime = new TimeSpan(0, 0, 0),
WeightDiaperDry = 0,
RetentionRw = RwType.Ok,
RetentionAfterZentrifugeValue = 0,
RetentionWetWeight = 0,
RetentionAfterZentrifugePercent = 0,
TestType = TestTypeBabyDiaper.Retention
};
var babyDiapersPenetrationTimeTestAverage = new BabyDiaperTestValue
{
BabyDiaperTestValueId = 6,
DiaperCreatedTime = new TimeSpan(0, 0, 0),
WeightDiaperDry = 0,
PenetrationTimeAdditionThird = 0,
PenetrationTimeAdditionSecond = 0,
PenetrationTimeAdditionFourth = 0,
PenetrationTimeAdditionFirst = 0,
RetentionAfterZentrifugePercent = 0,
PenetrationRwType = RwType.Ok,
TestType = TestTypeBabyDiaper.RewetAndPenetrationTime
};
var babyDiapersPenetrationTimeTestStandardDeviation = new BabyDiaperTestValue
{
BabyDiaperTestValueId = 7,
DiaperCreatedTime = new TimeSpan(0, 0, 0),
PenetrationTimeAdditionThird = 0,
PenetrationTimeAdditionSecond = 0,
PenetrationTimeAdditionFourth = 0,
PenetrationTimeAdditionFirst = 0,
RetentionAfterZentrifugePercent = 0,
WeightDiaperDry = 0,
PenetrationRwType = RwType.Ok,
TestType = TestTypeBabyDiaper.RewetAndPenetrationTime
};
babyDiapersRewetTestValue1.BabyDiaperTestValue = babyDiapersRewetTest1;
babyDiapersRewetTestValueAverage.BabyDiaperTestValue = babyDiapersRewetTestAverage;
babyDiapersRewetTestValueStandardDeviation.BabyDiaperTestValue = babyDiapersRewetTestStandardDeviation;
babyDiapersRetentionTestValueAverage.BabyDiaperTestValue = babyDiapersRetentionTestAverage;
babyDiapersRetentionTestValueStandardDeviation.BabyDiaperTestValue = babyDiapersRetentionTestStandardDeviation;
babyDiapersPenetrationTimeTestValueAverage.BabyDiaperTestValue = babyDiapersPenetrationTimeTestAverage;
babyDiapersPenetrationTimeTestValueStandardDeviation.BabyDiaperTestValue = babyDiapersPenetrationTimeTestStandardDeviation;
testSheet.TestValues = new List <TestValue>
{
babyDiapersRewetTestValue1,
babyDiapersRetentionTestValue1,
babyDiapersRetentionTestValueAverage,
babyDiapersRetentionTestValueStandardDeviation,
babyDiapersRewetTestValueAverage,
babyDiapersRewetTestValueStandardDeviation,
babyDiapersPenetrationTimeTestValueAverage,
babyDiapersPenetrationTimeTestValueStandardDeviation
};
context.TestSheets.AddOrUpdate(m => m.FaNr, testSheet);
context.TestValues.AddOrUpdate(m => m.TestValueId, babyDiapersRewetTestValue1);
context.TestValues.AddOrUpdate(m => m.TestValueId, babyDiapersRewetTestValueAverage);
context.TestValues.AddOrUpdate(m => m.TestValueId, babyDiapersRewetTestValueStandardDeviation);
context.TestValues.AddOrUpdate(m => m.TestValueId, babyDiapersRetentionTestValueAverage);
context.TestValues.AddOrUpdate(m => m.TestValueId, babyDiapersRetentionTestValueStandardDeviation);
context.TestValues.AddOrUpdate(m => m.TestValueId, babyDiapersPenetrationTimeTestValueAverage);
context.TestValues.AddOrUpdate(m => m.TestValueId, babyDiapersPenetrationTimeTestValueStandardDeviation);
context.BabyDiaperTestValues.AddOrUpdate(m => m.BabyDiaperTestValueId, babyDiapersRewetTest1);
context.BabyDiaperTestValues.AddOrUpdate(m => m.BabyDiaperTestValueId, babyDiapersRewetTestStandardDeviation);
context.BabyDiaperTestValues.AddOrUpdate(m => m.BabyDiaperTestValueId, babyDiapersRewetTestAverage);
context.BabyDiaperTestValues.AddOrUpdate(m => m.BabyDiaperTestValueId, babyDiapersRetentionTestStandardDeviation);
context.BabyDiaperTestValues.AddOrUpdate(m => m.BabyDiaperTestValueId, babyDiapersRetentionTestAverage);
context.BabyDiaperTestValues.AddOrUpdate(m => m.BabyDiaperTestValueId, babyDiapersPenetrationTimeTestStandardDeviation);
context.BabyDiaperTestValues.AddOrUpdate(m => m.BabyDiaperTestValueId, babyDiapersPenetrationTimeTestAverage);
babyDiapersPenetrationTimeTestValueAverage.BabyDiaperTestValue = babyDiapersPenetrationTimeTestAverage;
}
private void UpdateRewetAvg(TestSheet testSheet, TestValue rewetTestAvg)
{
var productionOrder = TestBll.GetProductionOrder(testSheet.FaNr);
var tempBabyDiaper = new BabyDiaperTestValue {
Rewet140Rw = RwType.Ok, Rewet210Rw = RwType.Ok
};
var counter = 0;
foreach (
var testValue in
testSheet.TestValues.Where(
testValue =>
(testValue.TestValueType == TestValueType.Single) &&
((testValue.BabyDiaperTestValue.TestType == TestTypeBabyDiaper.Rewet) ||
(testValue.BabyDiaperTestValue.TestType == TestTypeBabyDiaper.RewetAndPenetrationTime)))
)
{
tempBabyDiaper.WeightDiaperDry += testValue.BabyDiaperTestValue.WeightDiaperDry;
tempBabyDiaper.Rewet140Value += testValue.BabyDiaperTestValue.Rewet140Value;
tempBabyDiaper.Rewet210Value += testValue.BabyDiaperTestValue.Rewet210Value;
tempBabyDiaper.StrikeTroughValue += testValue.BabyDiaperTestValue.StrikeTroughValue;
tempBabyDiaper.DistributionOfTheStrikeTrough += testValue.BabyDiaperTestValue.DistributionOfTheStrikeTrough;
if (testValue.BabyDiaperTestValue.Rewet140Rw == RwType.Worse)
{
tempBabyDiaper.Rewet140Rw = RwType.SomethingWorse;
}
if (testValue.BabyDiaperTestValue.Rewet210Rw == RwType.Worse)
{
tempBabyDiaper.Rewet210Rw = RwType.SomethingWorse;
}
if (testValue.BabyDiaperTestValue.PenetrationRwType == RwType.Worse)
{
tempBabyDiaper.PenetrationRwType = RwType.SomethingWorse;
}
counter++;
}
if (counter == 0)
{
counter = 1;
}
rewetTestAvg.BabyDiaperTestValue.WeightDiaperDry = tempBabyDiaper.WeightDiaperDry / counter;
rewetTestAvg.BabyDiaperTestValue.Rewet140Value = tempBabyDiaper.Rewet140Value / counter;
rewetTestAvg.BabyDiaperTestValue.Rewet210Value = tempBabyDiaper.Rewet210Value / counter;
rewetTestAvg.BabyDiaperTestValue.StrikeTroughValue = tempBabyDiaper.StrikeTroughValue / counter;
rewetTestAvg.BabyDiaperTestValue.DistributionOfTheStrikeTrough = tempBabyDiaper.DistributionOfTheStrikeTrough / counter;
if (GetRewet140RwType(rewetTestAvg.BabyDiaperTestValue.Rewet140Value, productionOrder) == RwType.Worse)
{
tempBabyDiaper.Rewet140Rw = RwType.Worse;
}
if (GetRewet210RwType(rewetTestAvg.BabyDiaperTestValue.Rewet210Value, productionOrder) == RwType.Worse)
{
tempBabyDiaper.Rewet210Rw = RwType.Worse;
}
if (GetPenetrationRwType(rewetTestAvg.BabyDiaperTestValue.PenetrationTimeAdditionFourth, productionOrder) == RwType.Worse)
{
tempBabyDiaper.PenetrationRwType = RwType.Worse;
}
rewetTestAvg.BabyDiaperTestValue.Rewet140Rw = tempBabyDiaper.Rewet140Rw;
rewetTestAvg.BabyDiaperTestValue.Rewet210Rw = tempBabyDiaper.Rewet210Rw;
rewetTestAvg.BabyDiaperTestValue.PenetrationRwType = tempBabyDiaper.PenetrationRwType;
}
