public AssetAdministrationShellEnvironment_V2_0 GetEnvironment_V2_0()
{
if (specPart?.Uri != null)
{
string specFilePath = specPart.Uri.ToString();
string extension = Path.GetExtension(specFilePath)?.ToLower();
AssetAdministrationShellEnvironment_V2_0 environment;
switch (extension)
{
case ".json":
{
using (Stream file = specPart.GetStream(FileMode.Open, FileAccess.Read))
environment = AssetAdministrationShellEnvironment_V2_0.ReadEnvironment_V2_0(file, ExportType.Json);
}
break;
case ".xml":
{
using (Stream file = specPart.GetStream(FileMode.Open, FileAccess.Read))
environment = AssetAdministrationShellEnvironment_V2_0.ReadEnvironment_V2_0(file, ExportType.Xml);
}
break;
default:
logger.Error("Not supported file format: " + extension);
environment = null;
break;
}
return(environment);
}
return(null);
}
public void AddEnvironment(Identifier aasId, AssetAdministrationShellEnvironment_V2_0 environment, ExportType exportType)
{
if (aasId == null)
{
throw new ArgumentNullException(nameof(aasId));
}
if (environment == null)
{
throw new ArgumentNullException(nameof(environment));
}
string aasIdName = aasId.Id;
foreach (char invalidChar in Path.GetInvalidFileNameChars())
{
aasIdName = aasIdName.Replace(invalidChar, '_');
}
string aasFilePath = AASX_FOLDER + "/" + aasIdName + "/" + aasIdName + ".aas." + exportType.ToString().ToLower();
Uri partUri = PackUriHelper.CreatePartUri(new Uri(aasFilePath, UriKind.RelativeOrAbsolute));
ClearRelationshipAndPartFromPackagePart(originPart, SPEC_RELATIONSHIP_TYPE, partUri);
specPart = aasxPackage.CreatePart(partUri, GetContentType(aasFilePath), CompressionOption.Maximum);
originPart.CreateRelationship(specPart.Uri, TargetMode.Internal, SPEC_RELATIONSHIP_TYPE);
string environmentTemp = Path.GetRandomFileName() + "." + exportType.ToString().ToLower();
environment.WriteEnvironment_V2_0(exportType, environmentTemp);
CopyFileToPackagePart(specPart, environmentTemp);
File.Delete(environmentTemp);
}
public static void WriteEnvironment_V2_0(AssetAdministrationShellEnvironment_V2_0 environment, ExportType exportType, string filePath)
{
if (environment == null)
{
return;
}
switch (exportType)
{
case ExportType.Json:
try
{
string serialized = JsonConvert.SerializeObject(environment, JsonSettings);
System.IO.File.WriteAllText(filePath, serialized);
}
catch (Exception e)
{
logger.Error(e);
}
break;
case ExportType.Xml:
try
{
using (StreamWriter writer = new StreamWriter(filePath))
{
XmlSerializer serializer = new XmlSerializer(typeof(AssetAdministrationShellEnvironment_V2_0), AAS_NAMESPACE);
XmlSerializerNamespaces namespaces = new XmlSerializerNamespaces();
namespaces.Add("xsi", XmlSchema.InstanceNamespace);
namespaces.Add("aas", AAS_NAMESPACE);
namespaces.Add("IEC61360", IEC61360_NAMESPACE);
serializer.Serialize(writer, environment, namespaces);
}
}
catch (Exception e)
{
logger.Error(e);
}
break;
default:
break;
}
}
public static AssetAdministrationShellEnvironment_V2_0 ReadEnvironment_V2_0(string filePath)
{
if (string.IsNullOrEmpty(filePath))
{
throw new ArgumentNullException(filePath);
}
if (!System.IO.File.Exists(filePath))
{
throw new ArgumentException(filePath + " does not exist");
}
AssetAdministrationShellEnvironment_V2_0 env = null;
string fileExtension = Path.GetExtension(filePath);
ExportType exportType;
switch (fileExtension)
{
case ".xml":
exportType = ExportType.Xml;
break;
case ".json":
exportType = ExportType.Json;
break;
default:
throw new InvalidOperationException(fileExtension + " not supported");
}
using (FileStream file = new FileStream(filePath, FileMode.Open, FileAccess.Read))
env = ReadEnvironment_V2_0(file, exportType);
if (env == null)
{
return(null);
}
ConvertToAssetAdministrationShell(env);
return(env);
}
public static AssetAdministrationShellEnvironment_V2_0 ReadEnvironment_V2_0(Stream stream, ExportType exportType)
{
AssetAdministrationShellEnvironment_V2_0 env = null;
try
{
switch (exportType)
{
case ExportType.Xml:
{
XmlSerializer serializer = new XmlSerializer(typeof(AssetAdministrationShellEnvironment_V2_0), AAS_NAMESPACE);
using (XmlReader reader = XmlReader.Create(stream, XmlSettings))
env = (AssetAdministrationShellEnvironment_V2_0)serializer.Deserialize(reader);
}
break;
case ExportType.Json:
{
using (StreamReader reader = new StreamReader(stream))
env = JsonConvert.DeserializeObject <AssetAdministrationShellEnvironment_V2_0>(reader.ReadToEnd(), JsonSettings);
}
break;
default:
throw new InvalidOperationException(exportType + " not supported");
}
ConvertToAssetAdministrationShell(env);
return(env);
}
catch (Exception e)
{
logger.Error(e, "Failed to read environment - Exception: " + e.Message);
return(null);
}
}
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);
}
}
