Ejemplo n.º 1
0
        public void ScaffoldTest()
        {
            var chemistry = new ChemistryFileData();

            chemistry.OriginalChemName = "XYZ";

            var esdatModel           = new ESDATModel();
            var sample               = new SampleFileData();
            var mockDb               = new Mock <IDbContext>();
            var mockDbContext        = mockDb.Object;
            var duplicateChecker     = new ODM2DuplicateChecker(mockDbContext);
            var defaultValueProvider = new StaticWQDefaultValueProvider();
            var wayToHandleNewData   = WayToHandleNewData.ThrowExceptionForNewData;
            var results              = new List <IResult>();
            var mapper               = new ChemistryVariableMapper(duplicateChecker, defaultValueProvider, wayToHandleNewData, results);

            var variable = mapper.Draft(esdatModel, chemistry);

            Assert.AreEqual(defaultValueProvider.DefaultVariableTypeCVChemistry, variable.VariableTypeCV);
            Assert.AreEqual(chemistry.ChemCode, variable.VariableCode);

            // This is temporarily hard-coded
            Assert.AreEqual("1,1,1-Trichloroethane", variable.VariableNameCV);

            Assert.AreEqual(chemistry.OriginalChemName, variable.VariableDefinition);
            Assert.AreEqual(defaultValueProvider.DefaultVariableSpeciationCV, variable.SpeciationCV);
            Assert.AreEqual(defaultValueProvider.DefaultVariableNoDataValue, variable.NoDataValue);
        }
