/// <summary>
/// A mock for BabyDiaperRetentionBll for Save methods
/// </summary>
/// <param name="testSheet">testSheet data which would be in the db</param>
/// <param name="productionOrder">testSheet data which would be in the db</param>
/// <param name="testValue">testValue data which would be in the db</param>
/// <returns>a ITestBll moq</returns>
public static ITestBll GetTestBllForSavingAndUpdating(TestSheet testSheet, ProductionOrder productionOrder, TestValue testValue)
{
var mock = new Mock <ITestBll>
{
Name = "MockHelper.GetTestBllForSavingAndUpdating",
DefaultValue = DefaultValue.Mock
};
mock.Setup(x => x.SaveNewTestValue(It.IsAny <TestValue>()))
.Returns(( TestValue tValue ) => tValue);
mock.Setup(x => x.UpdateTestValue(It.IsAny <TestValue>()))
.Returns(( TestValue tValue ) => tValue);
mock.Setup(x => x.GetTestSheetInfo(It.IsAny <Int32>()))
.Returns(testSheet);
mock.Setup(x => x.GetProductionOrder(It.IsAny <String>()))
.Returns(productionOrder);
mock.Setup(x => x.GetTestValue(It.IsAny <Int32>()))
.Returns(testValue);
mock.Setup(x => x.UpdateTestSheet())
.Returns(0);
mock.Setup(x => x.DeleteNote(It.IsAny <Int32>()))
.Returns(new TestValueNote());
return(mock.Object);
}
public void GetBabyDiaperRetentionEditViewModelTest()
{
var listOfTestValues = new List <TestValue>
{
new TestValue
{
TestValueId = 1,
TestSheetId = 1,
LastEditedPerson = "Hans",
DayInYearOfArticleCreation = 123,
BabyDiaperTestValue =
new BabyDiaperTestValue
{
DiaperCreatedTime = new TimeSpan(5, 10, 0),
WeightDiaperDry = 32.2,
RetentionWetWeight = 398.1,
TestType = TestTypeBabyDiaper.Retention
}
}
};
var testSheetInDb = new TestSheet
{
TestSheetId = 1,
MachineNr = "M11",
CreatedDateTime = new DateTime(2016, 5, 5),
TestValues = listOfTestValues
};
foreach (var testValue in listOfTestValues)
{
testValue.TestSheet = testSheetInDb;
}
var babyDiaperRetentionBll =
MockHelperBll.GetTestBll(
testSheetInDb
);
var babyDiaperServiceHelper = MockHelperTestServiceHelper.GetTestServiceHelper("IT/11/16/");
var target = new BabyDiaperRetentionService(new NLogLoggerFactory())
{
TestBll = babyDiaperRetentionBll,
TestServiceHelper = babyDiaperServiceHelper
};
var actual = target.GetBabyDiapersRetentionEditViewModel(1);
Assert.Equal(testSheetInDb.TestSheetId, actual.TestSheetId);
Assert.Equal(1, actual.TestValueId);
Assert.Equal("IT/11/16/", actual.ProductionCode);
Assert.Equal("Hans", actual.TestPerson);
Assert.Equal(123, actual.ProductionCodeDay);
Assert.Equal(new TimeSpan(5, 10, 0), actual.ProductionCodeTime);
Assert.Equal(32.2, actual.DiaperWeight);
Assert.Equal(398.1, actual.WeightRetentionWet);
Assert.Equal(2,
actual.NoteCodes.ToList()
.Count);
}
public void GetNewBabyDiaperRewetEditViewModelFromExistingTestSheetTest()
{
var testSheetInDb = new TestSheet
{
TestSheetId = 1,
MachineNr = "M11",
CreatedDateTime = new DateTime(2016, 5, 5)
};
var babyDiaperRetentionBll =
MockHelperBll.GetTestBll(
testSheetInDb
);
var babyDiaperServiceHelper = MockHelperTestServiceHelper.GetTestServiceHelper("IT/11/16/");
var target = new BabyDiaperRewetService(new NLogLoggerFactory())
{
TestBll = babyDiaperRetentionBll,
TestServiceHelper = babyDiaperServiceHelper
};
var actual = target.GetNewBabyDiaperRewetEditViewModel(1);
Assert.Equal(testSheetInDb.TestSheetId, actual.TestSheetId);
Assert.Equal(-1, actual.TestValueId);
Assert.Equal("IT/11/16/", actual.ProductionCode);
}
public void GetNewInkoRetentionEditViewModelFromExistingTestSheetTest()
{
var testSheetInDb = new TestSheet
{
TestSheetId = 2,
MachineNr = "M49",
CreatedDateTime = new DateTime(2016, 5, 5),
ArticleType = ArticleType.IncontinencePad
};
var testBll =
MockHelperBll.GetTestBll(
testSheetInDb
);
var testServiceHelper = MockHelperTestServiceHelper.GetTestServiceHelper("IT/49/16/");
var target = new InkoRetentionService(new NLogLoggerFactory())
{
TestBll = testBll,
TestServiceHelper = testServiceHelper
};
var actual = target.GetNewInkoRetentionEditViewModel(2);
Assert.Equal(testSheetInDb.TestSheetId, actual.TestSheetId);
Assert.Equal(-1, actual.TestValueId);
Assert.Equal("IT/49/16/", actual.ProductionCode);
}
private static void UpdateInkoRewetStDev(TestSheet testSheet, TestValue rewetTestAvg, TestValue rewetTestStDev)
{
var tempInko = new IncontinencePadTestValue();
var counter = 0;
foreach (
var testValue in
testSheet.TestValues.Where(
testValue =>
(testValue.TestValueType == TestValueType.Single) &&
(testValue.IncontinencePadTestValue.TestType == TestTypeIncontinencePad.RewetFree))
)
{
tempInko.RewetFreeDryValue += Math.Pow(testValue.IncontinencePadTestValue.RewetFreeDryValue - rewetTestAvg.IncontinencePadTestValue.RewetFreeDryValue, 2);
tempInko.RewetFreeWetValue += Math.Pow(testValue.IncontinencePadTestValue.RewetFreeWetValue - rewetTestAvg.IncontinencePadTestValue.RewetFreeWetValue, 2);
tempInko.RewetFreeDifference += Math.Pow(testValue.IncontinencePadTestValue.RewetFreeDifference - rewetTestAvg.IncontinencePadTestValue.RewetFreeDifference, 2);
counter++;
}
if (counter < 2)
{
rewetTestStDev.IncontinencePadTestValue.RewetFreeDryValue = 0;
rewetTestStDev.IncontinencePadTestValue.RewetFreeWetValue = 0;
rewetTestStDev.IncontinencePadTestValue.RewetFreeDifference = 0;
}
else
{
counter--;
rewetTestStDev.IncontinencePadTestValue.RewetFreeDryValue = Math.Sqrt(tempInko.RewetFreeDryValue / counter);
rewetTestStDev.IncontinencePadTestValue.RewetFreeWetValue = Math.Sqrt(tempInko.RewetFreeWetValue / counter);
rewetTestStDev.IncontinencePadTestValue.RewetFreeDifference = Math.Sqrt(tempInko.RewetFreeDifference / counter);
}
}
public void GetBabyDiaperRewetEditViewModelFromNotExistingTestValueTest()
{
var listOfTestValues = new List <TestValue>
{
new TestValue {
TestValueId = 1, TestSheetId = 1, BabyDiaperTestValue = new BabyDiaperTestValue()
}
};
var testSheetInDb = new TestSheet
{
TestSheetId = 1,
MachineNr = "M11",
CreatedDateTime = new DateTime(2016, 5, 5),
TestValues = listOfTestValues
};
foreach (var testValue in listOfTestValues)
{
testValue.TestSheet = testSheetInDb;
}
var babyDiaperRetentionBll =
MockHelperBll.GetTestBll(
testSheetInDb
);
var target = new BabyDiaperRewetService(new NLogLoggerFactory())
{
TestBll = babyDiaperRetentionBll
};
var actual = target.GetBabyDiaperRewetEditViewModel(2);
Assert.Equal(null, actual);
}
public void GetInkoRetentionEditViewModelFromNotExistingTestValueTest()
{
var listOfTestValues = new List <TestValue>
{
new TestValue {
TestValueId = 1, TestSheetId = 1, IncontinencePadTestValue = new IncontinencePadTestValue(), ArticleTestType = ArticleType.IncontinencePad
}
};
var testSheetInDb = new TestSheet
{
TestSheetId = 2,
MachineNr = "M49",
CreatedDateTime = new DateTime(2016, 5, 5),
TestValues = listOfTestValues
};
foreach (var testValue in listOfTestValues)
{
testValue.TestSheet = testSheetInDb;
}
var testBll =
MockHelperBll.GetTestBll(
testSheetInDb
);
var target = new InkoRetentionService(new NLogLoggerFactory())
{
TestBll = testBll
};
var actual = target.GetInkoRetentionEditViewModel(2);
Assert.Equal(null, actual);
}
public void GetInkoRewetEditViewModelWithNoBabyDiaperTestVauleTest()
{
var listOfTestValues = new List <TestValue>
{
new TestValue {
TestValueId = 1, TestSheetId = 1
}
};
var testSheetInDb = new TestSheet
{
TestSheetId = 1,
MachineNr = "M49",
CreatedDateTime = new DateTime(2016, 5, 5),
TestValues = listOfTestValues
};
foreach (var testValue in listOfTestValues)
{
testValue.TestSheet = testSheetInDb;
}
var testBll =
MockHelperBll.GetTestBll(
testSheetInDb
);
var target = new InkoRewetService(new NLogLoggerFactory())
{
TestBll = testBll
};
var actual = target.GetInkoRewetEditViewModel(1);
Assert.Equal(null, actual);
}
private static void UpdateInkoAquisitionStDev(TestSheet testSheet, TestValue aquisitionTestAvg, TestValue aquisitionTestStDev)
{
var tempInko = new IncontinencePadTestValue();
var counter = 0;
foreach (
var testValue in
testSheet.TestValues.Where(
testValue =>
(testValue.TestValueType == TestValueType.Single) &&
(testValue.IncontinencePadTestValue.TestType == TestTypeIncontinencePad.AcquisitionTimeAndRewet))
)
{
tempInko.AcquisitionTimeFirst += Math.Pow(
testValue.IncontinencePadTestValue.AcquisitionTimeFirst - aquisitionTestAvg.IncontinencePadTestValue.AcquisitionTimeFirst,
2);
tempInko.AcquisitionTimeSecond +=
Math.Pow(testValue.IncontinencePadTestValue.AcquisitionTimeSecond - aquisitionTestAvg.IncontinencePadTestValue.AcquisitionTimeSecond, 2);
tempInko.AcquisitionTimeThird += Math.Pow(
testValue.IncontinencePadTestValue.AcquisitionTimeThird - aquisitionTestAvg.IncontinencePadTestValue.AcquisitionTimeThird,
2);
tempInko.AcquisitionWeight += Math.Pow(testValue.IncontinencePadTestValue.AcquisitionWeight - aquisitionTestAvg.IncontinencePadTestValue.AcquisitionWeight, 2);
tempInko.RewetAfterAcquisitionTimeDryWeight +=
Math.Pow(
testValue.IncontinencePadTestValue.RewetAfterAcquisitionTimeDryWeight - aquisitionTestAvg.IncontinencePadTestValue.RewetAfterAcquisitionTimeDryWeight,
2);
tempInko.RewetAfterAcquisitionTimeWetWeight +=
Math.Pow(
testValue.IncontinencePadTestValue.RewetAfterAcquisitionTimeWetWeight - aquisitionTestAvg.IncontinencePadTestValue.RewetAfterAcquisitionTimeWetWeight,
2);
tempInko.RewetAfterAcquisitionTimeWeightDifference +=
Math.Pow(
testValue.IncontinencePadTestValue.RewetAfterAcquisitionTimeWeightDifference
- aquisitionTestAvg.IncontinencePadTestValue.RewetAfterAcquisitionTimeWeightDifference,
2);
counter++;
}
if (counter < 2)
{
aquisitionTestStDev.IncontinencePadTestValue.AcquisitionTimeFirst = 0;
aquisitionTestStDev.IncontinencePadTestValue.AcquisitionTimeSecond = 0;
aquisitionTestStDev.IncontinencePadTestValue.AcquisitionTimeThird = 0;
aquisitionTestStDev.IncontinencePadTestValue.AcquisitionWeight = 0;
aquisitionTestStDev.IncontinencePadTestValue.RewetAfterAcquisitionTimeDryWeight = 0;
aquisitionTestStDev.IncontinencePadTestValue.RewetAfterAcquisitionTimeWetWeight = 0;
aquisitionTestStDev.IncontinencePadTestValue.RewetAfterAcquisitionTimeWeightDifference = 0;
}
else
{
counter--;
aquisitionTestStDev.IncontinencePadTestValue.AcquisitionTimeFirst = Math.Sqrt(tempInko.AcquisitionTimeFirst / counter);
aquisitionTestStDev.IncontinencePadTestValue.AcquisitionTimeSecond = Math.Sqrt(tempInko.AcquisitionTimeSecond / counter);
aquisitionTestStDev.IncontinencePadTestValue.AcquisitionTimeThird = Math.Sqrt(tempInko.AcquisitionTimeThird / counter);
aquisitionTestStDev.IncontinencePadTestValue.AcquisitionWeight = Math.Sqrt(tempInko.AcquisitionWeight / counter);
aquisitionTestStDev.IncontinencePadTestValue.RewetAfterAcquisitionTimeDryWeight = Math.Sqrt(tempInko.RewetAfterAcquisitionTimeDryWeight / counter);
aquisitionTestStDev.IncontinencePadTestValue.RewetAfterAcquisitionTimeWetWeight = Math.Sqrt(tempInko.RewetAfterAcquisitionTimeWetWeight / counter);
aquisitionTestStDev.IncontinencePadTestValue.RewetAfterAcquisitionTimeWeightDifference = Math.Sqrt(tempInko.RewetAfterAcquisitionTimeWeightDifference / counter);
}
}
public void GetTestSheetForActualAndLastThreeShiftsFoundTest2()
{
var now = DateTime.Now;
var testsheet = new TestSheet
{
FaNr = "666",
ShiftType = ShiftType.Late,
DayInYear = now.DayOfYear,
CreatedDateTime = now
};
var testsheet2 = new TestSheet
{
FaNr = "666",
ShiftType = ShiftType.Late,
DayInYear = now.DayOfYear,
CreatedDateTime = now.AddDays(-7)
};
var shift = new ShiftSchedule
{
Name = "The One",
ShiftType = ShiftType.Late,
EndTime = new TimeSpan(now.Hour + 2, now.Minute + 10, now.Second),
StartTime = new TimeSpan(now.Hour - 2, now.Minute - 10, now.Second),
StartDay = now.DayOfWeek,
EndDay = now.AddDays(1)
.DayOfWeek
};
var shiftSheduleListQuery = new List <ShiftSchedule>
{
shift,
shift
};
var testSheetListQuery = new List <TestSheet>
{
testsheet,
testsheet2
};
var testSheetRepository = MockHelperBll.TestSheetRepository(testSheetListQuery.AsQueryable());
var shifthelper = MockHelperBll.GetShiftHelper(ShiftType.Late, shift, shiftSheduleListQuery);
var target = new LaborDashboardBll(new NLogLoggerFactory())
{
ShiftHelper = shifthelper,
TestSheets = testSheetRepository
};
var actual = target.GetTestSheetForActualAndLastThreeShifts();
actual.Count.Should()
.Be(1);
}
/// <summary>
/// A mock that adds test for test sheets Repository
/// </summary>
/// <param name="testSheet">Test sheet to be added</param>
/// <returns>a generic repository for test sheets</returns>
public static IGenericRepository <TestSheet> AddTestSheets(TestSheet testSheet)
{
var mock = new Mock <IGenericRepository <TestSheet> >
{
Name = "MockHelper.TestSheetRepository",
DefaultValue = DefaultValue.Mock
};
return(mock.Object);
}
/// <summary>
/// Creates a productionOrder item with the values from the testsheet
/// </summary>
/// <param name="testSheet">the testsheet</param>
/// <returns>a production order item</returns>
public ProductionOrderItem ToProductionOrderItem(TestSheet testSheet)
=> new ProductionOrderItem
{
SheetId = testSheet.TestSheetId,
HasNotes = testSheet.TestValues?.ToList()
.Exists(value => value.TestValueNote.Count > 0) ?? false,
Notes = testSheet.TestValues != null?ToDashboardNote(testSheet.TestValues) : null,
DashboardInfos = testSheet.TestValues != null?ToDashboardInfos(testSheet.TestValues) : null,
ProductionOrderName = testSheet.FaNr,
RwType = testSheet.TestValues != null?ToRwTypeAll(testSheet.TestValues.ToList()) : RwType.Ok,
Action = "Edit",
Controller = testSheet.ArticleType == ArticleType.BabyDiaper ? "LaborCreatorBaby" : "LaborCreatorInko"
};
public static TestSheet load(string path)
{
String[] t = System.IO.File.ReadAllLines(path);
TestSheet sheet = new TestSheet();
for (int i = 5; i < t.Length; i += 7)
{
sheet.add(
new Test(t[i - 5], new String[] { t[i - 4], t[i - 3], t[i - 2], t[i - 1], }, Int32.Parse(t[i]))
);
}
return(sheet);
}
/// <summary>
/// A mock for LaborCreatorBll
/// </summary>
/// <param name="testSheet">the testsheet</param>
/// <returns>a moq for laborcreatorbll</returns>
public static IBabyDiaperLaborCreatorBll GetBabyDiaperLaborCreatorBll(TestSheet testSheet)
{
var mock = new Mock <IBabyDiaperLaborCreatorBll>
{
Name = "MockHelper.IBabyDiaperLaborCreatorBll",
DefaultValue = DefaultValue.Mock
};
mock.Setup(x => x.GetTestSheetForId(It.IsAny <Int32>()))
.Returns(testSheet);
return(mock.Object);
}
public void CreateProductionCodeTest2()
{
const String expectedResult = "IT/10/17/";
var testSheet = new TestSheet
{
MachineNr = "M10",
CreatedDateTime = new DateTime(2017, 1, 7)
};
var testServiceHelper = new TestServiceHelper(new NLogLoggerFactory());
var actual = testServiceHelper.CreateProductionCode(testSheet);
Assert.Equal(expectedResult, actual);
}
private static RwType GetRwTypeInko(TestSheet testSheet)
{
var result = RwType.Ok;
foreach (var inko in testSheet.TestValues.Where(testValue => testValue.TestValueType == TestValueType.Average)
.Select(testValue => testValue.IncontinencePadTestValue))
{
switch (inko.TestType)
{
case TestTypeIncontinencePad.RewetFree:
if (inko.RewetFreeRw == RwType.Worse)
{
return(RwType.Worse);
}
if (inko.RewetFreeRw == RwType.SomethingWorse)
{
result = RwType.SomethingWorse;
}
break;
case TestTypeIncontinencePad.Retention:
if (inko.RetentionRw == RwType.Worse)
{
return(RwType.Worse);
}
if (inko.RetentionRw == RwType.SomethingWorse)
{
result = RwType.SomethingWorse;
}
break;
case TestTypeIncontinencePad.AcquisitionTimeAndRewet:
if ((inko.RewetAfterAcquisitionTimeRw == RwType.Worse) || (inko.AcquisitionTimeFirstRw == RwType.Worse) ||
(inko.AcquisitionTimeSecondRw == RwType.Worse) || (inko.AcquisitionTimeThirdRw == RwType.Worse))
{
return(RwType.Worse);
}
if ((inko.RewetAfterAcquisitionTimeRw == RwType.SomethingWorse) || (inko.AcquisitionTimeFirstRw == RwType.SomethingWorse) ||
(inko.AcquisitionTimeSecondRw == RwType.SomethingWorse) || (inko.AcquisitionTimeThirdRw == RwType.SomethingWorse))
{
result = RwType.SomethingWorse;
}
break;
}
}
return(result);
}
public void GetTestSheetForFaNrTestNormal()
{
var now = DateTime.Now;
var testsheet = new TestSheet
{
FaNr = "666",
ShiftType = ShiftType.Late,
DayInYear = now.DayOfYear,
CreatedDateTime = now
};
var shift = new ShiftSchedule
{
Name = "The One",
ShiftType = ShiftType.Late,
EndTime = new TimeSpan(now.Hour + 2, now.Minute, now.Second),
StartTime = new TimeSpan(now.Hour - 2, now.Minute, now.Second),
StartDay = now.DayOfWeek,
EndDay = now.AddDays(1)
.DayOfWeek
};
var shiftSheduleListQuery = new List <ShiftSchedule>
{
shift
};
var shiftSheduleRepository = MockHelperBll.GetAllShiftSchedules(shiftSheduleListQuery.AsQueryable());
var testSheetList = new List <TestSheet>
{
testsheet
};
var testSheetRepository = MockHelperBll.TestSheetRepository(testSheetList.AsQueryable());
var shifthelper = MockHelperBll.GetShiftHelper(ShiftType.Late);
var target = new LaborCreatorBll(new NLogLoggerFactory())
{
ProductionOrderRepository = null,
ShiftHelper = shifthelper,
TestSheetRepository = testSheetRepository
};
var actual = target.GetTestSheetForFaNr("666")
.Should()
.Be(testsheet);
}
private static RwType GetRwTypeBaby(TestSheet testSheet)
{
var result = RwType.Ok;
foreach (var babyDiaper in testSheet.TestValues.Where(testValue => testValue.TestValueType == TestValueType.Average)
.Select(testValue => testValue.BabyDiaperTestValue))
{
switch (babyDiaper.TestType)
{
case TestTypeBabyDiaper.Retention:
if (babyDiaper.RetentionRw == RwType.Worse)
{
return(RwType.Worse);
}
if (babyDiaper.RetentionRw == RwType.SomethingWorse)
{
result = RwType.SomethingWorse;
}
break;
case TestTypeBabyDiaper.Rewet:
if ((babyDiaper.Rewet140Rw == RwType.Worse) || (babyDiaper.Rewet210Rw == RwType.Worse))
{
return(RwType.Worse);
}
if ((babyDiaper.Rewet140Rw == RwType.SomethingWorse) || (babyDiaper.Rewet210Rw == RwType.SomethingWorse))
{
result = RwType.SomethingWorse;
}
break;
case TestTypeBabyDiaper.RewetAndPenetrationTime:
if ((babyDiaper.Rewet140Rw == RwType.Worse) || (babyDiaper.Rewet210Rw == RwType.Worse) || (babyDiaper.PenetrationRwType == RwType.Worse))
{
return(RwType.Worse);
}
if ((babyDiaper.Rewet140Rw == RwType.SomethingWorse) || (babyDiaper.Rewet210Rw == RwType.SomethingWorse) ||
(babyDiaper.PenetrationRwType == RwType.SomethingWorse))
{
result = RwType.SomethingWorse;
}
break;
}
}
return(result);
}
public void loadData()
{
if (sheet != null)
{
return;
}
if (System.IO.File.Exists(VOCAB_TXT))
{
sheet = TestSheet.load(VOCAB_TXT);
}
else
{
return;
}
string d = null;
if (System.IO.File.Exists(VOCAB_SF_TXT))
{
d = System.IO.File.ReadAllText(VOCAB_SF_TXT);
}
F = new int[sheet.size()];
sF = 0;
point = 0;
if (d == null)
{
point = 0;
for (int i = 0; i < F.Length; ++i)
{
sF += 10;
F[i] = 10;
}
}
else
{
String[] t = d.Split(new char[] { ' ' });
point = Int32.Parse(t[0]);
for (int i = 0; i < F.Length; ++i)
{
F[i] = Int32.Parse(t[i + 1]);
sF += F[i];
}
}
nextQuestion();
}
/// <summary>
/// A mock for LaborCreatorBll
/// </summary>
/// <param name="testSheet">the testsheet</param>
/// <param name="runningTestSheets">the running testsheets</param>
/// <returns>a moq for laborcreatorbll</returns>
public static ILaborCreatorBll GetLaborCreatorsBll(TestSheet testSheet, ICollection <TestSheet> runningTestSheets)
{
var mock = new Mock <ILaborCreatorBll>
{
Name = "MockHelper.ILaborCreatorBll",
DefaultValue = DefaultValue.Mock
};
mock.Setup(x => x.GetTestSheetForFaNr(It.IsAny <String>()))
.Returns(testSheet);
mock.Setup(x => x.InitTestSheetForFaNr(It.IsAny <String>()))
.Returns(testSheet);
mock.Setup(x => x.RunningTestSheets())
.Returns(runningTestSheets);
return(mock.Object);
}
private void UpdateInkoRetentionAvg(TestSheet testSheet, TestValue retentionTestAvg)
{
var productionOrder = TestBll.GetProductionOrder(testSheet.FaNr);
var tempInko = new IncontinencePadTestValue {
RetentionRw = RwType.Ok
};
var counter = 0;
foreach (
var testValue in
testSheet.TestValues.Where(
testValue =>
(testValue.TestValueType == TestValueType.Single) &&
(testValue.IncontinencePadTestValue.TestType == TestTypeIncontinencePad.Retention))
)
{
tempInko.RetentionWeight += testValue.IncontinencePadTestValue.RetentionWeight;
tempInko.RetentionWetValue += testValue.IncontinencePadTestValue.RetentionWetValue;
tempInko.RetentionAfterZentrifuge += testValue.IncontinencePadTestValue.RetentionAfterZentrifuge;
tempInko.RetentionAbsorbtion += testValue.IncontinencePadTestValue.RetentionAbsorbtion;
tempInko.RetentionEndValue += testValue.IncontinencePadTestValue.RetentionEndValue;
if (testValue.IncontinencePadTestValue.RetentionRw == RwType.Worse)
{
tempInko.RetentionRw = RwType.SomethingWorse;
}
counter++;
}
if (counter == 0)
{
counter = 1;
}
retentionTestAvg.IncontinencePadTestValue.RetentionWeight = tempInko.RetentionWeight / counter;
retentionTestAvg.IncontinencePadTestValue.RetentionWetValue = tempInko.RetentionWetValue / counter;
retentionTestAvg.IncontinencePadTestValue.RetentionAfterZentrifuge = tempInko.RetentionAfterZentrifuge / counter;
retentionTestAvg.IncontinencePadTestValue.RetentionAbsorbtion = tempInko.RetentionAbsorbtion / counter;
retentionTestAvg.IncontinencePadTestValue.RetentionEndValue = tempInko.RetentionEndValue / counter;
if ((GetRetentionRwType(retentionTestAvg.IncontinencePadTestValue.RetentionEndValue, productionOrder) == RwType.Worse) && (tempInko.RetentionRw != RwType.Ok))
{
tempInko.RetentionRw = RwType.Worse;
}
retentionTestAvg.IncontinencePadTestValue.RetentionRw = tempInko.RetentionRw;
}
private static void UpdateInkoRetentionStDev(TestSheet testSheet, TestValue retentionTestAvg, TestValue retentionTestStDev)
{
var tempInko = new IncontinencePadTestValue();
var counter = 0;
foreach (
var testValue in
testSheet.TestValues.Where(
testValue =>
(testValue.TestValueType == TestValueType.Single) &&
(testValue.IncontinencePadTestValue.TestType == TestTypeIncontinencePad.Retention))
)
{
tempInko.RetentionWeight += Math.Pow(testValue.IncontinencePadTestValue.RetentionWeight - retentionTestAvg.IncontinencePadTestValue.RetentionWeight, 2);
tempInko.RetentionWetValue += Math.Pow(testValue.IncontinencePadTestValue.RetentionWetValue - retentionTestAvg.IncontinencePadTestValue.RetentionWetValue, 2);
tempInko.RetentionAfterZentrifuge +=
Math.Pow(testValue.IncontinencePadTestValue.RetentionAfterZentrifuge - retentionTestAvg.IncontinencePadTestValue.RetentionAfterZentrifuge, 2);
tempInko.RetentionAbsorbtion += Math.Pow(testValue.IncontinencePadTestValue.RetentionAbsorbtion - retentionTestAvg.IncontinencePadTestValue.RetentionAbsorbtion, 2);
tempInko.RetentionEndValue += Math.Pow(testValue.IncontinencePadTestValue.RetentionEndValue - retentionTestAvg.IncontinencePadTestValue.RetentionEndValue, 2);
counter++;
}
if (counter < 2)
{
retentionTestStDev.IncontinencePadTestValue.RetentionWeight = 0;
retentionTestStDev.IncontinencePadTestValue.RetentionWetValue = 0;
retentionTestStDev.IncontinencePadTestValue.RetentionAfterZentrifuge = 0;
retentionTestStDev.IncontinencePadTestValue.RetentionAbsorbtion = 0;
retentionTestStDev.IncontinencePadTestValue.RetentionEndValue = 0;
}
else
{
counter--;
retentionTestStDev.IncontinencePadTestValue.RetentionWeight = Math.Sqrt(tempInko.RetentionWeight / counter);
retentionTestStDev.IncontinencePadTestValue.RetentionWetValue = Math.Sqrt(tempInko.RetentionWetValue / counter);
retentionTestStDev.IncontinencePadTestValue.RetentionAfterZentrifuge = Math.Sqrt(tempInko.RetentionAfterZentrifuge / counter);
retentionTestStDev.IncontinencePadTestValue.RetentionAbsorbtion = Math.Sqrt(tempInko.RetentionAbsorbtion / counter);
retentionTestStDev.IncontinencePadTestValue.RetentionEndValue = Math.Sqrt(tempInko.RetentionEndValue / counter);
}
#endregion
}
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;
}
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 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 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);
}
}
/// <summary>
/// A mock for BabyDiaperRetentionBll
/// </summary>
/// <param name="testSheet">testSheet data which would be in the db</param>
/// <returns>a IBabyDiaperRetentionBll moq</returns>
public static ITestBll GetTestBll(TestSheet testSheet)
{
var mock = new Mock <ITestBll>
{
Name = "MockHelper.GetTestBll",
DefaultValue = DefaultValue.Mock
};
var noteCodes = new List <Error>
{
new Error {
ErrorId = 1, ErrorCode = "404", Value = "Error Not Found"
},
new Error {
ErrorId = 2, ErrorCode = "500", Value = "Error not authorized"
}
};
mock.Setup(x => x.GetAllNoteCodes())
.Returns(noteCodes);
mock.Setup(x => x.GetTestSheetInfo(testSheet.TestSheetId))
.Returns(testSheet);
mock.Setup(x => x.GetTestSheetInfo(It.IsNotIn(testSheet.TestSheetId)))
.Returns((TestSheet)null);
if (testSheet.TestValues.IsNullOrEmpty())
{
testSheet.TestValues = new List <TestValue>();
}
var testValuesId = testSheet.TestValues.Select(tv => tv.TestValueId)
.ToArray();
mock.Setup(x => x.GetTestValue(It.IsIn(testValuesId)))
.Returns(( Int32 testValueId ) => testSheet.TestValues.FirstOrDefault(tv => tv.TestValueId == testValueId));
mock.Setup(x => x.GetTestValue(It.IsNotIn(testValuesId)))
.Returns((TestValue)null);
return(mock.Object);
}
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);
}
}
private void UpdateInkoRewetAvg(TestSheet testSheet, TestValue rewetTestAvg)
{
var productionOrder = TestBll.GetProductionOrder(testSheet.FaNr);
var tempInko = new IncontinencePadTestValue {
RewetFreeRw = RwType.Ok
};
var counter = 0;
foreach (
var testValue in
testSheet.TestValues.Where(
testValue =>
(testValue.TestValueType == TestValueType.Single) &&
(testValue.IncontinencePadTestValue.TestType == TestTypeIncontinencePad.RewetFree))
)
{
tempInko.RewetFreeDryValue += testValue.IncontinencePadTestValue.RewetFreeDryValue;
tempInko.RewetFreeWetValue += testValue.IncontinencePadTestValue.RewetFreeWetValue;
tempInko.RewetFreeDifference += testValue.IncontinencePadTestValue.RewetFreeDifference;
if (testValue.IncontinencePadTestValue.RewetFreeRw == RwType.Worse)
{
tempInko.RewetFreeRw = RwType.SomethingWorse;
}
counter++;
}
if (counter == 0)
{
counter = 1;
}
rewetTestAvg.IncontinencePadTestValue.RewetFreeDryValue = tempInko.RewetFreeDryValue / counter;
rewetTestAvg.IncontinencePadTestValue.RewetFreeWetValue = tempInko.RewetFreeWetValue / counter;
rewetTestAvg.IncontinencePadTestValue.RewetFreeDifference = tempInko.RewetFreeDifference / counter;
if (GetRewetFreeRwType(rewetTestAvg.IncontinencePadTestValue.RewetFreeDifference, productionOrder) == RwType.Worse)
{
tempInko.RewetFreeRw = RwType.Worse;
}
rewetTestAvg.IncontinencePadTestValue.RewetFreeRw = tempInko.RewetFreeRw;
}
public void GetIncontinencePadLaborCreatorViewModelTest()
{
var serviceHelperMoq = MockHelperIncontinencePadLaborCreatorServiceHelper.GetLaborCreatorServiceHelper();
const ShiftType shiftType = ShiftType.Late;
const String faNr = "Fa666";
const String productName = "Beast";
const String sizeName = "Huge";
var createdDateTime = new DateTime(2016, 1, 1);
var testSheet = new TestSheet
{
ShiftType = shiftType,
FaNr = faNr,
ProductName = productName,
SizeName = sizeName,
CreatedDateTime = createdDateTime,
TestValues = new List <TestValue>(),
TestSheetId = 1,
ArticleType = ArticleType.IncontinencePad
};
var laborCreatorBllMoq = MockHelperBll.GetIncontinencePadLaborCreatorBll(
testSheet
);
var target = new IncontinencePadLaborCreatorService(new NLogLoggerFactory())
{
Helper = serviceHelperMoq,
IncontinencePadLaborCreatorBll = laborCreatorBllMoq
};
var actual = target.GetLaborCreatorViewModel(1);
actual.TestSheetId.Should()
.Be(1);
actual.Producer.Should()
.Be("Intigena");
actual.Shift.Should()
.Be(shiftType.ToFriendlyString());
actual.FaNr.Should()
.Be(faNr);
actual.ProductName.Should()
.Be(productName);
actual.SizeName.Should()
.Be(sizeName);
actual.CreatedDate.Should()
.Be("01.01.2016");
actual.Rewets.Should()
.NotBeNull("because it is initialized");
actual.RewetAverage.Should()
.NotBeNull("because it is initialized");
actual.RewetStandardDeviation.Should()
.NotBeNull("because it is initialized");
actual.RewetAfterAcquisitionTimeAverage.Should()
.NotBeNull("because it is initialized");
actual.RewetAfterAcquisitionTimeStandardDeviation.Should()
.NotBeNull("because it is initialized");
actual.Retentions.Should()
.NotBeNull("because it is initialized");
actual.RewetAverage.Should()
.NotBeNull("because it is initialized");
actual.RetentionStandardDeviation.Should()
.NotBeNull("because it is initialized");
actual.AcquisitionTimes.Should()
.NotBeNull("because it is initialized");
actual.AcquisitionTimeAverage.Should()
.NotBeNull("because it is initialized");
actual.AcquisitionTimeAverage.Should()
.NotBeNull("because it is initialized");
}