protected override void SetupNewDatabase(DbContextOptions <PreservationContext> dbContextOptions)
{
using (var context = new PreservationContext(dbContextOptions, _plantProvider, _eventDispatcher, _currentUserProvider))
{
_tfWithRequirement = AddTagFunction(context, "TFC2", "RC1");
var rt = AddRequirementTypeWith1DefWithoutField(context, "ROT", "R", RequirementTypeIcon.Other);
_requirementDefinition = rt.RequirementDefinitions.First();
_tfWithRequirement.AddRequirement(new TagFunctionRequirement(TestPlant, 4, _requirementDefinition));
_tfWithoutRequirement = AddTagFunction(context, "TFC1", "RC1");
context.SaveChangesAsync().Wait();
}
}
public static void AddRequirementTypes(this IRequirementTypeRepository requirementTypeRepository, int entryCount, string plant)
{
for (var i = 0; i < entryCount; i++)
{
var requirementType = new RequirementType(plant, "Code", "Title", RequirementTypeIcon.Other, i);
for (var j = 0; j < 5; j++)
{
var requirementDefinition = new RequirementDefinition(plant, $"RequirementDefinition-{j}", 2, RequirementUsage.ForAll, j);
requirementType.AddRequirementDefinition(requirementDefinition);
}
requirementTypeRepository.Add(requirementType);
}
}
protected RequirementType AddRequirementTypeWith1DefWithoutField(PreservationContext context, string typeCode, string defTitle, RequirementTypeIcon icon, int sortKey = 0)
{
var requirementType = new RequirementType(TestPlant, typeCode, $"Title{typeCode}", icon, sortKey);
context.RequirementTypes.Add(requirementType);
context.SaveChangesAsync().Wait();
var requirementDefinition = new RequirementDefinition(TestPlant, defTitle, 2, RequirementUsage.ForAll, 1);
requirementType.AddRequirementDefinition(requirementDefinition);
context.SaveChangesAsync().Wait();
return(requirementType);
}
public void AddRequirementDefinition(RequirementDefinition requirementDefinition)
{
if (requirementDefinition == null)
{
throw new ArgumentNullException(nameof(requirementDefinition));
}
if (requirementDefinition.Plant != Plant)
{
throw new ArgumentException($"Can't relate item in {requirementDefinition.Plant} to item in {Plant}");
}
_requirementDefinitions.Add(requirementDefinition);
}
protected override void SetupNewDatabase(DbContextOptions <PreservationContext> dbContextOptions)
{
using (var context = new PreservationContext(dbContextOptions, _plantProvider, _eventDispatcher,
_currentUserProvider))
{
var journey = AddJourneyWithStep(context, "J1", "S", AddMode(context, "M1", false), AddResponsible(context, "R1"));
_requirementType = AddRequirementTypeWith1DefWithoutField(context, "RT", "RD", RequirementTypeIcon.Other, 1);
_requirementDefinitionWithoutOneField =
_requirementType.RequirementDefinitions.Single();
_infoField = AddInfoField(context, _requirementDefinitionWithoutOneField, "I");
// be sure to use different intervals in the TagRequirement and RequirementDefinition to be able to Assert on correct value for dto.IntervalWeeks
_interval = _requirementDefinitionWithoutOneField.DefaultIntervalWeeks * 2;
var requirementWithoutField = new TagRequirement(TestPlant, _interval, _requirementDefinitionWithoutOneField);
var tag = new Tag(TestPlant,
TagType.Standard,
"TagNo",
"Description",
journey.Steps.ElementAt(0),
new List <TagRequirement>
{
requirementWithoutField
});
context.Tags.Add(tag);
Assert.IsNull(requirementWithoutField.ActivePeriod);
// All TagRequirements get an active Period when starting
tag.StartPreservation();
Assert.IsNotNull(requirementWithoutField.ActivePeriod);
context.SaveChangesAsync().Wait();
_tagId = tag.Id;
_requirementWithoutFieldId = requirementWithoutField.Id;
var activePeriodForRequirementWithOutField =
tag.Requirements.Single(r => r.Id == requirementWithoutField.Id).ActivePeriod;
Assert.IsNull(activePeriodForRequirementWithOutField.PreservationRecord);
requirementWithoutField.SetComment(_comment);
// Active Period gets a Preservation Record and the current Active Period be a new active Period when preserving
tag.Preserve(new Mock <Person>().Object, _requirementWithoutFieldId);
Assert.IsNotNull(activePeriodForRequirementWithOutField.PreservationRecord);
context.SaveChangesAsync().Wait();
_preservationRecordGuid = activePeriodForRequirementWithOutField.PreservationRecord.ObjectGuid;
_preservationRecordId = activePeriodForRequirementWithOutField.PreservationRecord.Id;
}
}
public TagFunctionRequirement(string plant, int intervalWeeks, RequirementDefinition requirementDefinition)
: base(plant)
{
if (requirementDefinition == null)
{
throw new ArgumentNullException(nameof(requirementDefinition));
}
if (requirementDefinition.Plant != plant)
{
throw new ArgumentException($"Can't relate item in {requirementDefinition.Plant} to item in {plant}");
}
IntervalWeeks = intervalWeeks;
RequirementDefinitionId = requirementDefinition.Id;
}
protected override void SetupNewDatabase(DbContextOptions <PreservationContext> dbContextOptions)
{
using (var context = new PreservationContext(dbContextOptions, _plantProvider, _eventDispatcher, _currentUserProvider))
{
_requirementType = AddRequirementTypeWith1DefWithoutField(context, "R", "D1", RequirementTypeIcon.Other);
_reqDefForAll = _reqDefWithoutField = _requirementType.RequirementDefinitions.First();
_reqDefForSupplier = new RequirementDefinition(TestPlant, "D2", 2, RequirementUsage.ForSuppliersOnly, 1);
_requirementType.AddRequirementDefinition(_reqDefForSupplier);
_reqDefForOther = _reqDefWithTwoFields = new RequirementDefinition(TestPlant, "D3", 2, RequirementUsage.ForOtherThanSuppliers, 1);
_requirementType.AddRequirementDefinition(_reqDefForOther);
_numberFieldId = AddNumberField(context, _reqDefForOther, "N", "mm", true).Id;
_cbFieldId = AddCheckBoxField(context, _reqDefForOther, "CB").Id;
context.SaveChangesAsync().Wait();
}
}
private void CloneFields(RequirementDefinition sourceRD, RequirementDefinition targetRD)
{
foreach (var sourceField in sourceRD.Fields)
{
if (targetRD.Fields.SingleOrDefault(t => t.Label == sourceField.Label) == null)
{
var targetField = new Field(
targetRD.Plant,
sourceField.Label,
sourceField.FieldType,
sourceField.SortKey,
sourceField.Unit,
sourceField.ShowPrevious);
targetRD.AddField(targetField);
}
}
}
private void VerifyReadyForRecording(RequirementDefinition requirementDefinition)
{
if (requirementDefinition == null)
{
throw new ArgumentNullException(nameof(requirementDefinition));
}
if (requirementDefinition.Id != RequirementDefinitionId)
{
throw new Exception(
$"{nameof(TagRequirement)} {Id} belong to RequirementDefinition {RequirementDefinitionId}. Can't record values for RequirementDefinition {requirementDefinition.Id}");
}
if (!HasActivePeriod)
{
throw new Exception($"{nameof(TagRequirement)} {Id} don't have an active {nameof(PreservationPeriod)}. Can't record values");
}
}
public void RemoveRequirementDefinition(RequirementDefinition requirementDefinition)
{
if (requirementDefinition == null)
{
throw new ArgumentNullException(nameof(requirementDefinition));
}
if (!requirementDefinition.IsVoided)
{
throw new Exception($"{nameof(requirementDefinition)} must be voided before delete");
}
if (requirementDefinition.Plant != Plant)
{
throw new ArgumentException($"Can't remove item in {requirementDefinition.Plant} from item in {Plant}");
}
_requirementDefinitions.Remove(requirementDefinition);
}
private void CloneRequirementDefinitions(RequirementType sourceRT, RequirementType targetRT)
{
foreach (var sourceRD in sourceRT.RequirementDefinitions)
{
var targetRD = targetRT.RequirementDefinitions.SingleOrDefault(t => t.Title == sourceRD.Title);
if (targetRD == null)
{
targetRD = new RequirementDefinition(
targetRT.Plant,
sourceRD.Title,
sourceRD.DefaultIntervalWeeks,
sourceRD.Usage,
sourceRD.SortKey);
targetRT.AddRequirementDefinition(targetRD);
}
CloneFields(sourceRD, targetRD);
}
}
public void RecordCheckBoxValues(Dictionary <int, bool> checkBoxValues, RequirementDefinition requirementDefinition)
{
if (checkBoxValues == null)
{
throw new ArgumentNullException(nameof(checkBoxValues));
}
VerifyReadyForRecording(requirementDefinition);
var period = ActivePeriod;
foreach (var checkBoxValue in checkBoxValues)
{
var field = requirementDefinition.Fields.Single(f => f.Id == checkBoxValue.Key);
period.RecordCheckBoxValueForField(field, checkBoxValue.Value);
}
period.UpdateStatus(requirementDefinition);
}
public void Setup()
{
// Arrange
_requirementDefinition = new RequirementDefinition(_plant, "Rotate 2 turns", 2, RequirementUsage.ForAll, 1);
_historyRepositoryMock = new Mock <IHistoryRepository>();
_historyRepositoryMock
.Setup(repo => repo.Add(It.IsAny <History>()))
.Callback <History>(history =>
{
_historyAdded = history;
});
_requirementTypeRepositoryMock = new Mock <IRequirementTypeRepository>();
_requirementTypeRepositoryMock
.Setup(repo => repo.GetRequirementDefinitionByIdAsync(_requirementDefinitionId))
.Returns(Task.FromResult(_requirementDefinition));
_dut = new TagRequirementUnvoidedEventHandler(_historyRepositoryMock.Object, _requirementTypeRepositoryMock.Object);
}
public void RecordNumberIsNaValues(IList <int> fieldIds, RequirementDefinition requirementDefinition)
{
if (fieldIds == null)
{
throw new ArgumentNullException(nameof(fieldIds));
}
VerifyReadyForRecording(requirementDefinition);
var period = ActivePeriod;
foreach (var fieldId in fieldIds)
{
var field = requirementDefinition.Fields.Single(f => f.Id == fieldId);
period.RecordNumberIsNaValueForField(field);
}
period.UpdateStatus(requirementDefinition);
}
public TagRequirement(string plant, int intervalWeeks, RequirementDefinition requirementDefinition)
: base(plant)
{
if (requirementDefinition == null)
{
throw new ArgumentNullException(nameof(requirementDefinition));
}
if (requirementDefinition.Plant != plant)
{
throw new ArgumentException($"Can't relate item in {requirementDefinition.Plant} to item in {plant}");
}
IntervalWeeks = intervalWeeks;
Usage = requirementDefinition.Usage;
RequirementDefinitionId = requirementDefinition.Id;
_initialPreservationPeriodStatus = requirementDefinition.NeedsUserInput
? PreservationPeriodStatus.NeedsUserInput
: PreservationPeriodStatus.ReadyToBePreserved;
}
private static Tag SeedSiteTag(PreservationContext dbContext, Project project, Step step,
RequirementDefinition requirementDef)
{
var suffix = Guid.NewGuid().ToString().Substring(3, 8);
var tagNo = $"{KnownTestData.SiteTagNo}-{suffix}";
var tag = new Tag(
project.Plant,
TagType.SiteArea,
tagNo,
$"{tagNo} - Description",
step,
new List <TagRequirement>
{
new TagRequirement(project.Plant, 4, requirementDef)
});
FillTag(tag, suffix);
project.AddTag(tag);
dbContext.SaveChangesAsync().Wait();
return(tag);
}
public void Setup()
{
// Arrange
var reqTypeRepositoryMock = new Mock <IRequirementTypeRepository>();
var requirementTypeId = 1;
var requirementDefinitionId = 2;
var requirementType = new RequirementType(TestPlant, "TestCode", "ReqTypeTitle", _reqIconOther, 99);
requirementType.SetProtectedIdForTesting(requirementTypeId);
_requirementDefinition = new RequirementDefinition(TestPlant, "ReqDefinitionTitle", 4, RequirementUsage.ForAll, 88);
_requirementDefinition.SetProtectedIdForTesting(requirementDefinitionId);
requirementType.AddRequirementDefinition(_requirementDefinition);
reqTypeRepositoryMock.Setup(m => m.GetByIdAsync(requirementTypeId))
.Returns(Task.FromResult(requirementType));
_command = new VoidRequirementDefinitionCommand(requirementTypeId, requirementDefinitionId, _rowVersion);
_dut = new VoidRequirementDefinitionCommandHandler(
reqTypeRepositoryMock.Object,
UnitOfWorkMock.Object);
}
protected override void SetupNewDatabase(DbContextOptions <PreservationContext> dbContextOptions)
{
using (var context = new PreservationContext(dbContextOptions, _plantProvider, _eventDispatcher, _currentUserProvider))
{
var reqType1 = AddRequirementTypeWith1DefWithoutField(context, _reqTypeCode1, _reqDefTitle1_1, RequirementTypeIcon.Other);
_reqTypeId1 = reqType1.Id;
_reqTypeTitle1 = reqType1.Title;
var reqDef1_1 = reqType1.RequirementDefinitions.Single();
_reqDefId1_1 = reqDef1_1.Id;
_infoFieldId1_1 = AddInfoField(context, reqDef1_1, "I").Id;
var reqDef1_2 = new RequirementDefinition(TestPlant, _reqDefTitle1_2, 2, RequirementUsage.ForAll, 1);
reqType1.AddRequirementDefinition(reqDef1_2);
context.SaveChangesAsync().Wait();
_reqDefId1_2 = reqDef1_2.Id;
_infoFieldId1_2 = AddInfoField(context, reqDef1_2, "I").Id;
var reqType2 = AddRequirementTypeWith1DefWithoutField(context, _reqTypeCode2, _reqDefTitle2, RequirementTypeIcon.Other);
_reqTypeId2 = reqType2.Id;
_reqTypeTitle2 = reqType2.Title;
}
}
public void UpdateStatus(RequirementDefinition requirementDefinition)
{
if (requirementDefinition == null)
{
throw new ArgumentNullException(nameof(requirementDefinition));
}
if (Status != PreservationPeriodStatus.ReadyToBePreserved && Status != PreservationPeriodStatus.NeedsUserInput)
{
throw new Exception($"{Status} is an illegal status for {nameof(PreservationPeriod)} when updating status");
}
var fieldNeedUserInputIds = requirementDefinition.Fields.Where(f => f.NeedsUserInput).Select(f => f.Id);
var recordedIds = _fieldValues.Select(fv => fv.FieldId);
if (fieldNeedUserInputIds.All(id => recordedIds.Contains(id)))
{
var numberFieldIds = requirementDefinition
.Fields
.Where(f => f.FieldType == FieldType.Number)
.Select(f => f.Id)
.ToList();
if (!numberFieldIds.Any())
{
Status = PreservationPeriodStatus.ReadyToBePreserved;
return;
}
var numberValues = _fieldValues
.Where(fv => numberFieldIds.Contains(fv.FieldId))
.Select(fv => (NumberValue)fv);
Status = numberValues.Any(nv => nv.Value.HasValue) ? PreservationPeriodStatus.ReadyToBePreserved : PreservationPeriodStatus.NeedsUserInput;
}
else
{
Status = PreservationPeriodStatus.NeedsUserInput;
}
}
public void RemoveRequirementDefinition(RequirementDefinition requirementDefinition) => _context.RequirementDefinitions.Remove(requirementDefinition);
public void Setup() => _dut = new RequirementDefinition(TestPlant, "TitleA", 4, RequirementUsage.ForAll, 10);
public void RemoveRequirementDefinition(RequirementDefinition requirementDefinition) => throw new NotImplementedException();
public void Setup()
{
var supplierMode = new Mode(TestPlant, "SUP", true);
supplierMode.SetProtectedIdForTesting(SupplierModeId);
var otherMode = new Mode(TestPlant, "HOOKUP", false);
otherMode.SetProtectedIdForTesting(OtherModeId);
var responsible = new Responsible(TestPlant, "C", "D");
var supplierStep = new Step(TestPlant, "SUP", supplierMode, responsible);
supplierStep.SetProtectedIdForTesting(SupplierStepId);
var otherStep = new Step(TestPlant, "HOOKUP", otherMode, responsible);
otherStep.SetProtectedIdForTesting(OtherStepId);
var rdForAllTwoWeekInterval = new RequirementDefinition(TestPlant, "ForAll", TwoWeeksInterval, RequirementUsage.ForAll, 1);
var rdForSupplierTwoWeekInterval = new RequirementDefinition(TestPlant, "ForSup", TwoWeeksInterval, RequirementUsage.ForSuppliersOnly, 2);
var rdForOtherTwoWeekInterval = new RequirementDefinition(TestPlant, "ForOther", TwoWeeksInterval, RequirementUsage.ForOtherThanSuppliers, 3);
_req1ForAllWithTwoWeekInterval = new TagRequirement(TestPlant, TwoWeeksInterval, rdForAllTwoWeekInterval);
_req2ForAllWithTwoWeekInterval = new TagRequirement(TestPlant, TwoWeeksInterval, rdForAllTwoWeekInterval);
_req3ForAllWithFourWeekInterval = new TagRequirement(TestPlant, FourWeeksInterval, rdForAllTwoWeekInterval);
_tagWithForAllRequirements = new Tag(TestPlant, TagType.Standard, "", "", supplierStep, new List <TagRequirement>
{
_req1ForAllWithTwoWeekInterval,
_req2ForAllWithTwoWeekInterval,
_req3ForAllWithFourWeekInterval
});
_reqForSupplierInSupplierStep = new TagRequirement(TestPlant, TwoWeeksInterval, rdForSupplierTwoWeekInterval);
_reqForOtherInSupplierStep = new TagRequirement(TestPlant, TwoWeeksInterval, rdForOtherTwoWeekInterval);
_tagWithSupplierAndOtherRequirementsInSupplierStep = new Tag(TestPlant, TagType.Standard, "", "", supplierStep, new List <TagRequirement>
{
_reqForSupplierInSupplierStep,
_reqForOtherInSupplierStep
});
_reqForSupplierInOtherStep = new TagRequirement(TestPlant, TwoWeeksInterval, rdForSupplierTwoWeekInterval);
_reqForOtherInOtherStep = new TagRequirement(TestPlant, TwoWeeksInterval, rdForOtherTwoWeekInterval);
_tagWithSupplierAndOtherRequirementsInOtherStep = new Tag(TestPlant, TagType.Standard, "", "", otherStep, new List <TagRequirement>
{
_reqForSupplierInOtherStep,
_reqForOtherInOtherStep
});
_projectRepoMock = new Mock <IProjectRepository>();
_projectRepoMock.Setup(r => r.GetTagByTagIdAsync(TagWithForAllRequirementsId)).Returns(Task.FromResult(_tagWithForAllRequirements));
_projectRepoMock.Setup(r => r.GetTagByTagIdAsync(TagInOtherStepId)).Returns(Task.FromResult(_tagWithSupplierAndOtherRequirementsInOtherStep));
_projectRepoMock.Setup(r => r.GetTagByTagIdAsync(TagInSupplierStepId)).Returns(Task.FromResult(_tagWithSupplierAndOtherRequirementsInSupplierStep));
_personRepoMock = new Mock <IPersonRepository>();
_personRepoMock
.Setup(p => p.GetByOidAsync(It.Is <Guid>(x => x == CurrentUserOid)))
.Returns(Task.FromResult(new Person(CurrentUserOid, "Test", "User")));
_commandForTagWithForAllRequirements = new PreserveCommand(TagWithForAllRequirementsId);
_commandForTagInOtherStep = new PreserveCommand(TagInOtherStepId);
_commandForTagInSupplierStep = new PreserveCommand(TagInSupplierStepId);
_tagWithForAllRequirements.StartPreservation();
_tagWithSupplierAndOtherRequirementsInOtherStep.StartPreservation();
_tagWithSupplierAndOtherRequirementsInSupplierStep.StartPreservation();
_dut = new PreserveCommandHandler(
_projectRepoMock.Object,
_personRepoMock.Object,
UnitOfWorkMock.Object,
CurrentUserProviderMock.Object);
}
private static void RecordNumberValues(List <NumberFieldValue> values, TagRequirement requirement, RequirementDefinition requirementDefinition)
{
var numberValues =
values.Where(nv => !nv.IsNa).ToDictionary(
keySelector => keySelector.FieldId,
elementSelector => elementSelector.Value);
requirement.RecordNumberValues(numberValues, requirementDefinition);
}
public void Setup()
{
// Arrange
var requirementTypeId = 1;
var requirementDefinitionId = 2;
_fieldId = 3;
var requirementTypeRepositoryMock = new Mock <IRequirementTypeRepository>();
_requirementType = new RequirementType(TestPlant, "Req type code", "Req type title", RequirementTypeIcon.Other, 10);
_requirementType.SetProtectedIdForTesting(requirementTypeId);
_requirementDefinition = new RequirementDefinition(TestPlant, _oldTitle, _oldDefaultWeeks, _oldUsage, _oldSortKey);
_requirementDefinition.SetProtectedIdForTesting(requirementDefinitionId);
_field = new Field(TestPlant, _oldLabel, _oldFieldType, _oldSortKey, _oldUnit, _oldShowPrevious);
_field.SetProtectedIdForTesting(_fieldId);
_requirementDefinition.AddField(_field);
_requirementType.AddRequirementDefinition(_requirementDefinition);
requirementTypeRepositoryMock.Setup(j => j.GetByIdAsync(requirementTypeId))
.Returns(Task.FromResult(_requirementType));
_updateCommandWithUpdateField = new UpdateRequirementDefinitionCommand(
requirementTypeId,
requirementDefinitionId,
_newSortKey1,
_newUsage,
_newTitle,
_newDefaultWeeks,
_rowVersion,
new List <UpdateFieldsForCommand>
{
new UpdateFieldsForCommand(_fieldId, _newLabel1, FieldType.Number, _newSortKey1, true, _rowVersion, _newUnit1, _newShowPrevious1)
},
new List <FieldsForCommand>()
);
_updateCommandWithDeleteField = new UpdateRequirementDefinitionCommand(
requirementTypeId,
requirementDefinitionId,
_newSortKey1,
_newUsage,
_newTitle,
_newDefaultWeeks,
_rowVersion,
new List <UpdateFieldsForCommand>(),
new List <FieldsForCommand>()
);
_updateCommandWithUpdateAndAddField = new UpdateRequirementDefinitionCommand(
requirementTypeId,
requirementDefinitionId,
_newSortKey1,
_newUsage,
_newTitle,
_newDefaultWeeks,
_rowVersion,
new List <UpdateFieldsForCommand>
{
new UpdateFieldsForCommand(_fieldId, _newLabel1, FieldType.Number, _newSortKey1, true, _rowVersion, _newUnit1, _newShowPrevious1)
},
new List <FieldsForCommand>
{
new FieldsForCommand(_newLabel2, _newFieldType2, _newSortKey2, _newUnit2, _newShowPrevious2)
}
);
_dut = new UpdateRequirementDefinitionCommandHandler(
requirementTypeRepositoryMock.Object,
UnitOfWorkMock.Object,
PlantProviderMock.Object);
}
public void Setup()
{
var reqDefId = 0;
_modeRepository = new ModeRepository(_plantProvider, _sourceModes);
_sourceModes.Add(new Mode(_sourcePlant, "ModeA", false));
_sourceModes.Add(new Mode(_sourcePlant, "ModeB", false));
_requirementTypeRepository = new RequirementTypeRepository(_plantProvider, _sourceRequirementTypes);
var requirementTypeA = new RequirementType(_sourcePlant, "RequirementTypeCodeA", "RequirementTypeTitleA", _requirementIconOther, 1);
var reqDefA1 = new RequirementDefinition(_sourcePlant, "RequirementDefCodeA1", 1, RequirementUsage.ForAll, 2);
reqDefA1.SetProtectedIdForTesting(++reqDefId);
requirementTypeA.AddRequirementDefinition(reqDefA1);
var reqDefA2 = new RequirementDefinition(_sourcePlant, "RequirementDefCodeA2", 3, RequirementUsage.ForAll, 4);
reqDefA2.SetProtectedIdForTesting(++reqDefId);
requirementTypeA.AddRequirementDefinition(reqDefA2);
reqDefA1.AddField(new Field(_sourcePlant, "LabelA", FieldType.Number, 1, "UnitA", true));
var requirementTypeB = new RequirementType(_sourcePlant, "RequirementTypeCodeB", "RequirementTypeTitleB", _requirementIconOther, 2);
_sourceRequirementTypes.Add(requirementTypeA);
_sourceRequirementTypes.Add(requirementTypeB);
_tagFunctionRepository = new TagFunctionRepository(_plantProvider, _sourceTagFunctions);
var tagFunctionA = new TagFunction(_sourcePlant, _tfCodeA, "TagFunctionDescA", _regCodeA);
tagFunctionA.AddRequirement(new TagFunctionRequirement(_sourcePlant, 1, reqDefA1));
tagFunctionA.AddRequirement(new TagFunctionRequirement(_sourcePlant, 2, reqDefA2));
var tagFunctionB = new TagFunction(_sourcePlant, _tfCodeB, "TagFunctionDescB", _regCodeB);
_sourceTagFunctions.Add(tagFunctionA);
_sourceTagFunctions.Add(tagFunctionB);
_tagFunctionApiServiceMock = new Mock <ITagFunctionApiService>();
_tagFunctionApiServiceMock
.Setup(t => t.TryGetTagFunctionAsync(TestPlant, _tfCodeA, _regCodeA))
.Returns(Task.FromResult(new PCSTagFunction
{
Code = _tfCodeA, RegisterCode = _regCodeA
}));
_tagFunctionApiServiceMock
.Setup(t => t.TryGetTagFunctionAsync(TestPlant, _tfCodeB, _regCodeB))
.Returns(Task.FromResult(new PCSTagFunction
{
Code = _tfCodeB, RegisterCode = _regCodeB
}));
_command = new CloneCommand(_sourcePlant, TestPlant);
_dut = new CloneCommandHandler(
_plantProvider,
_plantProvider,
UnitOfWorkMock.Object,
_modeRepository,
_requirementTypeRepository,
_tagFunctionRepository,
_tagFunctionApiServiceMock.Object);
UnitOfWorkMock
.Setup(uiw => uiw.SaveChangesAsync(It.IsAny <CancellationToken>()))
.Callback(() =>
{
// Need this to simulate what EF Core do with Ids upon saving new Items
_requirementTypeRepository.Save();
});
}
private static void RecordNumberIsNaValues(List <NumberFieldValue> values, TagRequirement requirement, RequirementDefinition requirementDefinition)
{
IList <int> fieldIds = values.Where(nv => nv.IsNa).Select(nv => nv.FieldId).ToList();
requirement.RecordNumberIsNaValues(fieldIds, requirementDefinition);
}
private (int, int) CreateTag(
PreservationContext context,
string projectName,
TagType tagType,
int intervalWeeks)
{
var plantId = _plantProvider.Plant;
_mode1 = new Mode(plantId, "M1", false);
_mode2 = new Mode(plantId, "M2", false);
context.Modes.Add(_mode1);
context.Modes.Add(_mode2);
_responsible1 = new Responsible(plantId, "Resp1", "Resp1-Desc");
_responsible2 = new Responsible(plantId, "Resp2", "Resp2-Desc");
context.Responsibles.Add(_responsible1);
context.Responsibles.Add(_responsible2);
context.SaveChangesAsync().Wait();
var journey = new Journey(plantId, "J1");
var step = new Step(plantId, "S1", _mode1, _responsible1);
journey.AddStep(step);
journey.AddStep(new Step(plantId, "S2", _mode2, _responsible2));
context.Journeys.Add(journey);
context.SaveChangesAsync().Wait();
var requirementType = new RequirementType(plantId, "RT", "RT title", RequirementTypeIcon.Other, 1);
context.RequirementTypes.Add(requirementType);
var requirementDefinition = new RequirementDefinition(plantId, "RD", intervalWeeks, RequirementUsage.ForAll, 1);
requirementType.AddRequirementDefinition(requirementDefinition);
context.SaveChangesAsync().Wait();
var project = new Project(plantId, projectName, $"{projectName} Desc");
context.Projects.Add(project);
var tag = new Tag(
plantId,
tagType,
"Tag A",
"Tag desc",
step,
new List <TagRequirement> {
new TagRequirement(plantId, _intervalWeeks1, requirementDefinition)
})
{
Calloff = "C",
CommPkgNo = "Cp",
McPkgNo = "Mp",
PurchaseOrderNo = "PO",
TagFunctionCode = "TF"
};
tag.SetArea("A", "A desc");
tag.SetDiscipline("D", "D desc");
project.AddTag(tag);
context.SaveChangesAsync().Wait();
return(project.Id, tag.Id);
}
protected override void SetupNewDatabase(DbContextOptions <PreservationContext> dbContextOptions)
{
using (var context = new PreservationContext(dbContextOptions, _plantProvider, _eventDispatcher, _currentUserProvider))
{
var journey = AddJourneyWithStep(context, "J1", "S", AddMode(context, "M1", false), AddResponsible(context, "R1"));
var requirementType1 = new RequirementType(TestPlant, _requirementType1Code, _requirementType1Title, _requirementType1Icon, 0);
context.RequirementTypes.Add(requirementType1);
var requirementType2 = new RequirementType(TestPlant, _requirementType2Code, _requirementType2Title, _requirementType2Icon, 0);
context.RequirementTypes.Add(requirementType2);
context.SaveChangesAsync().Wait();
var requirementDefinitionWithoutField = new RequirementDefinition(TestPlant, _requirementDefinitionWithoutFieldTitle, 2, RequirementUsage.ForAll, 1);
requirementType1.AddRequirementDefinition(requirementDefinitionWithoutField);
var requirementDefinitionWithOneInfo = new RequirementDefinition(TestPlant, _requirementDefinitionWithOneInfoTitle, 2, RequirementUsage.ForAll, 1);
var infoField = new Field(TestPlant, "Label for Info", FieldType.Info, 0);
requirementDefinitionWithOneInfo.AddField(infoField);
requirementType1.AddRequirementDefinition(requirementDefinitionWithOneInfo);
var requirementDefinitionWithOneAttachment = new RequirementDefinition(TestPlant, _requirementDefinitionWithOneAttachmentTitle, 2, RequirementUsage.ForAll, 1);
var attachmentField = new Field(TestPlant, "Label for Attachment", FieldType.Attachment, 0);
requirementDefinitionWithOneAttachment.AddField(attachmentField);
requirementType1.AddRequirementDefinition(requirementDefinitionWithOneAttachment);
var requirementDefinitionWithTwoCheckBoxes = new RequirementDefinition(TestPlant, _requirementDefinitionWithTwoCheckBoxesTitle, 2, RequirementUsage.ForAll, 1);
var cbField1 = new Field(TestPlant, "Label for checkBox - second", FieldType.CheckBox, 10);
var cbField2 = new Field(TestPlant, "Label for checkBox - first", FieldType.CheckBox, 2);
requirementDefinitionWithTwoCheckBoxes.AddField(cbField1);
requirementDefinitionWithTwoCheckBoxes.AddField(cbField2);
requirementType2.AddRequirementDefinition(requirementDefinitionWithTwoCheckBoxes);
var requirementDefinitionWithThreeNumberShowPrev = new RequirementDefinition(TestPlant, _requirementDefinitionWithThreeNumberShowPrevTitle, 2, RequirementUsage.ForAll, 1);
var numberFieldPrev1 = new Field(TestPlant, "Label for number - third", FieldType.Number, 15, _unit, true);
var numberFieldPrev2 = new Field(TestPlant, "Label for number - first", FieldType.Number, 2, _unit, true);
var numberFieldPrev3 = new Field(TestPlant, "Label for number - second", FieldType.Number, 10, _unit, true);
requirementDefinitionWithThreeNumberShowPrev.AddField(numberFieldPrev1);
requirementDefinitionWithThreeNumberShowPrev.AddField(numberFieldPrev2);
requirementDefinitionWithThreeNumberShowPrev.AddField(numberFieldPrev3);
requirementType2.AddRequirementDefinition(requirementDefinitionWithThreeNumberShowPrev);
var requirementDefinitionWithOneNumberNoPrev = new RequirementDefinition(TestPlant, _requirementDefinitionWithOneNumberNoPrevTitle, 2, RequirementUsage.ForAll, 1);
var numberFieldNoPrev = new Field(TestPlant, "Label for number", FieldType.Number, 10, _unit, false);
requirementDefinitionWithOneNumberNoPrev.AddField(numberFieldNoPrev);
requirementType2.AddRequirementDefinition(requirementDefinitionWithOneNumberNoPrev);
var requirementDefinitionForVoidedTest = new RequirementDefinition(TestPlant, _requirementDefinitionForVoidedTest, 2, RequirementUsage.ForAll, 1);
var vField1 = new Field(TestPlant, "Label for field", FieldType.CheckBox, 10);
requirementDefinitionForVoidedTest.AddField(vField1);
requirementType2.AddRequirementDefinition(requirementDefinitionForVoidedTest);
context.SaveChangesAsync().Wait();
var requirementWithoutField = new TagRequirement(TestPlant, _interval, requirementDefinitionWithoutField);
var requirementWithOneInfo = new TagRequirement(TestPlant, _interval, requirementDefinitionWithOneInfo);
var requirementWithOneAttachment = new TagRequirement(TestPlant, _interval, requirementDefinitionWithOneAttachment);
var requirementWithTwoCheckBoxes = new TagRequirement(TestPlant, _interval, requirementDefinitionWithTwoCheckBoxes);
var requirementWithOneNumberNoPrev = new TagRequirement(TestPlant, _interval, requirementDefinitionWithOneNumberNoPrev);
var requirementWithThreeNumberShowPrev = new TagRequirement(TestPlant, _interval, requirementDefinitionWithThreeNumberShowPrev);
var requirementThatIsVoided = new TagRequirement(TestPlant, _interval, requirementDefinitionForVoidedTest);
requirementThatIsVoided.IsVoided = true;
var tag = new Tag(TestPlant,
TagType.Standard,
"TagNo",
"Description",
journey.Steps.ElementAt(0),
new List <TagRequirement>
{
requirementWithoutField,
requirementWithOneInfo,
requirementWithOneAttachment,
requirementWithTwoCheckBoxes,
requirementWithOneNumberNoPrev,
requirementWithThreeNumberShowPrev,
requirementThatIsVoided
});
context.Tags.Add(tag);
context.SaveChangesAsync().Wait();
_tagId = tag.Id;
_requirementDefinitionWithOneAttachmentId = requirementDefinitionWithOneAttachment.Id;
_requirementDefinitionWithTwoCheckBoxesId = requirementDefinitionWithTwoCheckBoxes.Id;
_requirementDefinitionWithThreeNumberShowPrevId = requirementDefinitionWithThreeNumberShowPrev.Id;
_requirementWithoutFieldId = requirementWithoutField.Id;
_requirementWithOneInfoId = requirementWithOneInfo.Id;
_requirementWithOneAttachmentId = requirementWithOneAttachment.Id;
_requirementWithTwoCheckBoxesId = requirementWithTwoCheckBoxes.Id;
_requirementWithThreeNumberShowPrevId = requirementWithThreeNumberShowPrev.Id;
_requirementWithOneNumberNoPrevId = requirementWithOneNumberNoPrev.Id;
_attachmentFieldId = attachmentField.Id;
_firstCbFieldId = cbField2.Id;
_secondCbFieldId = cbField1.Id;
_firstNumberFieldId = numberFieldPrev2.Id;
_secondNumberFieldId = numberFieldPrev3.Id;
_thirdNumberFieldId = numberFieldPrev1.Id;
}
}
private static void RecordCheckBoxValues(List <CheckBoxFieldValue> values, TagRequirement requirement, RequirementDefinition requirementDefinition)
{
var checkBoxValues =
values.ToDictionary(keySelector => keySelector.FieldId, elementSelector => elementSelector.IsChecked);
requirement.RecordCheckBoxValues(checkBoxValues, requirementDefinition);
}