Ejemplo n.º 2
0
        public void ScaffoldTest()
        {
            var esdatModel = new ESDATModel();

            var mockDb               = new Mock <IDbContext>();
            var mockDbContext        = mockDb.Object;
            var duplicateChecker     = new ODM2DuplicateChecker(mockDbContext);
            var defaultValueProvider = new StaticWQDefaultValueProvider();
            var wayToHandleNewData   = WayToHandleNewData.ThrowExceptionForNewData;
            var results              = new List <IResult>();
            var mapper               = new RelatedActionMapper(duplicateChecker, defaultValueProvider, wayToHandleNewData, results);

            var action1 = new Core.Action();

            action1.ActionID = 101;

            var action2 = new Core.Action();

            action2.ActionID = 102;

            mapper.SetRelationship(action1, "relationshipTypeCV", action2);

            var relatedAction = mapper.Draft(esdatModel);

            Assert.AreEqual(action1.ActionID, relatedAction.ActionID);
            Assert.AreEqual("relationshipTypeCV", relatedAction.RelationshipTypeCV);
            Assert.AreEqual(action2.ActionID, relatedAction.RelatedActionID);
            Assert.AreEqual(action1, relatedAction.Action);
            Assert.AreEqual(action2, relatedAction.Action1);
        }
        public void Scaffold()
        {
            var esdatModel = new ESDATModel();

            var labName = "XYZ Labs";
            var sample  = new SampleFileData();

            sample.LabName = labName;

            var chemistry = new ChemistryFileData();

            var mockDb               = new Mock <IDbContext>();
            var mockDbContext        = mockDb.Object;
            var duplicateChecker     = new ODM2DuplicateChecker(mockDbContext);
            var defaultValueProvider = new StaticWQDefaultValueProvider();
            var wayToHandleNewData   = WayToHandleNewData.ThrowExceptionForNewData;
            var results              = new List <IResult>();
            var mapper               = new SampleCollectionOrganizationMapper(duplicateChecker, defaultValueProvider, wayToHandleNewData, results);

            var organization = mapper.Draft(esdatModel);

            Assert.AreEqual(defaultValueProvider.OrganizationTypeCVSampleCollection, organization.OrganizationTypeCV);
            Assert.AreEqual(mapper.GetOrganizationCode(defaultValueProvider.OrganizationNameSampleCollection), organization.OrganizationCode);
            Assert.AreEqual(defaultValueProvider.OrganizationNameSampleCollection, organization.OrganizationName);
        }
        public void ScaffoldTest()
        {
            var chemistry = new ChemistryFileData();
            chemistry.OriginalChemName = "XYZ";

            var esdatModel = new ESDATModel();
            var sample = new SampleFileData();
            var mockDb = new Mock<IDbContext>();
            var mockDbContext = mockDb.Object;
            var duplicateChecker = new ODM2DuplicateChecker(mockDbContext);
            var defaultValueProvider = new StaticWQDefaultValueProvider();
            var wayToHandleNewData = WayToHandleNewData.ThrowExceptionForNewData;
            var results = new List<IResult>();
            var mapper = new ChemistryVariableMapper(duplicateChecker, defaultValueProvider, wayToHandleNewData, results);

            var variable = mapper.Draft(esdatModel, chemistry);            

            Assert.AreEqual(defaultValueProvider.DefaultVariableTypeCVChemistry, variable.VariableTypeCV);
            Assert.AreEqual(chemistry.ChemCode, variable.VariableCode);

            // This is temporarily hard-coded
            Assert.AreEqual("1,1,1-Trichloroethane", variable.VariableNameCV);

            Assert.AreEqual(chemistry.OriginalChemName, variable.VariableDefinition);
            Assert.AreEqual(defaultValueProvider.DefaultVariableSpeciationCV, variable.SpeciationCV);
            Assert.AreEqual(defaultValueProvider.DefaultVariableNoDataValue, variable.NoDataValue);
        }
        public void ScaffoldTest()
        {
            var esdatModel = new ESDATModel();

            var mockDb = new Mock<IDbContext>();
            var mockDbContext = mockDb.Object;
            var duplicateChecker = new ODM2DuplicateChecker(mockDbContext);
            var defaultValueProvider = new StaticWQDefaultValueProvider();
            var wayToHandleNewData = WayToHandleNewData.ThrowExceptionForNewData;
            var results = new List<IResult>();
            var mapper = new RelatedActionMapper(duplicateChecker, defaultValueProvider, wayToHandleNewData, results);

            var action1 = new Core.Action();
            action1.ActionID = 101;

            var action2 = new Core.Action();
            action2.ActionID = 102;

            mapper.SetRelationship(action1, "relationshipTypeCV", action2);

            var relatedAction = mapper.Draft(esdatModel);

            Assert.AreEqual(action1.ActionID, relatedAction.ActionID);
            Assert.AreEqual("relationshipTypeCV", relatedAction.RelationshipTypeCV);
            Assert.AreEqual(action2.ActionID, relatedAction.RelatedActionID);
            Assert.AreEqual(action1, relatedAction.Action);
            Assert.AreEqual(action2, relatedAction.Action1);
        }
        public FeatureAction Draft(ESDATModel esdatModel, ChemistryFileData chemistry)
        {
            var entity = new FeatureAction();

            Validate(entity);

            return(entity);
        }
        public Affiliation Map(ESDATModel esdatModel)
        {
            var entity = Draft(esdatModel);

            entity = GetDuplicate(_wayToHandleNewData, entity);

            return(entity);
        }
Ejemplo n.º 8
0
        public SamplingFeature Map(ESDATModel esdatModel)
        {
            var entity = Draft(esdatModel);

            entity = GetDuplicate(_wayToHandleNewData, entity);

            return(entity);
        }
Ejemplo n.º 9
0
        public DatasetsResult Draft(ESDATModel esdatModel)
        {
            var entity = new DatasetsResult();

            Validate(entity);

            return(entity);
        }
Ejemplo n.º 10
0
        public Unit Map(ESDATModel esdatModel, ChemistryFileData chemistry)
        {
            var entity = Draft(esdatModel, chemistry);

            entity = GetDuplicate(_wayToHandleNewData, entity);

            return(entity);
        }
        public ProcessingLevel Map(ESDATModel esdatModel)
        {
            var entity = Draft(esdatModel);

            entity = GetDuplicate(_wayToHandleNewData, entity);

            return(entity);
        }
