public static DataSpecificationIEC61360 ToDataSpecificationIEC61360(this EnvironmentDataSpecificationIEC61360_V1_0 environmentDataSpecification)
        {
            if (environmentDataSpecification == null)
            {
                return(null);
            }

            DataSpecificationIEC61360 dataSpecification = new DataSpecificationIEC61360(new DataSpecificationIEC61360Content()
            {
                Definition    = environmentDataSpecification.Definition,
                PreferredName = environmentDataSpecification.PreferredName,
                ShortName     = string.IsNullOrEmpty(environmentDataSpecification.ShortName) ? null :
                                new LangStringSet()
                {
                    new LangString("Undefined", environmentDataSpecification.ShortName)
                },
                SourceOfDefinition = environmentDataSpecification.SourceOfDefinition?["EN"],
                Symbol             = environmentDataSpecification.Symbol,
                Unit        = environmentDataSpecification.Unit,
                UnitId      = environmentDataSpecification.UnitId?.ToReference_V1_0(),
                Value       = null,
                ValueFormat = environmentDataSpecification.ValueFormat,
                ValueId     = null,
                ValueList   = null
            });

            if (!string.IsNullOrEmpty(environmentDataSpecification.DataType))
            {
                (dataSpecification.DataSpecificationContent as DataSpecificationIEC61360Content).DataType =
                    (DataTypeIEC61360)Enum.Parse(typeof(DataTypeIEC61360), environmentDataSpecification.DataType);
            }

            return(dataSpecification);
        }
Exemple #2
0
        public static DataSpecificationIEC61360 ToDataSpecificationIEC61360(this EnvironmentDataSpecificationIEC61360_V2_0 environmentDataSpecification)
        {
            if (environmentDataSpecification == null)
            {
                return(null);
            }

            if (!Enum.TryParse <DataTypeIEC61360>(environmentDataSpecification.DataType.ToString(), out DataTypeIEC61360 dataType))
            {
                dataType = DataTypeIEC61360.UNDEFINED;
            }

            DataSpecificationIEC61360 dataSpecification = new DataSpecificationIEC61360(new DataSpecificationIEC61360Content()
            {
                DataType           = dataType,
                Definition         = environmentDataSpecification.Definition,
                PreferredName      = environmentDataSpecification.PreferredName,
                ShortName          = environmentDataSpecification.ShortName,
                SourceOfDefinition = environmentDataSpecification.SourceOfDefinition,
                Symbol             = environmentDataSpecification.Symbol,
                Unit        = environmentDataSpecification.Unit,
                UnitId      = environmentDataSpecification.UnitId?.ToReference_V2_0(),
                Value       = environmentDataSpecification.Value,
                ValueFormat = environmentDataSpecification.ValueFormat,
                ValueId     = environmentDataSpecification.ValueId?.ToReference_V2_0(),
                ValueList   = environmentDataSpecification.ValueList?.ConvertAll(c => new Extensions.Semantics.DataSpecifications.ValueReferencePair()
                {
                    Value   = c.Value,
                    ValueId = c.ValueId?.ToReference_V2_0()
                }),
                LevelTypes = environmentDataSpecification.LevelTypes?.ConvertAll(c => (LevelType)Enum.Parse(typeof(LevelType), c.ToString()))
            });

            return(dataSpecification);
        }
