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); }