Ejemplo n.º 12
0
        public FeatureAction Draft(ESDATModel esdatModel)
        {
            var entity = new FeatureAction();

            Validate(entity);

            return(entity);
        }
        public ProcessingLevel Draft(ESDATModel esdatModel)
        {
            var entity = new ProcessingLevel();

            entity.ProcessingLevelCode = _WQDefaultValueProvider.DefaultProcessingLevelCode;

            Validate(entity);

            return(entity);
        }
        public ActionBy Draft(ESDATModel esdatModel)
        {
            var entity = new ActionBy();

            entity.IsActionLead = true;

            Validate(entity);

            return(entity);
        }
        public Core.Action Draft(ESDATModel esdatModel)
        {
            var entity = new Core.Action();

            entity.ActionTypeCV  = _WQDefaultValueProvider.ActionTypeCVSampleCollection;
            entity.BeginDateTime = esdatModel.DateReported;

            Validate(entity);

            return(entity);
        }
Ejemplo n.º 16
0
        public MeasurementResultValue Draft(ESDATModel esdatModel, ChemistryFileData chemistry)
        {
            var entity = new MeasurementResultValue();

            entity.DataValue     = (double)chemistry.Result;
            entity.ValueDateTime = chemistry.AnalysedDate;

            Validate(entity);

            return(entity);
        }
        public Method Draft(ESDATModel esdatModel)
        {
            var entity = new Method();

            entity.MethodTypeCV = _WQDefaultValueProvider.DefaultMethodTypeCVSampleCollection;
            entity.MethodCode   = string.Empty;
            entity.MethodName   = _WQDefaultValueProvider.DefaultMethodTypeCVSampleCollection;

            Validate(entity);

            return(entity);
        }
        public Person Draft(ESDATModel esdatModel)
        {
            var entity = new Person();

            entity.PersonFirstName  = _WQDefaultValueProvider.DefaultPersonFirstName;
            entity.PersonMiddleName = _WQDefaultValueProvider.DefaultPersonMiddleName;
            entity.PersonLastName   = _WQDefaultValueProvider.DefaultPersonLastName;

            Validate(entity);

            return(entity);
        }
        public MeasurementResult Draft(ESDATModel esdatModel, ChemistryFileData chemistry)
        {
            var entity = new MeasurementResult();

            entity.CensorCodeCV           = _WQDefaultValueProvider.MeasurementResultCensorCodeCVChemistry;
            entity.QualityCodeCV          = _WQDefaultValueProvider.MeasurementResultQualityCodeCVChemistry;
            entity.AggregationStatisticCV = _WQDefaultValueProvider.MeasurementResultAggregationStatisticCVChemistry;

            Validate(entity);

            return(entity);
        }
Ejemplo n.º 20
0
        public Core.Action Draft(ESDATModel esdatModel, ChemistryFileData chemistry)
        {
            var entity = new Core.Action();

            entity.ActionTypeCV  = _WQDefaultValueProvider.ActionTypeCVChemistry;
            entity.BeginDateTime = chemistry.ExtractionDate;
            entity.EndDateTime   = chemistry.AnalysedDate;

            Validate(entity);

            return(entity);
        }
        public Organization Draft(ESDATModel esdatModel)
        {
            var entity = new Organization();

            entity.OrganizationTypeCV = _WQDefaultValueProvider.OrganizationTypeCVSampleCollection;
            entity.OrganizationCode   = GetOrganizationCode(_WQDefaultValueProvider.OrganizationNameSampleCollection);
            entity.OrganizationName   = _WQDefaultValueProvider.OrganizationNameSampleCollection;

            Validate(entity);

            return(entity);
        }
        public Method Draft(ESDATModel esdatModel, ChemistryFileData chemistry)
        {
            var entity = new Method();

            entity.MethodTypeCV = _WQDefaultValueProvider.DefaultMethodTypeCVChemistry;
            entity.MethodCode   = chemistry.MethodType;
            entity.MethodName   = chemistry.MethodName;

            Validate(entity);

            return(entity);
        }
Ejemplo n.º 23
0
        public Unit Draft(ESDATModel esdatModel)
        {
            var entity = new Unit();

            entity.UnitsTypeCV       = _WQDefaultValueProvider.DefaultUnitsTypeCVSampleCollection;
            entity.UnitsAbbreviation = AbbereviateUnit(_WQDefaultValueProvider.DefaultUnitsTypeCVSampleCollection);
            entity.UnitsName         = _WQDefaultValueProvider.DefaultUnitsTypeCVSampleCollection;

            Validate(entity);

            return(entity);
        }