Exemple #3
0
        private static void ConvertToAssetAdministrationShell(AssetAdministrationShellEnvironment_V2_0 environment)
        {
            foreach (var envAsset in environment.EnvironmentAssets)
            {
                Asset asset = new Asset
                {
                    Administration           = envAsset.Administration,
                    Category                 = envAsset.Category,
                    Description              = envAsset.Description,
                    Identification           = envAsset.Identification,
                    IdShort                  = envAsset.IdShort,
                    Kind                     = envAsset.Kind,
                    AssetIdentificationModel = envAsset.AssetIdentificationModelReference?.ToReference_V2_0 <ISubmodel>()
                };
                environment.Assets.Add(asset);
            }
            foreach (var envConceptDescription in environment.EnvironmentConceptDescriptions)
            {
                ConceptDescription conceptDescription = new ConceptDescription()
                {
                    Administration             = envConceptDescription.Administration,
                    Category                   = envConceptDescription.Category,
                    Description                = envConceptDescription.Description,
                    Identification             = envConceptDescription.Identification,
                    IdShort                    = envConceptDescription.IdShort,
                    IsCaseOf                   = envConceptDescription.IsCaseOf?.ConvertAll(c => c.ToReference_V2_0()),
                    EmbeddedDataSpecifications = (envConceptDescription.EmbeddedDataSpecification?.DataSpecificationContent?.DataSpecificationIEC61360 != null) ? new List <DataSpecificationIEC61360>() : null
                };
                if (conceptDescription.EmbeddedDataSpecifications != null)
                {
                    DataSpecificationIEC61360 dataSpecification = envConceptDescription
                                                                  .EmbeddedDataSpecification
                                                                  .DataSpecificationContent
                                                                  .DataSpecificationIEC61360
                                                                  .ToDataSpecificationIEC61360();

                    (conceptDescription.EmbeddedDataSpecifications as List <DataSpecificationIEC61360>).Add(dataSpecification);
                }
                environment.ConceptDescriptions.Add(conceptDescription);
            }
            foreach (var envSubmodel in environment.EnvironmentSubmodels)
            {
                Submodel submodel = new Submodel()
                {
                    Administration = envSubmodel.Administration,
                    Category       = envSubmodel.Category,
                    Description    = envSubmodel.Description,
                    Identification = envSubmodel.Identification,
                    IdShort        = envSubmodel.IdShort,
                    Kind           = envSubmodel.Kind,
                    Parent         = string.IsNullOrEmpty(envSubmodel.Parent) ? null :
                                     new Reference(
                        new Key(KeyElements.AssetAdministrationShell, KeyType.IRI, envSubmodel.Parent, true)),
                    SemanticId         = envSubmodel.SemanticId?.ToReference_V2_0(),
                    ConceptDescription = null,
                };
                List <ISubmodelElement> smElements = envSubmodel.SubmodelElements.ConvertAll(c => c.submodelElement?.ToSubmodelElement(environment.ConceptDescriptions));
                foreach (var smElement in smElements)
                {
                    submodel.SubmodelElements.Add(smElement);
                }

                environment.Submodels.Add(submodel);
            }
            foreach (var envAssetAdministrationShell in environment.EnvironmentAssetAdministationShells)
            {
                AssetAdministrationShell assetAdministrationShell = new AssetAdministrationShell()
                {
                    Administration = envAssetAdministrationShell.Administration,
                    Category       = envAssetAdministrationShell.Category,
                    DerivedFrom    = envAssetAdministrationShell.DerivedFrom?.ToReference_V2_0 <IAssetAdministrationShell>(),
                    Description    = envAssetAdministrationShell.Description,
                    Identification = envAssetAdministrationShell.Identification,
                    IdShort        = envAssetAdministrationShell.IdShort
                };

                IAsset asset = environment.Assets.Find(a => a.Identification.Id == envAssetAdministrationShell.AssetReference?.Keys?.FirstOrDefault()?.Value);
                assetAdministrationShell.Asset = asset;

                foreach (var envSubmodelRef in envAssetAdministrationShell.SubmodelReferences)
                {
                    ISubmodel submodel = environment.Submodels.Find(s => s.Identification.Id == envSubmodelRef.Keys?.FirstOrDefault()?.Value);
                    if (submodel != null)
                    {
                        assetAdministrationShell.Submodels.Add(submodel);
                    }
                }

                environment.AssetAdministrationShells.Add(assetAdministrationShell);
            }
        }