DP44/DataPRO/Modules/DatabaseImporter/DatabaseImport/ISO/TestObjectMetaData.cs

using System;
using System.Collections.Generic;
using System.Linq;

namespace DatabaseImport
{
    public class TestObjectMetaData
    {
        public static double Version { get; set; } = 1.06;
        public const string NOVALUE = "NOVALUE";

        public void SetProperty(MetaData meta)
        {
            _properties[meta.Name] = meta;
        }
        public enum CommentFields
        {
            Comment1,
            Comment2,
            Comment3,
        }
        public enum Fields
        {
            NameOfTestObject,
            VelocityOfTestObject,
            MassOfTestObject,
            DriverPositionObject,
            ImpactSideTestObject,
            TypeOfTestObject,
            ClassOfTestObject,
            CodeOfTestObject,
            RefNumberOfTestObject,
            TestObjectComments
        }
        public enum OptionFields
        {
            Offset,
            BarrierWidth,
            BarrierHeight,
            YawAngle,
            ReferenceSystem,
            OriginX,
            OriginY,
            OriginZ,
            NumberOfLoadCells
        }
        private Dictionary<string, MetaData> _properties = new Dictionary<string, MetaData>();
        public TestObjectMetaData(char testobject)
        {
            TestObject = testobject;
            var comments = Enum.GetValues(typeof(CommentFields)).Cast<CommentFields>().ToArray();
            var fields = Enum.GetValues(typeof(Fields)).Cast<Fields>().ToArray();
            var optional = Enum.GetValues(typeof(OptionFields)).Cast<OptionFields>().ToArray();
            foreach (var cfield in comments) { _properties.Add(cfield.ToString(), new MetaData(cfield.ToString(), false, NOVALUE, Version)); }
            foreach (var field in fields)
            {
                switch (field)
                {
                    case Fields.VelocityOfTestObject:
                    case Fields.MassOfTestObject:
                        _properties.Add(field.ToString(), new MetaData(field.ToString(), false, string.Empty, Version));
                        break;
                    default:
                        _properties.Add(field.ToString(), new MetaData(field.ToString(), false, NOVALUE, Version));
                        break;
                }
            }
            foreach (var ofield in optional)
            {
                _properties.Add(ofield.ToString(), new MetaData(ofield.ToString(), true, NOVALUE, Version));
            }
        }

        public char TestObject { get; } = '?';
    }
    public class MetaData
    {
        public string Name { get; }

        public bool IsOptional { get; } = false;

        public double Version { get; } = 1.06D;

        public string Value { get; set; } = "NOVALUE";

        public MetaData(string name, bool optional, string value, double version)
        {
            Name = name;
            IsOptional = optional;
            Value = value;
            Version = version;
        }
        public MetaData(MetaData copy)
        {
            Name = copy.Name;
            IsOptional = copy.IsOptional;
            Value = copy.Value;
            Version = copy.Version;
        }
    }
    public class TestSetupMetaData
    {
        public double Version { get; set; } = 1.06;
        public const string NOVALUE = "NOVALUE";
        public const string MEDIADEFAULT = "1/1";

        public void SetProperty(MetaData meta, bool requireXCrashCompatibilityForISOExports)
        {
            switch (meta.Name)
            {
                case "LaboratoryName":
                case "LaboratoryContactName":
                case "LaboratoryTestReferenceNumber":
                case "CustomerName":
                case "CustomerTestReferenceNumber":
                    if ((meta.Value == NOVALUE) && requireXCrashCompatibilityForISOExports)
                    {
                        meta.Value = string.Empty;
                    }
                    break;
            }
            _properties[meta.Name] = meta;
        }
        public enum Fields
        {
            LabName,
            LaboratoryContactName,
            LaboratoryContactPhone,
            LaboratoryContactFax,
            LaboratoryContactEmail,
            LaboratoryName,
            LaboratoryTestReferenceNumber,
            LaboratoryProjectReferenceNumber,

            CustName,
            CustomerName,
            CustomerTestReferenceNumber,
            CustomerProjectReferenceNumber,
            CustomerOrderNumber,
            CustomerCostUnit,

            TEName,
            TestEngineerName,
            TestEngineerPhone,
            TestEngineerFax,
            TestEngineerEmail,

            Title,
            MediumNoNumberOfMedia,
            TestComment,
            TypeOfTheTest,
            ReferenceTemperature,
            RelativeAirHumidity,
            Regulation,
            Subtype,
            DateOfTheTest
        }

        private Dictionary<string, MetaData> _properties = new Dictionary<string, MetaData>();
        public TestSetupMetaData(bool requireXCrashCompatibilityForISOExports)
        {
            _testObject = '_';
            var fields = Enum.GetValues(typeof(Fields)).Cast<Fields>().ToArray();
            foreach (var field in fields)
            {
                switch (field)
                {
                    case Fields.MediumNoNumberOfMedia:
                        _properties.Add(field.ToString(), new MetaData(field.ToString(), false, MEDIADEFAULT, Version));
                        break;
                    case Fields.LaboratoryName:
                    case Fields.LaboratoryContactName:
                    case Fields.LaboratoryTestReferenceNumber:
                    case Fields.CustomerName:
                    case Fields.CustomerTestReferenceNumber:
                        if (requireXCrashCompatibilityForISOExports)
                        {
                            _properties.Add(field.ToString(), new MetaData(field.ToString(), false, string.Empty, Version));
                        }
                        else
                        {
                            _properties.Add(field.ToString(), new MetaData(field.ToString(), false, NOVALUE, Version));
                        }
                        break;
                    default:
                        _properties.Add(field.ToString(), new MetaData(field.ToString(), false, NOVALUE, Version));
                        break;
                }
            }
        }
        private char _testObject = '_';
    }
}