Ejemplo n.º 24
0
        public SamplingFeature Draft(ESDATModel esdatModel)
        {
            var entity = new SamplingFeature();

            entity.SamplingFeatureTypeCV = _WQDefaultValueProvider.DefaultSamplingFeatureTypeCVSampleCollection;
            entity.SamplingFeatureCode   = _WQDefaultValueProvider.DefaultSamplingFeatureCodeSampleCollection;
            entity.SamplingFeatureName   = _WQDefaultValueProvider.DefaultSamplingFeatureNameSampleCollection;
            entity.SamplingFeatureUUID   = _WQDefaultValueProvider.DefaultSamplingFeatureUUIDSampleCollection;

            Validate(entity);

            return(entity);
        }
        public Affiliation Draft(ESDATModel esdatModel)
        {
            var entity = new Affiliation();

            entity.AffiliationStartDate = DateTime.Today;
            entity.PrimaryEmail         = string.Empty;

            ODM2EntityLinker.Link(entity, Person);

            Validate(entity);

            return(entity);
        }
        public SamplingFeature Draft(ESDATModel esdatModel, ChemistryFileData chemistry)
        {
            var entity = new SamplingFeature();

            entity.SamplingFeatureTypeCV = _WQDefaultValueProvider.DefaultSamplingFeatureTypeCVChemistry;
            entity.SamplingFeatureCode   = _WQDefaultValueProvider.DefaultSamplingFeatureCodeChemistry;
            entity.SamplingFeatureName   = _WQDefaultValueProvider.DefaultSamplingFeatureNameChemistry;
            entity.SamplingFeatureUUID   = _WQDefaultValueProvider.DefaultSamplingFeatureUUIDChemistry;

            Validate(entity);

            return(entity);
        }
        public Dataset Draft(ESDATModel esdatModel)
        {
            var entity = new Dataset();

            entity.DatasetTypeCV   = _WQDefaultValueProvider.DefaultDatasetTypeCV;
            entity.DatasetUUID     = Guid;
            entity.DatasetCode     = esdatModel.LabRequestId.ToString();
            entity.DatasetTitle    = String.Format("{0}: {1} ({2})", esdatModel.LabName, esdatModel.LabRequestId.ToString(), esdatModel.DateReported);
            entity.DatasetAbstract = string.Empty;

            Validate(entity);

            return(entity);
        }
Ejemplo n.º 28
0
        public RelatedAction Draft(ESDATModel esdatModel)
        {
            var entity = new RelatedAction();

            entity.ActionID           = _action.ActionID;
            entity.RelationshipTypeCV = _relationshipTypeCV;
            entity.RelatedActionID    = _action1.ActionID;
            entity.Action             = _action;
            entity.Action1            = _action1;

            Validate(entity);

            return(entity);
        }
        public Result Draft(ESDATModel esdatModel, ChemistryFileData chemistry)
        {
            var entity = new Result();

            entity.ResultUUID      = Guid.NewGuid();
            entity.ResultTypeCV    = _WQDefaultValueProvider.ResultTypeCVChemistry;
            entity.ResultDateTime  = chemistry.AnalysedDate;
            entity.SampledMediumCV = _WQDefaultValueProvider.ResultSampledMediumCVChemistry;
            entity.ValueCount      = 1;

            Validate(entity);

            return(entity);
        }
        public Result Draft(ESDATModel esdatModel)
        {
            var entity = new Result();

            entity.ResultUUID      = Guid.NewGuid();
            entity.ResultTypeCV    = _WQDefaultValueProvider.ResultTypeCVSampleCollection;
            entity.ResultDateTime  = Sample.SampledDateTime;
            entity.SampledMediumCV = _WQDefaultValueProvider.ResultSampledMediumCVSampleCollection;
            entity.ValueCount      = 1;

            Validate(entity);

            return(entity);
        }
Ejemplo n.º 31
0
        public Unit Draft(ESDATModel esdatModel, ChemistryFileData chemistry)
        {
            var entity = new Unit();

            string resultUnit = chemistry.ResultUnit;

            entity.UnitsTypeCV       = _WQDefaultValueProvider.DefaultUnitsTypeCVChemistry;
            entity.UnitsAbbreviation = AbbereviateUnit(resultUnit);
            entity.UnitsName         = resultUnit;

            Validate(entity);

            return(entity);
        }
        public IEnumerable <IResult> Convert(ESDATModel model)
        {
            var action = Map(model);

            var resultLevel = ResultLevel.INFO;
            var location    = new ODM2ConverterSourceLocation(this.ToString(), "Core.Action");
            var message     = string.Format("{0}: Core.Action is mappped.", location);
            var result      = new ParsingResult(resultLevel, message, action, location);

            _iResults.Add(result);
            PrintToConsole(message);

            return(_iResults);
        }
        public void Scaffold()
        {
            var esdatModel = new ESDATModel();

            var mockDb = new Mock<IDbContext>();
            var mockDbContext = mockDb.Object;
            var duplicateChecker = new ODM2DuplicateChecker(mockDbContext);
            var defaultValueProvider = new StaticWQDefaultValueProvider();
            var wayToHandleNewData = WayToHandleNewData.ThrowExceptionForNewData;
            var results = new List<IResult>();
            var mapper = new ProcessingLevelMapper(duplicateChecker, defaultValueProvider, wayToHandleNewData, results);

            var processingLevel = mapper.Draft(esdatModel);

            Assert.AreEqual(defaultValueProvider.DefaultProcessingLevelCode, processingLevel.ProcessingLevelCode);
        }
        public void ScaffoldChemistryTest()
        {
            var esdatModel = new ESDATModel();

            var mockDb = new Mock<IDbContext>();
            var mockDbContext = mockDb.Object;
            var duplicateChecker = new ODM2DuplicateChecker(mockDbContext);
            var defaultValueProvider = new StaticWQDefaultValueProvider();
            var wayToHandleNewData = WayToHandleNewData.ThrowExceptionForNewData;
            var results = new List<IResult>();
            var mapper = new DatasetsResultMapper(duplicateChecker, defaultValueProvider, wayToHandleNewData, results);

            var datasetsResult = mapper.Draft(esdatModel);

            Assert.AreEqual(0, datasetsResult.BridgeID);
            Assert.AreEqual(0, datasetsResult.DatasetID);
            Assert.AreEqual(0, datasetsResult.ResultID);
        }
        public void ScaffoldTest()
        {
            var esdatModel = new ESDATModel();

            var mockDb = new Mock<IDbContext>();
            var mockDbContext = mockDb.Object;
            var duplicateChecker = new ODM2DuplicateChecker(mockDbContext);
            var defaultValueProvider = new StaticWQDefaultValueProvider();
            var wayToHandleNewData = WayToHandleNewData.ThrowExceptionForNewData;
            var results = new List<IResult>();
            var mapper = new SampleCollectionMethodMapper(duplicateChecker, defaultValueProvider, wayToHandleNewData, results);

            var method = mapper.Draft(esdatModel);

            Assert.AreEqual(defaultValueProvider.DefaultMethodTypeCVSampleCollection, method.MethodTypeCV);
            Assert.AreEqual(string.Empty, method.MethodCode);
            Assert.AreEqual(defaultValueProvider.DefaultMethodTypeCVSampleCollection, method.MethodName);
        }
        public void ScaffoldTest()
        {
            var esdatModel = new ESDATModel();

            var mockDb = new Mock<IDbContext>();
            var mockDbContext = mockDb.Object;
            var duplicateChecker = new ODM2DuplicateChecker(mockDbContext);
            var defaultValueProvider = new StaticWQDefaultValueProvider();
            var wayToHandleNewData = WayToHandleNewData.ThrowExceptionForNewData;
            var results = new List<IResult>();
            var mapper = new SampleCollectionUnitMapper(duplicateChecker, defaultValueProvider, wayToHandleNewData, results);

            var unit = mapper.Draft(esdatModel);

            Assert.AreEqual(defaultValueProvider.DefaultUnitsTypeCVSampleCollection, unit.UnitsTypeCV);
            Assert.AreEqual(mapper.AbbereviateUnit(defaultValueProvider.DefaultUnitsTypeCVSampleCollection), unit.UnitsAbbreviation);
            Assert.AreEqual(defaultValueProvider.DefaultUnitsTypeCVSampleCollection, unit.UnitsName);
        }
        public void ScaffoldTest()
        {
            var esdatModel = new ESDATModel();

            var mockDb = new Mock<IDbContext>();
            var mockDbContext = mockDb.Object;
            var duplicateChecker = new ODM2DuplicateChecker(mockDbContext);
            var defaultValueProvider = new StaticWQDefaultValueProvider();
            var wayToHandleNewData = WayToHandleNewData.ThrowExceptionForNewData;
            var results = new List<IResult>();
            var mapper = new SampleCollectionSamplingFeatureMapper(duplicateChecker, defaultValueProvider, wayToHandleNewData, results);

            var samplingFeature = mapper.Draft(esdatModel);

            Assert.AreEqual(defaultValueProvider.DefaultSamplingFeatureTypeCVSampleCollection, samplingFeature.SamplingFeatureTypeCV);
            Assert.AreEqual(defaultValueProvider.DefaultSamplingFeatureCode, samplingFeature.SamplingFeatureCode);
            Assert.AreEqual(new Guid(), samplingFeature.SamplingFeatureUUID);
        }
        public void ScaffoldTest()
        {
            var esdatModel = new ESDATModel();

            var mockDb = new Mock<IDbContext>();
            var mockDbContext = mockDb.Object;
            var duplicateChecker = new ODM2DuplicateChecker(mockDbContext);
            var defaultValueProvider = new StaticWQDefaultValueProvider();
            var wayToHandleNewData = WayToHandleNewData.ThrowExceptionForNewData;
            var results = new List<IResult>();
            var mapper = new ActionByMapper(duplicateChecker, defaultValueProvider, wayToHandleNewData, results);

            var action = new Core.Action();
            action.ActionID = 101;

            var actionBy = mapper.Draft(esdatModel);

            Assert.AreEqual(true, actionBy.IsActionLead);
        }
        public void Scaffold()
        {
            var esdatModel = new ESDATModel();

            var mockDb = new Mock<IDbContext>();
            var mockDbContext = mockDb.Object;
            var duplicateChecker = new ODM2DuplicateChecker(mockDbContext);
            var defaultValueProvider = new StaticWQDefaultValueProvider();
            var wayToHandleNewData = WayToHandleNewData.ThrowExceptionForNewData;
            var results = new List<IResult>();
            var mapper = new PersonMapper(duplicateChecker, defaultValueProvider, wayToHandleNewData, results);

            var affiliation = new Affiliation();
            var person = mapper.Draft(esdatModel);

            Assert.AreEqual(defaultValueProvider.DefaultPersonFirstName, person.PersonFirstName);
            Assert.AreEqual(defaultValueProvider.DefaultPersonMiddleName, person.PersonMiddleName);
            Assert.AreEqual(defaultValueProvider.DefaultPersonLastName, person.PersonLastName);
        }
        public void ScaffoldTest()
        {
            var chemistry = new ChemistryFileData();

            var esdatModel = new ESDATModel();
            var sample = new SampleFileData();
            var mockDb = new Mock<IDbContext>();
            var mockDbContext = mockDb.Object;
            var duplicateChecker = new ODM2DuplicateChecker(mockDbContext);
            var defaultValueProvider = new StaticWQDefaultValueProvider();
            var wayToHandleNewData = WayToHandleNewData.ThrowExceptionForNewData;
            var results = new List<IResult>();
            var mapper = new ChemistryFeatureActionMapper(duplicateChecker, defaultValueProvider, wayToHandleNewData, results);

            var featureAction = mapper.Draft(esdatModel, chemistry);

            Assert.AreEqual(0, featureAction.FeatureActionID);
            Assert.AreEqual(0, featureAction.SamplingFeatureID);
            Assert.AreEqual(0, featureAction.ActionID);
        }
        public void ScaffoldTest()
        {
            var esdatModel = new ESDATModel();

            var mockDb = new Mock<IDbContext>();
            var mockDbContext = mockDb.Object;
            var duplicateChecker = new ODM2DuplicateChecker(mockDbContext);
            var defaultValueProvider = new StaticWQDefaultValueProvider();
            var wayToHandleNewData = WayToHandleNewData.ThrowExceptionForNewData;
            var results = new List<IResult>();
            var mapper = new DatasetMapper(duplicateChecker, defaultValueProvider, wayToHandleNewData, results);

            var datasetsResult = new DatasetsResult();
            var dataSet = mapper.Draft(esdatModel);

            Assert.AreEqual(defaultValueProvider.DefaultDatasetTypeCV, dataSet.DatasetTypeCV);
            Assert.AreEqual(esdatModel.LabRequestId.ToString(), dataSet.DatasetCode);
            Assert.AreEqual(String.Format("{0}: {1} ({2})", esdatModel.LabName, esdatModel.LabRequestId.ToString(), esdatModel.DateReported), dataSet.DatasetTitle);
            Assert.AreEqual(string.Empty, dataSet.DatasetAbstract);
        }
        public void ScaffoldTest()
        {
            var chemistry = new ChemistryFileData();

            var esdatModel = new ESDATModel();
            var sample = new SampleFileData();
            var mockDb = new Mock<IDbContext>();
            var mockDbContext = mockDb.Object;
            var duplicateChecker = new ODM2DuplicateChecker(mockDbContext);
            var defaultValueProvider = new StaticWQDefaultValueProvider();
            var wayToHandleNewData = WayToHandleNewData.ThrowExceptionForNewData;
            var results = new List<IResult>();
            var mapper = new ChemistryMeasurementResultMapper(duplicateChecker, defaultValueProvider, wayToHandleNewData, results);

            var measurementResult = mapper.Draft(esdatModel, chemistry);

            Assert.AreEqual(defaultValueProvider.MeasurementResultCensorCodeCVChemistry, measurementResult.CensorCodeCV);
            Assert.AreEqual(defaultValueProvider.MeasurementResultQualityCodeCVChemistry, measurementResult.QualityCodeCV);
            Assert.AreEqual(defaultValueProvider.MeasurementResultAggregationStatisticCVChemistry, measurementResult.AggregationStatisticCV);
        }
        public void ScaffoldTest()
        {
            var esdatModel = new ESDATModel();
            esdatModel.DateReported = DateTime.Now;

            var mockDb = new Mock<IDbContext>();
            var mockDbContext = mockDb.Object;
            var duplicateChecker = new ODM2DuplicateChecker(mockDbContext);
            var defaultValueProvider = new StaticWQDefaultValueProvider();
            var wayToHandleNewData = WayToHandleNewData.ThrowExceptionForNewData;
            var results = new List<IResult>();
            var SampleCollectionFactory = new ESDATSampleCollectionMapperFactory(duplicateChecker, defaultValueProvider, wayToHandleNewData, results);
            var chemistryFactory = new ESDATChemistryMapperFactory(duplicateChecker, defaultValueProvider, wayToHandleNewData, results);
            var mapper = new SampleCollectionActionMapper(duplicateChecker, SampleCollectionFactory, defaultValueProvider, chemistryFactory, wayToHandleNewData, results);

            var action = mapper.Draft(esdatModel);

            Assert.AreEqual(defaultValueProvider.ActionTypeCVSampleCollection, action.ActionTypeCV);
            Assert.AreEqual(esdatModel.DateReported, action.BeginDateTime);
        }
        public void ScaffoldTest()
        {
            var chemistry = new ChemistryFileData();
            chemistry.AnalysedDate = DateTime.Now;

            var esdatModel = new ESDATModel();
            var mockDb = new Mock<IDbContext>();
            var mockDbContext = mockDb.Object;
            var duplicateChecker = new ODM2DuplicateChecker(mockDbContext);
            var defaultValueProvider = new StaticWQDefaultValueProvider();
            var wayToHandleNewData = WayToHandleNewData.ThrowExceptionForNewData;
            var results = new List<IResult>();
            var factory = new ESDATChemistryMapperFactory(duplicateChecker, defaultValueProvider, wayToHandleNewData, results);
            var mapper = new ChemistryActionMapper(duplicateChecker, factory, defaultValueProvider, wayToHandleNewData, results);

            var action = mapper.Draft(esdatModel, chemistry);

            Assert.AreEqual(defaultValueProvider.ActionTypeCVChemistry, action.ActionTypeCV);
            Assert.AreEqual(chemistry.ExtractionDate, action.BeginDateTime);
            Assert.AreEqual(chemistry.AnalysedDate, action.EndDateTime);
        }
        public void ScaffoldTest()
        {
            var chemistry = new ChemistryFileData();
            chemistry.Result = 101;
            chemistry.AnalysedDate = DateTime.Now;

            var esdatModel = new ESDATModel();
            var sample = new SampleFileData();
            var mockDb = new Mock<IDbContext>();
            var mockDbContext = mockDb.Object;
            var duplicateChecker = new ODM2DuplicateChecker(mockDbContext);
            var defaultValueProvider = new StaticWQDefaultValueProvider();
            var wayToHandleNewData = WayToHandleNewData.ThrowExceptionForNewData;
            var results = new List<IResult>();
            var mapper = new ChemistryMeasurementResultValueMapper(duplicateChecker, defaultValueProvider, wayToHandleNewData, results);

            var measurementResultValue = mapper.Draft(esdatModel, chemistry);

            Assert.AreEqual(chemistry.Result, measurementResultValue.DataValue);
            Assert.AreEqual(chemistry.AnalysedDate, measurementResultValue.ValueDateTime);
        }
        public void ScaffoldTest()
        {
            var chemistry = new ChemistryFileData();

            var esdatModel = new ESDATModel();
            var sample = new SampleFileData();
            var mockDb = new Mock<IDbContext>();
            var mockDbContext = mockDb.Object;
            var duplicateChecker = new ODM2DuplicateChecker(mockDbContext);
            var defaultValueProvider = new StaticWQDefaultValueProvider();
            var wayToHandleNewData = WayToHandleNewData.ThrowExceptionForNewData;
            var results = new List<IResult>();
            var mapper = new ChemistryResultMapper(duplicateChecker, defaultValueProvider, wayToHandleNewData, results);

            var result = mapper.Draft(esdatModel, chemistry);

            Assert.AreEqual(defaultValueProvider.ResultTypeCVChemistry, result.ResultTypeCV);
            Assert.AreEqual(chemistry.AnalysedDate, result.ResultDateTime);
            Assert.AreEqual(defaultValueProvider.ResultSampledMediumCVChemistry, result.SampledMediumCV);
            Assert.AreEqual(1, result.ValueCount);
        }
        public void Scaffold()
        {
            var esdatModel = new ESDATModel();

            var labName = "XYZ Labs";
            var sample = new SampleFileData();
            sample.LabName = labName;

            var chemistry = new ChemistryFileData();

            var mockDb = new Mock<IDbContext>();
            var mockDbContext = mockDb.Object;
            var duplicateChecker = new ODM2DuplicateChecker(mockDbContext);
            var defaultValueProvider = new StaticWQDefaultValueProvider();
            var wayToHandleNewData = WayToHandleNewData.ThrowExceptionForNewData;
            var results = new List<IResult>();
            var mapper = new SampleCollectionOrganizationMapper(duplicateChecker, defaultValueProvider, wayToHandleNewData, results);

            var organization = mapper.Draft(esdatModel);

            Assert.AreEqual(defaultValueProvider.OrganizationTypeCVSampleCollection, organization.OrganizationTypeCV);
            Assert.AreEqual(mapper.GetOrganizationCode(defaultValueProvider.OrganizationNameSampleCollection), organization.OrganizationCode);
            Assert.AreEqual(defaultValueProvider.OrganizationNameSampleCollection, organization.OrganizationName);
        }
 public Core.Action Map(ESDATModel model)
 {
     return _mapper.Map(model);
 }
 public IEnumerable<IResult> Convert(ESDATModel model)
 {
     return _mapper.Convert(model);
 }